ngx-bootstrap 3.0.1 → 3.1.4

package/dropdown/fesm5/ngx-bootstrap-dropdown.js

@@ -0,0 +1,748 @@
+import { Injectable, EventEmitter, ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, Renderer2, Directive, Input, Output, ViewContainerRef, TemplateRef, HostBinding, HostListener, NgModule } from '@angular/core';
+import { isBs3 } from 'ngx-bootstrap/utils';
+import { __values } from 'tslib';
+import { filter } from 'rxjs/operators';
+import { ComponentLoaderFactory } from 'ngx-bootstrap/component-loader';
+import { PositioningService } from 'ngx-bootstrap/positioning';
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} 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;
+    }
+    BsDropdownConfig.decorators = [
+        { type: Injectable }
+    ];
+    return BsDropdownConfig;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var BsDropdownState = /** @class */ (function () {
+    function BsDropdownState() {
+        var _this = this;
+        this.direction = 'down';
+        this.isOpenChange = new EventEmitter();
+        this.isDisabledChange = new EventEmitter();
+        this.toggleClick = new EventEmitter();
+        this.dropdownMenu = new Promise(function (resolve) {
+            _this.resolveDropdownMenu = resolve;
+        });
+    }
+    BsDropdownState.decorators = [
+        { type: Injectable }
+    ];
+    /** @nocollapse */
+    BsDropdownState.ctorParameters = function () { return []; };
+    return BsDropdownState;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var BsDropdownContainerComponent = /** @class */ (function () {
+    function BsDropdownContainerComponent(_state, cd, _renderer, _element) {
+        var _this = this;
+        this._state = _state;
+        this.cd = cd;
+        this._renderer = _renderer;
+        this._element = _element;
+        this.isOpen = false;
+        this._subscription = _state.isOpenChange.subscribe(function (value) {
+            _this.isOpen = value;
+            var /** @type {?} */ dropdown = _this._element.nativeElement.querySelector('.dropdown-menu');
+            if (dropdown && !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%)');
+                }
+            }
+            _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: Component, args: [{
+                    selector: 'bs-dropdown-container',
+                    changeDetection: 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></div>\n  "
+                }] }
+    ];
+    /** @nocollapse */
+    BsDropdownContainerComponent.ctorParameters = function () { return [
+        { type: BsDropdownState, },
+        { type: ChangeDetectorRef, },
+        { type: Renderer2, },
+        { type: ElementRef, },
+    ]; };
+    return BsDropdownContainerComponent;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var BsDropdownDirective = /** @class */ (function () {
+    function BsDropdownDirective(_elementRef, _renderer, _viewContainerRef, _cis, _config, _state) {
+        this._elementRef = _elementRef;
+        this._renderer = _renderer;
+        this._viewContainerRef = _viewContainerRef;
+        this._cis = _cis;
+        this._config = _config;
+        this._state = _state;
+        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;
+        // 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;
+        },
+        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, "insideClick", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this._state.insideClick;
+        },
+        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;
+        },
+        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", {
+        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 !isBs3();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(BsDropdownDirective.prototype, "_showInline", {
+        get: /**
+         * @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: function () { return _this.show(); }
+        });
+        // toggle visibility on toggle element click
+        this._subscriptions.push(this._state.toggleClick.subscribe(function (value) { return _this.toggle(value); }));
+        // hide dropdown if set disabled while opened
+        this._subscriptions.push(this._state.isDisabledChange
+            .pipe(filter(function (value) { return value; }))
+            .subscribe(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(function (dropdownMenu) {
+                    _this._dropdown.attachInline(dropdownMenu.viewContainer, dropdownMenu.templateRef);
+                    _this._inlinedMenu = _this._dropdown._inlineViewRef;
+                    _this.addBs4Polyfills();
+                })
+                    .catch();
+            }
+            this.addBs4Polyfills();
+            this._isInlineOpen = true;
+            this.onShown.emit(true);
+            this._state.isOpenChange.emit(true);
+            return;
+        }
+        this._state.dropdownMenu.then(function (dropdownMenu) {
+            // check direction in which dropdown should be opened
+            var /** @type {?} */ _dropup = _this.dropup ||
+                (typeof _this.dropup !== 'undefined' && _this.dropup);
+            _this._state.direction = _dropup ? 'up' : 'down';
+            var /** @type {?} */ _placement = _this.placement || (_dropup ? 'top left' : 'bottom left');
+            // show dropdown
+            // show dropdown
+            _this._dropdown
+                .attach(BsDropdownContainerComponent)
+                .to(_this.container)
+                .position({ attachment: _placement })
+                .show({
+                content: dropdownMenu.templateRef,
+                placement: _placement
+            });
+            _this._state.isOpenChange.emit(true);
+        })
+            .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 () {
+        try {
+            // clean up subscriptions and destroy dropdown
+            for (var _a = __values(this._subscriptions), _b = _a.next(); !_b.done; _b = _a.next()) {
+                var sub = _b.value;
+                sub.unsubscribe();
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        this._dropdown.dispose();
+        var e_1, _c;
+    };
+    /**
+     * @return {?}
+     */
+    BsDropdownDirective.prototype.addBs4Polyfills = /**
+     * @return {?}
+     */
+    function () {
+        if (!isBs3()) {
+            this.addShowClass();
+            this.checkRightAlignment();
+            this.addDropupStyles();
+        }
+    };
+    /**
+     * @return {?}
+     */
+    BsDropdownDirective.prototype.addShowClass = /**
+     * @return {?}
+     */
+    function () {
+        if (this._inlinedMenu && this._inlinedMenu.rootNodes[0]) {
+            this._renderer.addClass(this._inlinedMenu.rootNodes[0], 'show');
+        }
+    };
+    /**
+     * @return {?}
+     */
+    BsDropdownDirective.prototype.removeShowClass = /**
+     * @return {?}
+     */
+    function () {
+        if (this._inlinedMenu && this._inlinedMenu.rootNodes[0]) {
+            this._renderer.removeClass(this._inlinedMenu.rootNodes[0], 'show');
+        }
+    };
+    /**
+     * @return {?}
+     */
+    BsDropdownDirective.prototype.checkRightAlignment = /**
+     * @return {?}
+     */
+    function () {
+        if (this._inlinedMenu && this._inlinedMenu.rootNodes[0]) {
+            var /** @type {?} */ 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');
+        }
+    };
+    /**
+     * @return {?}
+     */
+    BsDropdownDirective.prototype.addDropupStyles = /**
+     * @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');
+        }
+    };
+    /**
+     * @return {?}
+     */
+    BsDropdownDirective.prototype.removeDropupStyles = /**
+     * @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: 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: ElementRef, },
+        { type: Renderer2, },
+        { type: ViewContainerRef, },
+        { type: ComponentLoaderFactory, },
+        { type: BsDropdownConfig, },
+        { type: BsDropdownState, },
+    ]; };
+    BsDropdownDirective.propDecorators = {
+        "placement": [{ type: Input },],
+        "triggers": [{ type: Input },],
+        "container": [{ type: Input },],
+        "dropup": [{ type: Input },],
+        "autoClose": [{ type: Input },],
+        "insideClick": [{ type: Input },],
+        "isDisabled": [{ type: Input },],
+        "isOpen": [{ type: Input },],
+        "isOpenChange": [{ type: Output },],
+        "onShown": [{ type: Output },],
+        "onHidden": [{ type: Output },],
+    };
+    return BsDropdownDirective;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} 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: Directive, args: [{
+                    selector: '[bsDropdownMenu],[dropdownMenu]',
+                    exportAs: 'bs-dropdown-menu'
+                },] }
+    ];
+    /** @nocollapse */
+    BsDropdownMenuDirective.ctorParameters = function () { return [
+        { type: BsDropdownState, },
+        { type: ViewContainerRef, },
+        { type: TemplateRef, },
+    ]; };
+    return BsDropdownMenuDirective;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var BsDropdownToggleDirective = /** @class */ (function () {
+    function BsDropdownToggleDirective(_state, _element, dropdown) {
+        var _this = this;
+        this._state = _state;
+        this._element = _element;
+        this.dropdown = dropdown;
+        this.isDisabled = null;
+        this._subscriptions = [];
+        // sync is open value with state
+        this._subscriptions.push(this._state.isOpenChange.subscribe(function (value) { return (_this.isOpen = value); }));
+        // populate disabled state
+        this._subscriptions.push(this._state.isDisabledChange.subscribe(function (value) { return (_this.isDisabled = value || null); }));
+    }
+    /**
+     * @return {?}
+     */
+    BsDropdownToggleDirective.prototype.onClick = /**
+     * @return {?}
+     */
+    function () {
+        if (this.isDisabled) {
+            return;
+        }
+        this._state.toggleClick.emit(true);
+    };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsDropdownToggleDirective.prototype.onDocumentClick = /**
+     * @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);
+        }
+    };
+    /**
+     * @return {?}
+     */
+    BsDropdownToggleDirective.prototype.onEsc = /**
+     * @return {?}
+     */
+    function () {
+        if (this._state.autoClose) {
+            this._state.toggleClick.emit(false);
+        }
+    };
+    /**
+     * @return {?}
+     */
+    BsDropdownToggleDirective.prototype.ngOnDestroy = /**
+     * @return {?}
+     */
+    function () {
+        try {
+            for (var _a = __values(this._subscriptions), _b = _a.next(); !_b.done; _b = _a.next()) {
+                var sub = _b.value;
+                sub.unsubscribe();
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        var e_1, _c;
+    };
+    BsDropdownToggleDirective.decorators = [
+        { type: Directive, args: [{
+                    selector: '[bsDropdownToggle],[dropdownToggle]',
+                    exportAs: 'bs-dropdown-toggle',
+                    host: {
+                        '[attr.aria-haspopup]': 'true'
+                    }
+                },] }
+    ];
+    /** @nocollapse */
+    BsDropdownToggleDirective.ctorParameters = function () { return [
+        { type: BsDropdownState, },
+        { type: ElementRef, },
+        { type: BsDropdownDirective, },
+    ]; };
+    BsDropdownToggleDirective.propDecorators = {
+        "isDisabled": [{ type: HostBinding, args: ['attr.disabled',] },],
+        "isOpen": [{ type: HostBinding, args: ['attr.aria-expanded',] },],
+        "onClick": [{ type: HostListener, args: ['click', [],] },],
+        "onDocumentClick": [{ type: HostListener, args: ['document:click', ['$event'],] },],
+        "onEsc": [{ type: HostListener, args: ['keyup.esc',] },],
+    };
+    return BsDropdownToggleDirective;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var BsDropdownModule = /** @class */ (function () {
+    function BsDropdownModule() {
+    }
+    // tslint:disable-next-line:no-any
+    /**
+     * @param {?=} config
+     * @return {?}
+     */
+    BsDropdownModule.forRoot = /**
+     * @param {?=} config
+     * @return {?}
+     */
+    function (config) {
+        return {
+            ngModule: BsDropdownModule,
+            providers: [
+                ComponentLoaderFactory,
+                PositioningService,
+                BsDropdownState,
+                {
+                    provide: BsDropdownConfig,
+                    useValue: config ? config : { autoClose: true, insideClick: false }
+                }
+            ]
+        };
+    };
+    BsDropdownModule.decorators = [
+        { type: NgModule, args: [{
+                    declarations: [
+                        BsDropdownMenuDirective,
+                        BsDropdownToggleDirective,
+                        BsDropdownContainerComponent,
+                        BsDropdownDirective
+                    ],
+                    exports: [
+                        BsDropdownMenuDirective,
+                        BsDropdownToggleDirective,
+                        BsDropdownDirective
+                    ],
+                    entryComponents: [BsDropdownContainerComponent]
+                },] }
+    ];
+    return BsDropdownModule;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+
+export { BsDropdownDirective, BsDropdownMenuDirective, BsDropdownToggleDirective, BsDropdownContainerComponent, BsDropdownState, BsDropdownConfig, BsDropdownModule };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ngx-bootstrap-dropdown.js.map","sources":["ng://ngx-bootstrap/dropdown/bs-dropdown.config.ts","ng://ngx-bootstrap/dropdown/bs-dropdown.state.ts","ng://ngx-bootstrap/dropdown/bs-dropdown-container.component.ts","ng://ngx-bootstrap/dropdown/bs-dropdown.directive.ts","ng://ngx-bootstrap/dropdown/bs-dropdown-menu.directive.ts","ng://ngx-bootstrap/dropdown/bs-dropdown-toggle.directive.ts","ng://ngx-bootstrap/dropdown/bs-dropdown.module.ts"],"sourcesContent":["import { Injectable } from '@angular/core';\n\n/** Default dropdown configuration */\n@Injectable()\nexport class BsDropdownConfig {\n  /** default dropdown auto closing behavior */\n  autoClose = true;\n  /** default dropdown auto closing behavior */\n  insideClick = false;\n}\n","import { EventEmitter, Injectable } from '@angular/core';\nimport { BsComponentRef } from 'ngx-bootstrap/component-loader';\n\n@Injectable()\nexport class BsDropdownState {\n  direction: 'down' | 'up' = 'down';\n  autoClose: boolean;\n  insideClick: boolean;\n  isOpenChange = new EventEmitter<boolean>();\n  isDisabledChange = new EventEmitter<boolean>();\n  toggleClick = new EventEmitter<boolean>();\n\n  /**\n   * Content to be displayed as popover.\n   */\n  // tslint:disable:no-any\n  dropdownMenu: Promise<BsComponentRef<any>>;\n  resolveDropdownMenu: (componentRef: BsComponentRef<any>) => void;\n\n  constructor() {\n    this.dropdownMenu = new Promise(resolve => {\n      this.resolveDropdownMenu = resolve;\n    });\n  }\n}\n","import {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  OnDestroy,\n  Renderer2\n} from '@angular/core';\nimport { BsDropdownState } from './bs-dropdown.state';\nimport { isBs3 } from 'ngx-bootstrap/utils';\n\n@Component({\n  selector: 'bs-dropdown-container',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  host: {\n    style: 'display:block;position: absolute;'\n  },\n  template: `\n    <div [class.dropup]=\"direction === 'up'\"\n         [class.dropdown]=\"direction === 'down'\"\n         [class.show]=\"isOpen\"\n         [class.open]=\"isOpen\"><ng-content></ng-content></div>\n  `\n})\nexport class BsDropdownContainerComponent implements OnDestroy {\n  isOpen = false;\n\n  get direction(): 'down' | 'up' {\n    return this._state.direction;\n  }\n\n// tslint:disable-next-line:no-any\n  private _subscription: any;\n\n  constructor(\n    private _state: BsDropdownState,\n    private cd: ChangeDetectorRef,\n    private _renderer: Renderer2,\n    private _element: ElementRef\n  ) {\n    this._subscription = _state.isOpenChange.subscribe((value: boolean) => {\n      this.isOpen = value;\n      const dropdown = this._element.nativeElement.querySelector('.dropdown-menu');\n      if (dropdown && !isBs3()) {\n        this._renderer.addClass(dropdown, 'show');\n        if (dropdown.classList.contains('dropdown-menu-right')) {\n          this._renderer.setStyle(dropdown, 'left', 'auto');\n          this._renderer.setStyle(dropdown, 'right', '0');\n        }\n        if (this.direction === 'up') {\n          this._renderer.setStyle(dropdown, 'top', 'auto');\n          this._renderer.setStyle(\n            dropdown,\n            'transform',\n            'translateY(-101%)'\n          );\n        }\n      }\n      this.cd.markForCheck();\n      this.cd.detectChanges();\n    });\n  }\n\n  /** @internal */\n  _contains(el: Element): boolean {\n    return this._element.nativeElement.contains(el);\n  }\n\n  ngOnDestroy(): void {\n    this._subscription.unsubscribe();\n  }\n}\n","// tslint:disable:max-file-line-count\nimport {\n  Directive,\n  ElementRef,\n  EmbeddedViewRef,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  OnInit,\n  Output,\n  Renderer2,\n  ViewContainerRef\n} from '@angular/core';\nimport { filter } from 'rxjs/operators';\nimport { Subscription } from 'rxjs';\nimport { ComponentLoader, ComponentLoaderFactory, BsComponentRef } from 'ngx-bootstrap/component-loader';\n\nimport { BsDropdownConfig } from './bs-dropdown.config';\nimport { BsDropdownContainerComponent } from './bs-dropdown-container.component';\nimport { BsDropdownState } from './bs-dropdown.state';\nimport { BsDropdownMenuDirective } from './index';\nimport { isBs3 } from 'ngx-bootstrap/utils';\n\n@Directive({\n  selector: '[bsDropdown],[dropdown]',\n  exportAs: 'bs-dropdown',\n  providers: [BsDropdownState],\n  host: {\n    '[class.dropup]': 'dropup',\n    '[class.open]': 'isOpen',\n    '[class.show]': 'isOpen && isBs4'\n  }\n})\nexport class BsDropdownDirective implements OnInit, OnDestroy {\n  /**\n   * Placement of a popover. Accepts: \"top\", \"bottom\", \"left\", \"right\"\n   */\n  @Input() placement: string;\n  /**\n   * Specifies events that should trigger. Supports a space separated list of\n   * event names.\n   */\n  @Input() triggers: string;\n  /**\n   * A selector specifying the element the popover should be appended to.\n   * Currently only supports \"body\".\n   */\n  @Input() container: string;\n\n  /**\n   * This attribute indicates that the dropdown should be opened upwards\n   */\n  @Input() dropup: boolean;\n\n  /**\n   * Indicates that dropdown will be closed on item or document click,\n   * and after pressing ESC\n   */\n  @Input()\n  set autoClose(value: boolean) {\n    this._state.autoClose = value;\n  }\n\n  get autoClose(): boolean {\n    return this._state.autoClose;\n  }\n\n  /**\n   * This attribute indicates that the dropdown shouldn't close on inside click when autoClose is set to true\n   */\n  @Input()\n  set insideClick(value: boolean) {\n    this._state.insideClick = value;\n  }\n\n  get insideClick(): boolean {\n    return this._state.insideClick;\n  }\n\n  /**\n   * Disables dropdown toggle and hides dropdown menu if opened\n   */\n  @Input()\n  set isDisabled(value: boolean) {\n    this._isDisabled = value;\n    this._state.isDisabledChange.emit(value);\n    if (value) {\n      this.hide();\n    }\n  }\n\n  get isDisabled(): boolean {\n    return this._isDisabled;\n  }\n\n  /**\n   * Returns whether or not the popover is currently being shown\n   */\n  @Input()\n  get isOpen(): boolean {\n    if (this._showInline) {\n      return this._isInlineOpen;\n    }\n\n    return this._dropdown.isShown;\n  }\n\n  set isOpen(value: boolean) {\n    if (value) {\n      this.show();\n    } else {\n      this.hide();\n    }\n  }\n\n  /**\n   * Emits an event when isOpen change\n   */\n  @Output() isOpenChange: EventEmitter<boolean>;\n\n  /**\n   * Emits an event when the popover is shown\n   */\n  @Output() onShown: EventEmitter<boolean>;\n\n  /**\n   * Emits an event when the popover is hidden\n   */\n  @Output() onHidden: EventEmitter<boolean>;\n\n  get isBs4(): boolean {\n    return !isBs3();\n  }\n\n  private _dropdown: ComponentLoader<BsDropdownContainerComponent>;\n\n  private get _showInline(): boolean {\n    return !this.container;\n  }\n\n  // todo: move to component loader\n  private _isInlineOpen = false;\n\n  private _inlinedMenu: EmbeddedViewRef<BsDropdownMenuDirective>;\n  private _isDisabled: boolean;\n  private _subscriptions: Subscription[] = [];\n  private _isInited = false;\n\n  constructor(private _elementRef: ElementRef,\n              private _renderer: Renderer2,\n              private _viewContainerRef: ViewContainerRef,\n              private _cis: ComponentLoaderFactory,\n              private _config: BsDropdownConfig,\n              private _state: BsDropdownState) {\n    // set initial dropdown state from config\n    this._state.autoClose = this._config.autoClose;\n    this._state.insideClick = this._config.insideClick;\n\n    // create dropdown component loader\n    this._dropdown = this._cis\n      .createLoader<BsDropdownContainerComponent>(\n        this._elementRef,\n        this._viewContainerRef,\n        this._renderer\n      )\n      .provide({provide: BsDropdownState, useValue: this._state});\n\n    this.onShown = this._dropdown.onShown;\n    this.onHidden = this._dropdown.onHidden;\n    this.isOpenChange = this._state.isOpenChange;\n\n  }\n\n  ngOnInit(): void {\n    // fix: seems there are an issue with `routerLinkActive`\n    // which result in duplicated call ngOnInit without call to ngOnDestroy\n    // read more: https://github.com/valor-software/ngx-bootstrap/issues/1885\n    if (this._isInited) {\n      return;\n    }\n    this._isInited = true;\n\n    // attach DOM listeners\n    this._dropdown.listen({\n      // because of dropdown inline mode\n      outsideClick: false,\n      triggers: this.triggers,\n      show: () => this.show()\n    });\n\n    // toggle visibility on toggle element click\n    this._subscriptions.push(\n      this._state.toggleClick.subscribe((value: boolean) => this.toggle(value))\n    );\n\n    // hide dropdown if set disabled while opened\n    this._subscriptions.push(\n      this._state.isDisabledChange\n        .pipe(\n          filter((value: boolean) => value)\n        )\n        .subscribe((value: boolean) => this.hide())\n    );\n  }\n\n  /**\n   * Opens an elementâs popover. This is considered a âmanualâ triggering of\n   * the popover.\n   */\n  show(): void {\n    if (this.isOpen || this.isDisabled) {\n      return;\n    }\n\n    if (this._showInline) {\n      if (!this._inlinedMenu) {\n        this._state.dropdownMenu.then(\n          (dropdownMenu: BsComponentRef<BsDropdownMenuDirective>) => {\n            this._dropdown.attachInline(\n              dropdownMenu.viewContainer,\n              dropdownMenu.templateRef\n            );\n            this._inlinedMenu = this._dropdown._inlineViewRef;\n            this.addBs4Polyfills();\n          }\n        )\n        // swallow errors\n          .catch();\n      }\n      this.addBs4Polyfills();\n      this._isInlineOpen = true;\n      this.onShown.emit(true);\n      this._state.isOpenChange.emit(true);\n\n      return;\n    }\n    this._state.dropdownMenu.then(dropdownMenu => {\n      // check direction in which dropdown should be opened\n      const _dropup =\n        this.dropup ||\n        (typeof this.dropup !== 'undefined' && this.dropup);\n      this._state.direction = _dropup ? 'up' : 'down';\n      const _placement =\n        this.placement || (_dropup ? 'top left' : 'bottom left');\n\n      // show dropdown\n      this._dropdown\n        .attach(BsDropdownContainerComponent)\n        .to(this.container)\n        .position({attachment: _placement})\n        .show({\n          content: dropdownMenu.templateRef,\n          placement: _placement\n        });\n\n      this._state.isOpenChange.emit(true);\n    })\n    // swallow error\n      .catch();\n  }\n\n  /**\n   * Closes an elementâs popover. This is considered a âmanualâ triggering of\n   * the popover.\n   */\n  hide(): void {\n    if (!this.isOpen) {\n      return;\n    }\n\n    if (this._showInline) {\n      this.removeShowClass();\n      this.removeDropupStyles();\n      this._isInlineOpen = false;\n      this.onHidden.emit(true);\n    } else {\n      this._dropdown.hide();\n    }\n\n    this._state.isOpenChange.emit(false);\n  }\n\n  /**\n   * Toggles an elementâs popover. This is considered a âmanualâ triggering of\n   * the popover. With parameter <code>true</code> allows toggling, with parameter <code>false</code>\n   * only hides opened dropdown. Parameter usage will be removed in ngx-bootstrap v3\n   */\n  toggle(value?: boolean): void {\n    if (this.isOpen || !value) {\n      return this.hide();\n    }\n\n    return this.show();\n  }\n\n  /** @internal */\n  _contains(event: any): boolean {\n    return this._elementRef.nativeElement.contains(event.target) ||\n      (this._dropdown.instance && this._dropdown.instance._contains(event.target));\n  }\n\n  ngOnDestroy(): void {\n    // clean up subscriptions and destroy dropdown\n    for (const sub of this._subscriptions) {\n      sub.unsubscribe();\n    }\n    this._dropdown.dispose();\n  }\n\n  private addBs4Polyfills(): void {\n    if (!isBs3()) {\n      this.addShowClass();\n      this.checkRightAlignment();\n      this.addDropupStyles();\n    }\n  }\n\n  private addShowClass(): void {\n    if (this._inlinedMenu && this._inlinedMenu.rootNodes[0]) {\n      this._renderer.addClass(this._inlinedMenu.rootNodes[0], 'show');\n    }\n  }\n\n  private removeShowClass(): void {\n    if (this._inlinedMenu && this._inlinedMenu.rootNodes[0]) {\n      this._renderer.removeClass(this._inlinedMenu.rootNodes[0], 'show');\n    }\n  }\n\n  private checkRightAlignment(): void {\n    if (this._inlinedMenu && this._inlinedMenu.rootNodes[0]) {\n      const isRightAligned = this._inlinedMenu.rootNodes[0].classList.contains(\n        'dropdown-menu-right'\n      );\n      this._renderer.setStyle(\n        this._inlinedMenu.rootNodes[0],\n        'left',\n        isRightAligned ? 'auto' : '0'\n      );\n      this._renderer.setStyle(\n        this._inlinedMenu.rootNodes[0],\n        'right',\n        isRightAligned ? '0' : 'auto'\n      );\n    }\n  }\n\n  private addDropupStyles(): void {\n    if (this._inlinedMenu && this._inlinedMenu.rootNodes[0]) {\n      // a little hack to not break support of bootstrap 4 beta\n      this._renderer.setStyle(\n        this._inlinedMenu.rootNodes[0],\n        'top',\n        this.dropup ? 'auto' : '100%'\n      );\n      this._renderer.setStyle(\n        this._inlinedMenu.rootNodes[0],\n        'transform',\n        this.dropup ? 'translateY(-101%)' : 'translateY(0)'\n      );\n      this._renderer.setStyle(\n        this._inlinedMenu.rootNodes[0],\n        'bottom',\n        'auto'\n      );\n    }\n  }\n\n  private removeDropupStyles(): void {\n    if (this._inlinedMenu && this._inlinedMenu.rootNodes[0]) {\n      this._renderer.removeStyle(this._inlinedMenu.rootNodes[0], 'top');\n      this._renderer.removeStyle(this._inlinedMenu.rootNodes[0], 'transform');\n      this._renderer.removeStyle(this._inlinedMenu.rootNodes[0], 'bottom');\n    }\n  }\n}\n","import { Directive, TemplateRef, ViewContainerRef } from '@angular/core';\nimport { BsDropdownState } from './bs-dropdown.state';\n\n@Directive({\n  selector: '[bsDropdownMenu],[dropdownMenu]',\n  exportAs: 'bs-dropdown-menu'\n})\nexport class BsDropdownMenuDirective {\n  // tslint:disable:no-any\n  constructor(\n    _state: BsDropdownState,\n    _viewContainer: ViewContainerRef,\n    _templateRef: TemplateRef<any>\n  ) {\n    _state.resolveDropdownMenu({\n      templateRef: _templateRef,\n      viewContainer: _viewContainer\n    });\n  }\n}\n","import {\n  Directive,\n  ElementRef,\n  HostBinding,\n  HostListener,\n  OnDestroy\n} from '@angular/core';\nimport { Subscription } from 'rxjs';\n\nimport { BsDropdownState } from './bs-dropdown.state';\nimport { BsDropdownDirective } from './bs-dropdown.directive';\n\n@Directive({\n  selector: '[bsDropdownToggle],[dropdownToggle]',\n  exportAs: 'bs-dropdown-toggle',\n  host: {\n    '[attr.aria-haspopup]': 'true'\n  }\n})\nexport class BsDropdownToggleDirective implements OnDestroy {\n  @HostBinding('attr.disabled') isDisabled: boolean = null;\n\n  // @HostBinding('class.active')\n  @HostBinding('attr.aria-expanded') isOpen: boolean;\n\n  private _subscriptions: Subscription[] = [];\n\n  constructor(private _state: BsDropdownState, private _element: ElementRef, private dropdown: BsDropdownDirective) {\n    // sync is open value with state\n    this._subscriptions.push(\n      this._state.isOpenChange.subscribe(\n        (value: boolean) => (this.isOpen = value)\n      )\n    );\n    // populate disabled state\n    this._subscriptions.push(\n      this._state.isDisabledChange.subscribe(\n        (value: boolean) => (this.isDisabled = value || null)\n      )\n    );\n  }\n\n  @HostListener('click', [])\n  onClick(): void {\n    if (this.isDisabled) {\n      return;\n    }\n    this._state.toggleClick.emit(true);\n  }\n\n  @HostListener('document:click', ['$event'])\n  onDocumentClick(event: MouseEvent): void {\n    if (\n      this._state.autoClose &&\n      event.button !== 2 &&\n      !this._element.nativeElement.contains(event.target) &&\n      !(this._state.insideClick && this.dropdown._contains(event))\n    ) {\n      this._state.toggleClick.emit(false);\n    }\n  }\n\n  @HostListener('keyup.esc')\n  onEsc(): void {\n    if (this._state.autoClose) {\n      this._state.toggleClick.emit(false);\n    }\n  }\n\n  ngOnDestroy(): void {\n    for (const sub of this._subscriptions) {\n      sub.unsubscribe();\n    }\n  }\n}\n","import { ModuleWithProviders, NgModule } from '@angular/core';\nimport { ComponentLoaderFactory } from 'ngx-bootstrap/component-loader';\n\nimport { PositioningService } from 'ngx-bootstrap/positioning';\nimport { BsDropdownContainerComponent } from './bs-dropdown-container.component';\nimport { BsDropdownMenuDirective } from './bs-dropdown-menu.directive';\nimport { BsDropdownToggleDirective } from './bs-dropdown-toggle.directive';\nimport { BsDropdownConfig } from './bs-dropdown.config';\n\nimport { BsDropdownDirective } from './bs-dropdown.directive';\nimport { BsDropdownState } from './bs-dropdown.state';\n\n@NgModule({\n  declarations: [\n    BsDropdownMenuDirective,\n    BsDropdownToggleDirective,\n    BsDropdownContainerComponent,\n    BsDropdownDirective\n  ],\n  exports: [\n    BsDropdownMenuDirective,\n    BsDropdownToggleDirective,\n    BsDropdownDirective\n  ],\n  entryComponents: [BsDropdownContainerComponent]\n})\nexport class BsDropdownModule {\n  // tslint:disable-next-line:no-any\n  static forRoot(config?: any): ModuleWithProviders {\n    return {\n      ngModule: BsDropdownModule,\n      providers: [\n        ComponentLoaderFactory,\n        PositioningService,\n        BsDropdownState,\n        {\n          provide: BsDropdownConfig,\n          useValue: config ? config : { autoClose: true, insideClick: false }\n        }\n      ]\n    };\n  }\n}\n"],"names":["tslib_1.__values"],"mappings":"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"}