ngx-bootstrap 3.0.1 → 3.1.4

package/dropdown/esm2015/bs-dropdown.directive.js

@@ -0,0 +1,408 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { Directive, ElementRef, EventEmitter, Input, Output, Renderer2, ViewContainerRef } from '@angular/core';
+import { filter } from 'rxjs/operators';
+import { ComponentLoaderFactory } from 'ngx-bootstrap/component-loader';
+import { BsDropdownConfig } from './bs-dropdown.config';
+import { BsDropdownContainerComponent } from './bs-dropdown-container.component';
+import { BsDropdownState } from './bs-dropdown.state';
+import { isBs3 } from 'ngx-bootstrap/utils';
+export class BsDropdownDirective {
+    /**
+     * @param {?} _elementRef
+     * @param {?} _renderer
+     * @param {?} _viewContainerRef
+     * @param {?} _cis
+     * @param {?} _config
+     * @param {?} _state
+     */
+    constructor(_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;
+    }
+    /**
+     * Indicates that dropdown will be closed on item or document click,
+     * and after pressing ESC
+     * @param {?} value
+     * @return {?}
+     */
+    set autoClose(value) {
+        this._state.autoClose = value;
+    }
+    /**
+     * @return {?}
+     */
+    get autoClose() {
+        return this._state.autoClose;
+    }
+    /**
+     * This attribute indicates that the dropdown shouldn't close on inside click when autoClose is set to true
+     * @param {?} value
+     * @return {?}
+     */
+    set insideClick(value) {
+        this._state.insideClick = value;
+    }
+    /**
+     * @return {?}
+     */
+    get insideClick() {
+        return this._state.insideClick;
+    }
+    /**
+     * Disables dropdown toggle and hides dropdown menu if opened
+     * @param {?} value
+     * @return {?}
+     */
+    set isDisabled(value) {
+        this._isDisabled = value;
+        this._state.isDisabledChange.emit(value);
+        if (value) {
+            this.hide();
+        }
+    }
+    /**
+     * @return {?}
+     */
+    get isDisabled() {
+        return this._isDisabled;
+    }
+    /**
+     * Returns whether or not the popover is currently being shown
+     * @return {?}
+     */
+    get isOpen() {
+        if (this._showInline) {
+            return this._isInlineOpen;
+        }
+        return this._dropdown.isShown;
+    }
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    set isOpen(value) {
+        if (value) {
+            this.show();
+        }
+        else {
+            this.hide();
+        }
+    }
+    /**
+     * @return {?}
+     */
+    get isBs4() {
+        return !isBs3();
+    }
+    /**
+     * @return {?}
+     */
+    get _showInline() {
+        return !this.container;
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+        // 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: () => this.show()
+        });
+        // toggle visibility on toggle element click
+        this._subscriptions.push(this._state.toggleClick.subscribe((value) => this.toggle(value)));
+        // hide dropdown if set disabled while opened
+        this._subscriptions.push(this._state.isDisabledChange
+            .pipe(filter((value) => value))
+            .subscribe((value) => this.hide()));
+    }
+    /**
+     * Opens an element’s popover. This is considered a “manual” triggering of
+     * the popover.
+     * @return {?}
+     */
+    show() {
+        if (this.isOpen || this.isDisabled) {
+            return;
+        }
+        if (this._showInline) {
+            if (!this._inlinedMenu) {
+                this._state.dropdownMenu.then((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(dropdownMenu => {
+            // check direction in which dropdown should be opened
+            const /** @type {?} */ _dropup = this.dropup ||
+                (typeof this.dropup !== 'undefined' && this.dropup);
+            this._state.direction = _dropup ? 'up' : 'down';
+            const /** @type {?} */ _placement = this.placement || (_dropup ? 'top left' : 'bottom left');
+            // 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.
+     * @return {?}
+     */
+    hide() {
+        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
+     * @param {?=} value
+     * @return {?}
+     */
+    toggle(value) {
+        if (this.isOpen || !value) {
+            return this.hide();
+        }
+        return this.show();
+    }
+    /**
+     * \@internal
+     * @param {?} event
+     * @return {?}
+     */
+    _contains(event) {
+        return this._elementRef.nativeElement.contains(event.target) ||
+            (this._dropdown.instance && this._dropdown.instance._contains(event.target));
+    }
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        // clean up subscriptions and destroy dropdown
+        for (const /** @type {?} */ sub of this._subscriptions) {
+            sub.unsubscribe();
+        }
+        this._dropdown.dispose();
+    }
+    /**
+     * @return {?}
+     */
+    addBs4Polyfills() {
+        if (!isBs3()) {
+            this.addShowClass();
+            this.checkRightAlignment();
+            this.addDropupStyles();
+        }
+    }
+    /**
+     * @return {?}
+     */
+    addShowClass() {
+        if (this._inlinedMenu && this._inlinedMenu.rootNodes[0]) {
+            this._renderer.addClass(this._inlinedMenu.rootNodes[0], 'show');
+        }
+    }
+    /**
+     * @return {?}
+     */
+    removeShowClass() {
+        if (this._inlinedMenu && this._inlinedMenu.rootNodes[0]) {
+            this._renderer.removeClass(this._inlinedMenu.rootNodes[0], 'show');
+        }
+    }
+    /**
+     * @return {?}
+     */
+    checkRightAlignment() {
+        if (this._inlinedMenu && this._inlinedMenu.rootNodes[0]) {
+            const /** @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 {?}
+     */
+    addDropupStyles() {
+        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 {?}
+     */
+    removeDropupStyles() {
+        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 = () => [
+    { 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 },],
+};
+function BsDropdownDirective_tsickle_Closure_declarations() {
+    /** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
+    BsDropdownDirective.decorators;
+    /**
+     * @nocollapse
+     * @type {function(): !Array<(null|{type: ?, decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>)})>}
+     */
+    BsDropdownDirective.ctorParameters;
+    /** @type {!Object<string,!Array<{type: !Function, args: (undefined|!Array<?>)}>>} */
+    BsDropdownDirective.propDecorators;
+    /**
+     * Placement of a popover. Accepts: "top", "bottom", "left", "right"
+     * @type {?}
+     */
+    BsDropdownDirective.prototype.placement;
+    /**
+     * Specifies events that should trigger. Supports a space separated list of
+     * event names.
+     * @type {?}
+     */
+    BsDropdownDirective.prototype.triggers;
+    /**
+     * A selector specifying the element the popover should be appended to.
+     * Currently only supports "body".
+     * @type {?}
+     */
+    BsDropdownDirective.prototype.container;
+    /**
+     * This attribute indicates that the dropdown should be opened upwards
+     * @type {?}
+     */
+    BsDropdownDirective.prototype.dropup;
+    /**
+     * Emits an event when isOpen change
+     * @type {?}
+     */
+    BsDropdownDirective.prototype.isOpenChange;
+    /**
+     * Emits an event when the popover is shown
+     * @type {?}
+     */
+    BsDropdownDirective.prototype.onShown;
+    /**
+     * Emits an event when the popover is hidden
+     * @type {?}
+     */
+    BsDropdownDirective.prototype.onHidden;
+    /** @type {?} */
+    BsDropdownDirective.prototype._dropdown;
+    /** @type {?} */
+    BsDropdownDirective.prototype._isInlineOpen;
+    /** @type {?} */
+    BsDropdownDirective.prototype._inlinedMenu;
+    /** @type {?} */
+    BsDropdownDirective.prototype._isDisabled;
+    /** @type {?} */
+    BsDropdownDirective.prototype._subscriptions;
+    /** @type {?} */
+    BsDropdownDirective.prototype._isInited;
+    /** @type {?} */
+    BsDropdownDirective.prototype._elementRef;
+    /** @type {?} */
+    BsDropdownDirective.prototype._renderer;
+    /** @type {?} */
+    BsDropdownDirective.prototype._viewContainerRef;
+    /** @type {?} */
+    BsDropdownDirective.prototype._cis;
+    /** @type {?} */
+    BsDropdownDirective.prototype._config;
+    /** @type {?} */
+    BsDropdownDirective.prototype._state;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bs-dropdown.directive.js","sourceRoot":"ng://ngx-bootstrap/dropdown/","sources":["bs-dropdown.directive.ts"],"names":[],"mappings":"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","sourcesContent":["// 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"]}

package/dropdown/esm2015/bs-dropdown.module.js

@@ -0,0 +1,60 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { NgModule } from '@angular/core';
+import { ComponentLoaderFactory } from 'ngx-bootstrap/component-loader';
+import { PositioningService } from 'ngx-bootstrap/positioning';
+import { BsDropdownContainerComponent } from './bs-dropdown-container.component';
+import { BsDropdownMenuDirective } from './bs-dropdown-menu.directive';
+import { BsDropdownToggleDirective } from './bs-dropdown-toggle.directive';
+import { BsDropdownConfig } from './bs-dropdown.config';
+import { BsDropdownDirective } from './bs-dropdown.directive';
+import { BsDropdownState } from './bs-dropdown.state';
+export class BsDropdownModule {
+    /**
+     * @param {?=} config
+     * @return {?}
+     */
+    static forRoot(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]
+            },] }
+];
+function BsDropdownModule_tsickle_Closure_declarations() {
+    /** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
+    BsDropdownModule.decorators;
+    /**
+     * @nocollapse
+     * @type {function(): !Array<(null|{type: ?, decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>)})>}
+     */
+    BsDropdownModule.ctorParameters;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dropdown/esm2015/bs-dropdown.state.js

@@ -0,0 +1,51 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { EventEmitter, Injectable } from '@angular/core';
+export class BsDropdownState {
+    constructor() {
+        this.direction = 'down';
+        this.isOpenChange = new EventEmitter();
+        this.isDisabledChange = new EventEmitter();
+        this.toggleClick = new EventEmitter();
+        this.dropdownMenu = new Promise(resolve => {
+            this.resolveDropdownMenu = resolve;
+        });
+    }
+}
+BsDropdownState.decorators = [
+    { type: Injectable }
+];
+/** @nocollapse */
+BsDropdownState.ctorParameters = () => [];
+function BsDropdownState_tsickle_Closure_declarations() {
+    /** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
+    BsDropdownState.decorators;
+    /**
+     * @nocollapse
+     * @type {function(): !Array<(null|{type: ?, decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>)})>}
+     */
+    BsDropdownState.ctorParameters;
+    /** @type {?} */
+    BsDropdownState.prototype.direction;
+    /** @type {?} */
+    BsDropdownState.prototype.autoClose;
+    /** @type {?} */
+    BsDropdownState.prototype.insideClick;
+    /** @type {?} */
+    BsDropdownState.prototype.isOpenChange;
+    /** @type {?} */
+    BsDropdownState.prototype.isDisabledChange;
+    /** @type {?} */
+    BsDropdownState.prototype.toggleClick;
+    /**
+     * Content to be displayed as popover.
+     * @type {?}
+     */
+    BsDropdownState.prototype.dropdownMenu;
+    /** @type {?} */
+    BsDropdownState.prototype.resolveDropdownMenu;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnMtZHJvcGRvd24uc3RhdGUuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9uZ3gtYm9vdHN0cmFwL2Ryb3Bkb3duLyIsInNvdXJjZXMiOlsiYnMtZHJvcGRvd24uc3RhdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBSXpELE1BQU07SUFlSjt5QkFkMkIsTUFBTTs0QkFHbEIsSUFBSSxZQUFZLEVBQVc7Z0NBQ3ZCLElBQUksWUFBWSxFQUFXOzJCQUNoQyxJQUFJLFlBQVksRUFBVztRQVV2QyxJQUFJLENBQUMsWUFBWSxHQUFHLElBQUksT0FBTyxDQUFDLE9BQU8sQ0FBQyxFQUFFO1lBQ3hDLElBQUksQ0FBQyxtQkFBbUIsR0FBRyxPQUFPLENBQUM7U0FDcEMsQ0FBQyxDQUFDO0tBQ0o7OztZQXBCRixVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRXZlbnRFbWl0dGVyLCBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBCc0NvbXBvbmVudFJlZiB9IGZyb20gJ25neC1ib290c3RyYXAvY29tcG9uZW50LWxvYWRlcic7XG5cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBCc0Ryb3Bkb3duU3RhdGUge1xuICBkaXJlY3Rpb246ICdkb3duJyB8ICd1cCcgPSAnZG93bic7XG4gIGF1dG9DbG9zZTogYm9vbGVhbjtcbiAgaW5zaWRlQ2xpY2s6IGJvb2xlYW47XG4gIGlzT3BlbkNoYW5nZSA9IG5ldyBFdmVudEVtaXR0ZXI8Ym9vbGVhbj4oKTtcbiAgaXNEaXNhYmxlZENoYW5nZSA9IG5ldyBFdmVudEVtaXR0ZXI8Ym9vbGVhbj4oKTtcbiAgdG9nZ2xlQ2xpY2sgPSBuZXcgRXZlbnRFbWl0dGVyPGJvb2xlYW4+KCk7XG5cbiAgLyoqXG4gICAqIENvbnRlbnQgdG8gYmUgZGlzcGxheWVkIGFzIHBvcG92ZXIuXG4gICAqL1xuICAvLyB0c2xpbnQ6ZGlzYWJsZTpuby1hbnlcbiAgZHJvcGRvd25NZW51OiBQcm9taXNlPEJzQ29tcG9uZW50UmVmPGFueT4+O1xuICByZXNvbHZlRHJvcGRvd25NZW51OiAoY29tcG9uZW50UmVmOiBCc0NvbXBvbmVudFJlZjxhbnk+KSA9PiB2b2lkO1xuXG4gIGNvbnN0cnVjdG9yKCkge1xuICAgIHRoaXMuZHJvcGRvd25NZW51ID0gbmV3IFByb21pc2UocmVzb2x2ZSA9PiB7XG4gICAgICB0aGlzLnJlc29sdmVEcm9wZG93bk1lbnUgPSByZXNvbHZlO1xuICAgIH0pO1xuICB9XG59XG4iXX0=

package/dropdown/esm2015/index.js

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+export { BsDropdownDirective, BsDropdownMenuDirective, BsDropdownToggleDirective, BsDropdownContainerComponent, BsDropdownState, BsDropdownConfig, BsDropdownModule } from './public_api';
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290Ijoibmc6Ly9uZ3gtYm9vdHN0cmFwL2Ryb3Bkb3duLyIsInNvdXJjZXMiOlsiaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztBQUFBLDJLQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcHVibGljX2FwaSc7XG4iXX0=

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

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * Generated bundle index. Do not edit.
+ */
+export { BsDropdownDirective, BsDropdownMenuDirective, BsDropdownToggleDirective, BsDropdownContainerComponent, BsDropdownState, BsDropdownConfig, BsDropdownModule } from './public_api';
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmd4LWJvb3RzdHJhcC1kcm9wZG93bi5qcyIsInNvdXJjZVJvb3QiOiJuZzovL25neC1ib290c3RyYXAvZHJvcGRvd24vIiwic291cmNlcyI6WyJuZ3gtYm9vdHN0cmFwLWRyb3Bkb3duLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7QUFJQSwyS0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljX2FwaSc7XG4iXX0=

package/dropdown/esm2015/public_api.js

@@ -0,0 +1,13 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+export { BsDropdownDirective } from './bs-dropdown.directive';
+export { BsDropdownMenuDirective } from './bs-dropdown-menu.directive';
+export { BsDropdownToggleDirective } from './bs-dropdown-toggle.directive';
+export { BsDropdownContainerComponent } from './bs-dropdown-container.component';
+export { BsDropdownState } from './bs-dropdown.state';
+export { BsDropdownConfig } from './bs-dropdown.config';
+export { BsDropdownModule } from './bs-dropdown.module';
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL25neC1ib290c3RyYXAvZHJvcGRvd24vIiwic291cmNlcyI6WyJwdWJsaWNfYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7QUFBQSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUM5RCxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUN2RSxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUMzRSxPQUFPLEVBQ0wsNEJBQTRCLEVBQzdCLE1BQU0sbUNBQW1DLENBQUM7QUFDM0MsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ3hELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgQnNEcm9wZG93bkRpcmVjdGl2ZSB9IGZyb20gJy4vYnMtZHJvcGRvd24uZGlyZWN0aXZlJztcbmV4cG9ydCB7IEJzRHJvcGRvd25NZW51RGlyZWN0aXZlIH0gZnJvbSAnLi9icy1kcm9wZG93bi1tZW51LmRpcmVjdGl2ZSc7XG5leHBvcnQgeyBCc0Ryb3Bkb3duVG9nZ2xlRGlyZWN0aXZlIH0gZnJvbSAnLi9icy1kcm9wZG93bi10b2dnbGUuZGlyZWN0aXZlJztcbmV4cG9ydCB7XG4gIEJzRHJvcGRvd25Db250YWluZXJDb21wb25lbnRcbn0gZnJvbSAnLi9icy1kcm9wZG93bi1jb250YWluZXIuY29tcG9uZW50JztcbmV4cG9ydCB7IEJzRHJvcGRvd25TdGF0ZSB9IGZyb20gJy4vYnMtZHJvcGRvd24uc3RhdGUnO1xuZXhwb3J0IHsgQnNEcm9wZG93bkNvbmZpZyB9IGZyb20gJy4vYnMtZHJvcGRvd24uY29uZmlnJztcbmV4cG9ydCB7IEJzRHJvcGRvd25Nb2R1bGUgfSBmcm9tICcuL2JzLWRyb3Bkb3duLm1vZHVsZSc7XG4iXX0=