VLEX/BPM-UI/node_modules/ngx-bootstrap/dropdown/bundles/ngx-bootstrap-dropdown.umd.js

(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('rxjs/operators'), require('ngx-bootstrap/component-loader'), require('ngx-bootstrap/utils'), require('@angular/animations'), require('ngx-bootstrap/positioning')) :
    typeof define === 'function' && define.amd ? define('ngx-bootstrap/dropdown', ['exports', '@angular/core', 'rxjs/operators', 'ngx-bootstrap/component-loader', 'ngx-bootstrap/utils', '@angular/animations', 'ngx-bootstrap/positioning'], factory) :
    (global = global || self, factory((global['ngx-bootstrap'] = global['ngx-bootstrap'] || {}, global['ngx-bootstrap'].dropdown = {}), global.ng.core, global.rxjs.operators, global.componentLoader, global.utils, global.ng.animations, global.positioning));
}(this, function (exports, core, operators, componentLoader, utils, animations, positioning) { 'use strict';

    /*! *****************************************************************************
    Copyright (c) Microsoft Corporation. All rights reserved.
    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
    this file except in compliance with the License. You may obtain a copy of the
    License at http://www.apache.org/licenses/LICENSE-2.0

    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
    MERCHANTABLITY OR NON-INFRINGEMENT.

    See the Apache Version 2.0 License for specific language governing permissions
    and limitations under the License.
    ***************************************************************************** */

    function __values(o) {
        var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
        if (m) return m.call(o);
        return {
            next: function () {
                if (o && i >= o.length) o = void 0;
                return { value: o && o[i++], done: !o };
            }
        };
    }

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /**
     * Default dropdown configuration
     */
    var BsDropdownConfig = /** @class */ (function () {
        function BsDropdownConfig() {
            /**
             * default dropdown auto closing behavior
             */
            this.autoClose = true;
            /**
             * default dropdown auto closing behavior
             */
            this.insideClick = false;
            /**
             * turn on/off animation
             */
            this.isAnimated = false;
        }
        BsDropdownConfig.decorators = [
            { type: core.Injectable }
        ];
        return BsDropdownConfig;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var BsDropdownState = /** @class */ (function () {
        function BsDropdownState() {
            var _this = this;
            this.direction = 'down';
            this.isOpenChange = new core.EventEmitter();
            this.isDisabledChange = new core.EventEmitter();
            this.toggleClick = new core.EventEmitter();
            this.dropdownMenu = new Promise((/**
             * @param {?} resolve
             * @return {?}
             */
            function (resolve) {
                _this.resolveDropdownMenu = resolve;
            }));
        }
        BsDropdownState.decorators = [
            { type: core.Injectable }
        ];
        /** @nocollapse */
        BsDropdownState.ctorParameters = function () { return []; };
        return BsDropdownState;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /** @type {?} */
    var DROPDOWN_ANIMATION_TIMING = '220ms cubic-bezier(0, 0, 0.2, 1)';
    /** @type {?} */
    var dropdownAnimation = [
        animations.style({ height: 0, overflow: 'hidden' }),
        animations.animate(DROPDOWN_ANIMATION_TIMING, animations.style({ height: '*', overflow: 'hidden' }))
    ];

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var BsDropdownContainerComponent = /** @class */ (function () {
        function BsDropdownContainerComponent(_state, cd, _renderer, _element, _builder) {
            var _this = this;
            this._state = _state;
            this.cd = cd;
            this._renderer = _renderer;
            this._element = _element;
            this.isOpen = false;
            this._factoryDropDownAnimation = _builder.build(dropdownAnimation);
            this._subscription = _state.isOpenChange.subscribe((/**
             * @param {?} value
             * @return {?}
             */
            function (value) {
                _this.isOpen = value;
                /** @type {?} */
                var dropdown = _this._element.nativeElement.querySelector('.dropdown-menu');
                _this._renderer.addClass(_this._element.nativeElement.querySelector('div'), 'open');
                if (dropdown && !utils.isBs3()) {
                    _this._renderer.addClass(dropdown, 'show');
                    if (dropdown.classList.contains('dropdown-menu-right')) {
                        _this._renderer.setStyle(dropdown, 'left', 'auto');
                        _this._renderer.setStyle(dropdown, 'right', '0');
                    }
                    if (_this.direction === 'up') {
                        _this._renderer.setStyle(dropdown, 'top', 'auto');
                        _this._renderer.setStyle(dropdown, 'transform', 'translateY(-101%)');
                    }
                }
                if (dropdown && _this._state.isAnimated) {
                    _this._factoryDropDownAnimation.create(dropdown)
                        .play();
                }
                _this.cd.markForCheck();
                _this.cd.detectChanges();
            }));
        }
        Object.defineProperty(BsDropdownContainerComponent.prototype, "direction", {
            get: /**
             * @return {?}
             */
            function () {
                return this._state.direction;
            },
            enumerable: true,
            configurable: true
        });
        /** @internal */
        /**
         * \@internal
         * @param {?} el
         * @return {?}
         */
        BsDropdownContainerComponent.prototype._contains = /**
         * \@internal
         * @param {?} el
         * @return {?}
         */
        function (el) {
            return this._element.nativeElement.contains(el);
        };
        /**
         * @return {?}
         */
        BsDropdownContainerComponent.prototype.ngOnDestroy = /**
         * @return {?}
         */
        function () {
            this._subscription.unsubscribe();
        };
        BsDropdownContainerComponent.decorators = [
            { type: core.Component, args: [{
                        selector: 'bs-dropdown-container',
                        changeDetection: core.ChangeDetectionStrategy.OnPush,
                        host: {
                            style: 'display:block;position: absolute;'
                        },
                        template: "\n    <div [class.dropup]=\"direction === 'up'\"\n         [class.dropdown]=\"direction === 'down'\"\n         [class.show]=\"isOpen\"\n         [class.open]=\"isOpen\"><ng-content></ng-content>\n    </div>\n  "
                    }] }
        ];
        /** @nocollapse */
        BsDropdownContainerComponent.ctorParameters = function () { return [
            { type: BsDropdownState },
            { type: core.ChangeDetectorRef },
            { type: core.Renderer2 },
            { type: core.ElementRef },
            { type: animations.AnimationBuilder }
        ]; };
        return BsDropdownContainerComponent;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var BsDropdownDirective = /** @class */ (function () {
        function BsDropdownDirective(_elementRef, _renderer, _viewContainerRef, _cis, _state, _config, _builder) {
            this._elementRef = _elementRef;
            this._renderer = _renderer;
            this._viewContainerRef = _viewContainerRef;
            this._cis = _cis;
            this._state = _state;
            this._config = _config;
            // todo: move to component loader
            this._isInlineOpen = false;
            this._subscriptions = [];
            this._isInited = false;
            // set initial dropdown state from config
            this._state.autoClose = this._config.autoClose;
            this._state.insideClick = this._config.insideClick;
            this._state.isAnimated = this._config.isAnimated;
            this._factoryDropDownAnimation = _builder.build(dropdownAnimation);
            // create dropdown component loader
            this._dropdown = this._cis
                .createLoader(this._elementRef, this._viewContainerRef, this._renderer)
                .provide({ provide: BsDropdownState, useValue: this._state });
            this.onShown = this._dropdown.onShown;
            this.onHidden = this._dropdown.onHidden;
            this.isOpenChange = this._state.isOpenChange;
        }
        Object.defineProperty(BsDropdownDirective.prototype, "autoClose", {
            get: /**
             * @return {?}
             */
            function () {
                return this._state.autoClose;
            },
            /**
             * Indicates that dropdown will be closed on item or document click,
             * and after pressing ESC
             */
            set: /**
             * Indicates that dropdown will be closed on item or document click,
             * and after pressing ESC
             * @param {?} value
             * @return {?}
             */
            function (value) {
                this._state.autoClose = value;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(BsDropdownDirective.prototype, "isAnimated", {
            get: /**
             * @return {?}
             */
            function () {
                return this._state.isAnimated;
            },
            /**
             * Indicates that dropdown will be animated
             */
            set: /**
             * Indicates that dropdown will be animated
             * @param {?} value
             * @return {?}
             */
            function (value) {
                this._state.isAnimated = value;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(BsDropdownDirective.prototype, "insideClick", {
            get: /**
             * @return {?}
             */
            function () {
                return this._state.insideClick;
            },
            /**
             * This attribute indicates that the dropdown shouldn't close on inside click when autoClose is set to true
             */
            set: /**
             * This attribute indicates that the dropdown shouldn't close on inside click when autoClose is set to true
             * @param {?} value
             * @return {?}
             */
            function (value) {
                this._state.insideClick = value;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(BsDropdownDirective.prototype, "isDisabled", {
            get: /**
             * @return {?}
             */
            function () {
                return this._isDisabled;
            },
            /**
             * Disables dropdown toggle and hides dropdown menu if opened
             */
            set: /**
             * Disables dropdown toggle and hides dropdown menu if opened
             * @param {?} value
             * @return {?}
             */
            function (value) {
                this._isDisabled = value;
                this._state.isDisabledChange.emit(value);
                if (value) {
                    this.hide();
                }
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(BsDropdownDirective.prototype, "isOpen", {
            /**
             * Returns whether or not the popover is currently being shown
             */
            get: /**
             * Returns whether or not the popover is currently being shown
             * @return {?}
             */
            function () {
                if (this._showInline) {
                    return this._isInlineOpen;
                }
                return this._dropdown.isShown;
            },
            set: /**
             * @param {?} value
             * @return {?}
             */
            function (value) {
                if (value) {
                    this.show();
                }
                else {
                    this.hide();
                }
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(BsDropdownDirective.prototype, "isBs4", {
            get: /**
             * @return {?}
             */
            function () {
                return !utils.isBs3();
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(BsDropdownDirective.prototype, "_showInline", {
            get: /**
             * @private
             * @return {?}
             */
            function () {
                return !this.container;
            },
            enumerable: true,
            configurable: true
        });
        /**
         * @return {?}
         */
        BsDropdownDirective.prototype.ngOnInit = /**
         * @return {?}
         */
        function () {
            var _this = this;
            // fix: seems there are an issue with `routerLinkActive`
            // which result in duplicated call ngOnInit without call to ngOnDestroy
            // read more: https://github.com/valor-software/ngx-bootstrap/issues/1885
            if (this._isInited) {
                return;
            }
            this._isInited = true;
            // attach DOM listeners
            this._dropdown.listen({
                // because of dropdown inline mode
                outsideClick: false,
                triggers: this.triggers,
                show: (/**
                 * @return {?}
                 */
                function () { return _this.show(); })
            });
            // toggle visibility on toggle element click
            this._subscriptions.push(this._state.toggleClick.subscribe((/**
             * @param {?} value
             * @return {?}
             */
            function (value) { return _this.toggle(value); })));
            // hide dropdown if set disabled while opened
            this._subscriptions.push(this._state.isDisabledChange
                .pipe(operators.filter((/**
             * @param {?} value
             * @return {?}
             */
            function (value) { return value; })))
                .subscribe((/**
             * @param {?} value
             * @return {?}
             */
            function (value) { return _this.hide(); })));
        };
        /**
         * Opens an element’s popover. This is considered a “manual” triggering of
         * the popover.
         */
        /**
         * Opens an element’s popover. This is considered a “manual” triggering of
         * the popover.
         * @return {?}
         */
        BsDropdownDirective.prototype.show = /**
         * Opens an element’s popover. This is considered a “manual” triggering of
         * the popover.
         * @return {?}
         */
        function () {
            var _this = this;
            if (this.isOpen || this.isDisabled) {
                return;
            }
            if (this._showInline) {
                if (!this._inlinedMenu) {
                    this._state.dropdownMenu.then((/**
                     * @param {?} dropdownMenu
                     * @return {?}
                     */
                    function (dropdownMenu) {
                        _this._dropdown.attachInline(dropdownMenu.viewContainer, dropdownMenu.templateRef);
                        _this._inlinedMenu = _this._dropdown._inlineViewRef;
                        _this.addBs4Polyfills();
                        _this._renderer.addClass(_this._inlinedMenu.rootNodes[0].parentNode, 'open');
                        _this.playAnimation();
                    }))
                        // swallow errors
                        .catch();
                }
                this.addBs4Polyfills();
                this._isInlineOpen = true;
                this.onShown.emit(true);
                this._state.isOpenChange.emit(true);
                this.playAnimation();
                return;
            }
            this._state.dropdownMenu.then((/**
             * @param {?} dropdownMenu
             * @return {?}
             */
            function (dropdownMenu) {
                // check direction in which dropdown should be opened
                /** @type {?} */
                var _dropup = _this.dropup ||
                    (typeof _this.dropup !== 'undefined' && _this.dropup);
                _this._state.direction = _dropup ? 'up' : 'down';
                /** @type {?} */
                var _placement = _this.placement || (_dropup ? 'top start' : 'bottom start');
                // show dropdown
                _this._dropdown
                    .attach(BsDropdownContainerComponent)
                    .to(_this.container)
                    .position({ attachment: _placement })
                    .show({
                    content: dropdownMenu.templateRef,
                    placement: _placement
                });
                _this._state.isOpenChange.emit(true);
            }))
                // swallow error
                .catch();
        };
        /**
         * Closes an element’s popover. This is considered a “manual” triggering of
         * the popover.
         */
        /**
         * Closes an element’s popover. This is considered a “manual” triggering of
         * the popover.
         * @return {?}
         */
        BsDropdownDirective.prototype.hide = /**
         * Closes an element’s popover. This is considered a “manual” triggering of
         * the popover.
         * @return {?}
         */
        function () {
            if (!this.isOpen) {
                return;
            }
            if (this._showInline) {
                this.removeShowClass();
                this.removeDropupStyles();
                this._isInlineOpen = false;
                this.onHidden.emit(true);
            }
            else {
                this._dropdown.hide();
            }
            this._state.isOpenChange.emit(false);
        };
        /**
         * Toggles an element’s popover. This is considered a “manual” triggering of
         * the popover. With parameter <code>true</code> allows toggling, with parameter <code>false</code>
         * only hides opened dropdown. Parameter usage will be removed in ngx-bootstrap v3
         */
        /**
         * Toggles an element’s popover. This is considered a “manual” triggering of
         * the popover. With parameter <code>true</code> allows toggling, with parameter <code>false</code>
         * only hides opened dropdown. Parameter usage will be removed in ngx-bootstrap v3
         * @param {?=} value
         * @return {?}
         */
        BsDropdownDirective.prototype.toggle = /**
         * Toggles an element’s popover. This is considered a “manual” triggering of
         * the popover. With parameter <code>true</code> allows toggling, with parameter <code>false</code>
         * only hides opened dropdown. Parameter usage will be removed in ngx-bootstrap v3
         * @param {?=} value
         * @return {?}
         */
        function (value) {
            if (this.isOpen || !value) {
                return this.hide();
            }
            return this.show();
        };
        /** @internal */
        /**
         * \@internal
         * @param {?} event
         * @return {?}
         */
        BsDropdownDirective.prototype._contains = /**
         * \@internal
         * @param {?} event
         * @return {?}
         */
        function (event) {
            return this._elementRef.nativeElement.contains(event.target) ||
                (this._dropdown.instance && this._dropdown.instance._contains(event.target));
        };
        /**
         * @return {?}
         */
        BsDropdownDirective.prototype.ngOnDestroy = /**
         * @return {?}
         */
        function () {
            var e_1, _a;
            try {
                // clean up subscriptions and destroy dropdown
                for (var _b = __values(this._subscriptions), _c = _b.next(); !_c.done; _c = _b.next()) {
                    var sub = _c.value;
                    sub.unsubscribe();
                }
            }
            catch (e_1_1) { e_1 = { error: e_1_1 }; }
            finally {
                try {
                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                }
                finally { if (e_1) throw e_1.error; }
            }
            this._dropdown.dispose();
        };
        /**
         * @private
         * @return {?}
         */
        BsDropdownDirective.prototype.addBs4Polyfills = /**
         * @private
         * @return {?}
         */
        function () {
            if (!utils.isBs3()) {
                this.addShowClass();
                this.checkRightAlignment();
                this.addDropupStyles();
            }
        };
        /**
         * @private
         * @return {?}
         */
        BsDropdownDirective.prototype.playAnimation = /**
         * @private
         * @return {?}
         */
        function () {
            if (this._state.isAnimated && this._inlinedMenu) {
                this._factoryDropDownAnimation.create(this._inlinedMenu.rootNodes[0])
                    .play();
            }
        };
        /**
         * @private
         * @return {?}
         */
        BsDropdownDirective.prototype.addShowClass = /**
         * @private
         * @return {?}
         */
        function () {
            if (this._inlinedMenu && this._inlinedMenu.rootNodes[0]) {
                this._renderer.addClass(this._inlinedMenu.rootNodes[0], 'show');
            }
        };
        /**
         * @private
         * @return {?}
         */
        BsDropdownDirective.prototype.removeShowClass = /**
         * @private
         * @return {?}
         */
        function () {
            if (this._inlinedMenu && this._inlinedMenu.rootNodes[0]) {
                this._renderer.removeClass(this._inlinedMenu.rootNodes[0], 'show');
            }
        };
        /**
         * @private
         * @return {?}
         */
        BsDropdownDirective.prototype.checkRightAlignment = /**
         * @private
         * @return {?}
         */
        function () {
            if (this._inlinedMenu && this._inlinedMenu.rootNodes[0]) {
                /** @type {?} */
                var isRightAligned = this._inlinedMenu.rootNodes[0].classList.contains('dropdown-menu-right');
                this._renderer.setStyle(this._inlinedMenu.rootNodes[0], 'left', isRightAligned ? 'auto' : '0');
                this._renderer.setStyle(this._inlinedMenu.rootNodes[0], 'right', isRightAligned ? '0' : 'auto');
            }
        };
        /**
         * @private
         * @return {?}
         */
        BsDropdownDirective.prototype.addDropupStyles = /**
         * @private
         * @return {?}
         */
        function () {
            if (this._inlinedMenu && this._inlinedMenu.rootNodes[0]) {
                // a little hack to not break support of bootstrap 4 beta
                this._renderer.setStyle(this._inlinedMenu.rootNodes[0], 'top', this.dropup ? 'auto' : '100%');
                this._renderer.setStyle(this._inlinedMenu.rootNodes[0], 'transform', this.dropup ? 'translateY(-101%)' : 'translateY(0)');
                this._renderer.setStyle(this._inlinedMenu.rootNodes[0], 'bottom', 'auto');
            }
        };
        /**
         * @private
         * @return {?}
         */
        BsDropdownDirective.prototype.removeDropupStyles = /**
         * @private
         * @return {?}
         */
        function () {
            if (this._inlinedMenu && this._inlinedMenu.rootNodes[0]) {
                this._renderer.removeStyle(this._inlinedMenu.rootNodes[0], 'top');
                this._renderer.removeStyle(this._inlinedMenu.rootNodes[0], 'transform');
                this._renderer.removeStyle(this._inlinedMenu.rootNodes[0], 'bottom');
            }
        };
        BsDropdownDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[bsDropdown],[dropdown]',
                        exportAs: 'bs-dropdown',
                        providers: [BsDropdownState],
                        host: {
                            '[class.dropup]': 'dropup',
                            '[class.open]': 'isOpen',
                            '[class.show]': 'isOpen && isBs4'
                        }
                    },] }
        ];
        /** @nocollapse */
        BsDropdownDirective.ctorParameters = function () { return [
            { type: core.ElementRef },
            { type: core.Renderer2 },
            { type: core.ViewContainerRef },
            { type: componentLoader.ComponentLoaderFactory },
            { type: BsDropdownState },
            { type: BsDropdownConfig },
            { type: animations.AnimationBuilder }
        ]; };
        BsDropdownDirective.propDecorators = {
            placement: [{ type: core.Input }],
            triggers: [{ type: core.Input }],
            container: [{ type: core.Input }],
            dropup: [{ type: core.Input }],
            autoClose: [{ type: core.Input }],
            isAnimated: [{ type: core.Input }],
            insideClick: [{ type: core.Input }],
            isDisabled: [{ type: core.Input }],
            isOpen: [{ type: core.Input }],
            isOpenChange: [{ type: core.Output }],
            onShown: [{ type: core.Output }],
            onHidden: [{ type: core.Output }]
        };
        return BsDropdownDirective;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var BsDropdownMenuDirective = /** @class */ (function () {
        // tslint:disable:no-any
        function BsDropdownMenuDirective(_state, _viewContainer, _templateRef) {
            _state.resolveDropdownMenu({
                templateRef: _templateRef,
                viewContainer: _viewContainer
            });
        }
        BsDropdownMenuDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[bsDropdownMenu],[dropdownMenu]',
                        exportAs: 'bs-dropdown-menu'
                    },] }
        ];
        /** @nocollapse */
        BsDropdownMenuDirective.ctorParameters = function () { return [
            { type: BsDropdownState },
            { type: core.ViewContainerRef },
            { type: core.TemplateRef }
        ]; };
        return BsDropdownMenuDirective;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var BsDropdownToggleDirective = /** @class */ (function () {
        function BsDropdownToggleDirective(_changeDetectorRef, _dropdown, _element, _renderer, _state) {
            var _this = this;
            this._changeDetectorRef = _changeDetectorRef;
            this._dropdown = _dropdown;
            this._element = _element;
            this._renderer = _renderer;
            this._state = _state;
            this.isDisabled = null;
            this._subscriptions = [];
            // sync is open value with state
            this._subscriptions.push(this._state.isOpenChange.subscribe((/**
             * @param {?} value
             * @return {?}
             */
            function (value) {
                _this.isOpen = value;
                if (value) {
                    _this._documentClickListener = _this._renderer.listen('document', 'click', (/**
                     * @param {?} event
                     * @return {?}
                     */
                    function (event) {
                        if (_this._state.autoClose && event.button !== 2 &&
                            !_this._element.nativeElement.contains(event.target) &&
                            !(_this._state.insideClick && _this._dropdown._contains(event))) {
                            _this._state.toggleClick.emit(false);
                            _this._changeDetectorRef.detectChanges();
                        }
                    }));
                    _this._escKeyUpListener = _this._renderer.listen(_this._element.nativeElement, 'keyup.esc', (/**
                     * @return {?}
                     */
                    function () {
                        if (_this._state.autoClose) {
                            _this._state.toggleClick.emit(false);
                            _this._changeDetectorRef.detectChanges();
                        }
                    }));
                }
                else {
                    _this._documentClickListener();
                    _this._escKeyUpListener();
                }
            })));
            // populate disabled state
            this._subscriptions.push(this._state.isDisabledChange.subscribe((/**
             * @param {?} value
             * @return {?}
             */
            function (value) { return (_this.isDisabled = value || null); })));
        }
        /**
         * @return {?}
         */
        BsDropdownToggleDirective.prototype.onClick = /**
         * @return {?}
         */
        function () {
            if (this.isDisabled) {
                return;
            }
            this._state.toggleClick.emit(true);
        };
        /**
         * @return {?}
         */
        BsDropdownToggleDirective.prototype.ngOnDestroy = /**
         * @return {?}
         */
        function () {
            var e_1, _a;
            if (this._documentClickListener) {
                this._documentClickListener();
            }
            if (this._escKeyUpListener) {
                this._escKeyUpListener();
            }
            try {
                for (var _b = __values(this._subscriptions), _c = _b.next(); !_c.done; _c = _b.next()) {
                    var sub = _c.value;
                    sub.unsubscribe();
                }
            }
            catch (e_1_1) { e_1 = { error: e_1_1 }; }
            finally {
                try {
                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                }
                finally { if (e_1) throw e_1.error; }
            }
        };
        BsDropdownToggleDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[bsDropdownToggle],[dropdownToggle]',
                        exportAs: 'bs-dropdown-toggle',
                        host: {
                            '[attr.aria-haspopup]': 'true'
                        }
                    },] }
        ];
        /** @nocollapse */
        BsDropdownToggleDirective.ctorParameters = function () { return [
            { type: core.ChangeDetectorRef },
            { type: BsDropdownDirective },
            { type: core.ElementRef },
            { type: core.Renderer2 },
            { type: BsDropdownState }
        ]; };
        BsDropdownToggleDirective.propDecorators = {
            isDisabled: [{ type: core.HostBinding, args: ['attr.disabled',] }],
            isOpen: [{ type: core.HostBinding, args: ['attr.aria-expanded',] }],
            onClick: [{ type: core.HostListener, args: ['click', [],] }]
        };
        return BsDropdownToggleDirective;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var BsDropdownModule = /** @class */ (function () {
        function BsDropdownModule() {
        }
        // tslint:disable-next-line:no-any
        // tslint:disable-next-line:no-any
        /**
         * @param {?=} config
         * @return {?}
         */
        BsDropdownModule.forRoot = 
        // tslint:disable-next-line:no-any
        /**
         * @param {?=} config
         * @return {?}
         */
        function (config) {
            return {
                ngModule: BsDropdownModule,
                providers: [
                    componentLoader.ComponentLoaderFactory,
                    positioning.PositioningService,
                    BsDropdownState,
                    {
                        provide: BsDropdownConfig,
                        useValue: config ? config : { autoClose: true, insideClick: false }
                    }
                ]
            };
        };
        BsDropdownModule.decorators = [
            { type: core.NgModule, args: [{
                        declarations: [
                            BsDropdownMenuDirective,
                            BsDropdownToggleDirective,
                            BsDropdownContainerComponent,
                            BsDropdownDirective
                        ],
                        exports: [
                            BsDropdownMenuDirective,
                            BsDropdownToggleDirective,
                            BsDropdownDirective
                        ],
                        entryComponents: [BsDropdownContainerComponent]
                    },] }
        ];
        return BsDropdownModule;
    }());

    exports.BsDropdownConfig = BsDropdownConfig;
    exports.BsDropdownContainerComponent = BsDropdownContainerComponent;
    exports.BsDropdownDirective = BsDropdownDirective;
    exports.BsDropdownMenuDirective = BsDropdownMenuDirective;
    exports.BsDropdownModule = BsDropdownModule;
    exports.BsDropdownState = BsDropdownState;
    exports.BsDropdownToggleDirective = BsDropdownToggleDirective;

    Object.defineProperty(exports, '__esModule', { value: true });

}));
//# sourceMappingURL=ngx-bootstrap-dropdown.umd.js.map