VLEX/BPM-UI/node_modules/@ng-bootstrap/ng-bootstrap/esm5/dropdown/dropdown.js

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
import * as tslib_1 from "tslib";
import { ChangeDetectorRef, ContentChild, ContentChildren, Directive, ElementRef, EventEmitter, forwardRef, Inject, Input, NgZone, Output, QueryList, Renderer2, Optional } from '@angular/core';
import { DOCUMENT } from '@angular/common';
import { fromEvent, Subject } from 'rxjs';
import { take } from 'rxjs/operators';
import { positionElements } from '../util/positioning';
import { ngbAutoClose } from '../util/autoclose';
import { Key } from '../util/key';
import { NgbDropdownConfig } from './dropdown-config';
var NgbNavbar = /** @class */ (function () {
    function NgbNavbar() {
    }
    NgbNavbar.decorators = [
        { type: Directive, args: [{ selector: '.navbar' },] }
    ];
    return NgbNavbar;
}());
export { NgbNavbar };
/**
 * A directive you should put on a dropdown item to enable keyboard navigation.
 * Arrow keys will move focus between items marked with this directive.
 *
 * \@since 4.1.0
 */
var NgbDropdownItem = /** @class */ (function () {
    function NgbDropdownItem(elementRef) {
        this.elementRef = elementRef;
        this._disabled = false;
    }
    Object.defineProperty(NgbDropdownItem.prototype, "disabled", {
        get: /**
         * @return {?}
         */
        function () { return this._disabled; },
        set: /**
         * @param {?} value
         * @return {?}
         */
        function (value) {
            this._disabled = (/** @type {?} */ (value)) === '' || value === true; // accept an empty attribute as true
        },
        enumerable: true,
        configurable: true
    });
    NgbDropdownItem.decorators = [
        { type: Directive, args: [{ selector: '[ngbDropdownItem]', host: { 'class': 'dropdown-item', '[class.disabled]': 'disabled' } },] }
    ];
    /** @nocollapse */
    NgbDropdownItem.ctorParameters = function () { return [
        { type: ElementRef }
    ]; };
    NgbDropdownItem.propDecorators = {
        disabled: [{ type: Input }]
    };
    return NgbDropdownItem;
}());
export { NgbDropdownItem };
if (false) {
    /**
     * @type {?}
     * @private
     */
    NgbDropdownItem.prototype._disabled;
    /** @type {?} */
    NgbDropdownItem.prototype.elementRef;
}
/**
 * A directive that wraps dropdown menu content and dropdown items.
 */
var NgbDropdownMenu = /** @class */ (function () {
    function NgbDropdownMenu(dropdown) {
        this.dropdown = dropdown;
        this.placement = 'bottom';
        this.isOpen = false;
    }
    NgbDropdownMenu.decorators = [
        { type: Directive, args: [{
                    selector: '[ngbDropdownMenu]',
                    host: {
                        '[class.dropdown-menu]': 'true',
                        '[class.show]': 'dropdown.isOpen()',
                        '[attr.x-placement]': 'placement',
                        '(keydown.ArrowUp)': 'dropdown.onKeyDown($event)',
                        '(keydown.ArrowDown)': 'dropdown.onKeyDown($event)',
                        '(keydown.Home)': 'dropdown.onKeyDown($event)',
                        '(keydown.End)': 'dropdown.onKeyDown($event)',
                        '(keydown.Enter)': 'dropdown.onKeyDown($event)',
                        '(keydown.Space)': 'dropdown.onKeyDown($event)'
                    }
                },] }
    ];
    /** @nocollapse */
    NgbDropdownMenu.ctorParameters = function () { return [
        { type: undefined, decorators: [{ type: Inject, args: [forwardRef((/**
                         * @return {?}
                         */
                        function () { return NgbDropdown; })),] }] }
    ]; };
    NgbDropdownMenu.propDecorators = {
        menuItems: [{ type: ContentChildren, args: [NgbDropdownItem,] }]
    };
    return NgbDropdownMenu;
}());
export { NgbDropdownMenu };
if (false) {
    /** @type {?} */
    NgbDropdownMenu.prototype.placement;
    /** @type {?} */
    NgbDropdownMenu.prototype.isOpen;
    /** @type {?} */
    NgbDropdownMenu.prototype.menuItems;
    /** @type {?} */
    NgbDropdownMenu.prototype.dropdown;
}
/**
 * A directive to mark an element to which dropdown menu will be anchored.
 *
 * This is a simple version of the `NgbDropdownToggle` directive.
 * It plays the same role, but doesn't listen to click events to toggle dropdown menu thus enabling support
 * for events other than click.
 *
 * \@since 1.1.0
 */
var NgbDropdownAnchor = /** @class */ (function () {
    function NgbDropdownAnchor(dropdown, _elementRef) {
        this.dropdown = dropdown;
        this._elementRef = _elementRef;
        this.anchorEl = _elementRef.nativeElement;
    }
    /**
     * @return {?}
     */
    NgbDropdownAnchor.prototype.getNativeElement = /**
     * @return {?}
     */
    function () { return this._elementRef.nativeElement; };
    NgbDropdownAnchor.decorators = [
        { type: Directive, args: [{
                    selector: '[ngbDropdownAnchor]',
                    host: { 'class': 'dropdown-toggle', 'aria-haspopup': 'true', '[attr.aria-expanded]': 'dropdown.isOpen()' }
                },] }
    ];
    /** @nocollapse */
    NgbDropdownAnchor.ctorParameters = function () { return [
        { type: undefined, decorators: [{ type: Inject, args: [forwardRef((/**
                         * @return {?}
                         */
                        function () { return NgbDropdown; })),] }] },
        { type: ElementRef }
    ]; };
    return NgbDropdownAnchor;
}());
export { NgbDropdownAnchor };
if (false) {
    /** @type {?} */
    NgbDropdownAnchor.prototype.anchorEl;
    /** @type {?} */
    NgbDropdownAnchor.prototype.dropdown;
    /**
     * @type {?}
     * @private
     */
    NgbDropdownAnchor.prototype._elementRef;
}
/**
 * A directive to mark an element that will toggle dropdown via the `click` event.
 *
 * You can also use `NgbDropdownAnchor` as an alternative.
 */
var NgbDropdownToggle = /** @class */ (function (_super) {
    tslib_1.__extends(NgbDropdownToggle, _super);
    function NgbDropdownToggle(dropdown, elementRef) {
        return _super.call(this, dropdown, elementRef) || this;
    }
    NgbDropdownToggle.decorators = [
        { type: Directive, args: [{
                    selector: '[ngbDropdownToggle]',
                    host: {
                        'class': 'dropdown-toggle',
                        'aria-haspopup': 'true',
                        '[attr.aria-expanded]': 'dropdown.isOpen()',
                        '(click)': 'dropdown.toggle()',
                        '(keydown.ArrowUp)': 'dropdown.onKeyDown($event)',
                        '(keydown.ArrowDown)': 'dropdown.onKeyDown($event)',
                        '(keydown.Home)': 'dropdown.onKeyDown($event)',
                        '(keydown.End)': 'dropdown.onKeyDown($event)'
                    },
                    providers: [{ provide: NgbDropdownAnchor, useExisting: forwardRef((/**
                             * @return {?}
                             */
                            function () { return NgbDropdownToggle; })) }]
                },] }
    ];
    /** @nocollapse */
    NgbDropdownToggle.ctorParameters = function () { return [
        { type: undefined, decorators: [{ type: Inject, args: [forwardRef((/**
                         * @return {?}
                         */
                        function () { return NgbDropdown; })),] }] },
        { type: ElementRef }
    ]; };
    return NgbDropdownToggle;
}(NgbDropdownAnchor));
export { NgbDropdownToggle };
/**
 * A directive that provides contextual overlays for displaying lists of links and more.
 */
var NgbDropdown = /** @class */ (function () {
    function NgbDropdown(_changeDetector, config, _document, _ngZone, _elementRef, _renderer, ngbNavbar) {
        var _this = this;
        this._changeDetector = _changeDetector;
        this._document = _document;
        this._ngZone = _ngZone;
        this._elementRef = _elementRef;
        this._renderer = _renderer;
        this._closed$ = new Subject();
        /**
         * Defines whether or not the dropdown menu is opened initially.
         */
        this._open = false;
        /**
         * An event fired when the dropdown is opened or closed.
         *
         * The event payload is a `boolean`:
         * * `true` - the dropdown was opened
         * * `false` - the dropdown was closed
         */
        this.openChange = new EventEmitter();
        this.placement = config.placement;
        this.container = config.container;
        this.autoClose = config.autoClose;
        this.display = ngbNavbar ? 'static' : 'dynamic';
        this._zoneSubscription = _ngZone.onStable.subscribe((/**
         * @return {?}
         */
        function () { _this._positionMenu(); }));
    }
    /**
     * @return {?}
     */
    NgbDropdown.prototype.ngAfterContentInit = /**
     * @return {?}
     */
    function () {
        var _this = this;
        this._ngZone.onStable.pipe(take(1)).subscribe((/**
         * @return {?}
         */
        function () {
            _this._applyPlacementClasses();
            if (_this._open) {
                _this._setCloseHandlers();
            }
        }));
    };
    /**
     * @param {?} changes
     * @return {?}
     */
    NgbDropdown.prototype.ngOnChanges = /**
     * @param {?} changes
     * @return {?}
     */
    function (changes) {
        if (changes.container && this._open) {
            this._applyContainer(this.container);
        }
        if (changes.placement && !changes.placement.isFirstChange) {
            this._applyPlacementClasses();
        }
    };
    /**
     * Checks if the dropdown menu is open.
     */
    /**
     * Checks if the dropdown menu is open.
     * @return {?}
     */
    NgbDropdown.prototype.isOpen = /**
     * Checks if the dropdown menu is open.
     * @return {?}
     */
    function () { return this._open; };
    /**
     * Opens the dropdown menu.
     */
    /**
     * Opens the dropdown menu.
     * @return {?}
     */
    NgbDropdown.prototype.open = /**
     * Opens the dropdown menu.
     * @return {?}
     */
    function () {
        if (!this._open) {
            this._open = true;
            this._applyContainer(this.container);
            this.openChange.emit(true);
            this._setCloseHandlers();
        }
    };
    /**
     * @private
     * @return {?}
     */
    NgbDropdown.prototype._setCloseHandlers = /**
     * @private
     * @return {?}
     */
    function () {
        var _this = this;
        /** @type {?} */
        var anchor = this._anchor;
        ngbAutoClose(this._ngZone, this._document, this.autoClose, (/**
         * @return {?}
         */
        function () { return _this.close(); }), this._closed$, this._menu ? [this._menuElement.nativeElement] : [], anchor ? [anchor.getNativeElement()] : [], '.dropdown-item,.dropdown-divider');
    };
    /**
     * Closes the dropdown menu.
     */
    /**
     * Closes the dropdown menu.
     * @return {?}
     */
    NgbDropdown.prototype.close = /**
     * Closes the dropdown menu.
     * @return {?}
     */
    function () {
        if (this._open) {
            this._open = false;
            this._resetContainer();
            this._closed$.next();
            this.openChange.emit(false);
            this._changeDetector.markForCheck();
        }
    };
    /**
     * Toggles the dropdown menu.
     */
    /**
     * Toggles the dropdown menu.
     * @return {?}
     */
    NgbDropdown.prototype.toggle = /**
     * Toggles the dropdown menu.
     * @return {?}
     */
    function () {
        if (this.isOpen()) {
            this.close();
        }
        else {
            this.open();
        }
    };
    /**
     * @return {?}
     */
    NgbDropdown.prototype.ngOnDestroy = /**
     * @return {?}
     */
    function () {
        this._resetContainer();
        this._closed$.next();
        this._zoneSubscription.unsubscribe();
    };
    /**
     * @param {?} event
     * @return {?}
     */
    NgbDropdown.prototype.onKeyDown = /**
     * @param {?} event
     * @return {?}
     */
    function (event) {
        var _this = this;
        // tslint:disable-next-line:deprecation
        /** @type {?} */
        var key = event.which;
        /** @type {?} */
        var itemElements = this._getMenuElements();
        /** @type {?} */
        var position = -1;
        /** @type {?} */
        var isEventFromItems = false;
        /** @type {?} */
        var itemElement = null;
        /** @type {?} */
        var isEventFromToggle = this._isEventFromToggle(event);
        if (!isEventFromToggle && itemElements.length) {
            itemElements.forEach((/**
             * @param {?} item
             * @param {?} index
             * @return {?}
             */
            function (item, index) {
                if (item.contains((/** @type {?} */ (event.target)))) {
                    isEventFromItems = true;
                    itemElement = item;
                }
                if (item === _this._document.activeElement) {
                    position = index;
                }
            }));
        }
        // closing on Enter / Space
        if (key === Key.Space || key === Key.Enter) {
            if (isEventFromItems && (this.autoClose === true || this.autoClose === 'inside')) {
                // Item is either a button or a link, so click will be triggered by the browser on Enter or Space.
                // So we have to register a one-time click handler that will fire after any user defined click handlers
                // to close the dropdown
                fromEvent(itemElement, 'click').pipe(take(1)).subscribe((/**
                 * @return {?}
                 */
                function () { return _this.close(); }));
            }
            return;
        }
        // opening / navigating
        if (isEventFromToggle || isEventFromItems) {
            this.open();
            if (itemElements.length) {
                switch (key) {
                    case Key.ArrowDown:
                        position = Math.min(position + 1, itemElements.length - 1);
                        break;
                    case Key.ArrowUp:
                        if (this._isDropup() && position === -1) {
                            position = itemElements.length - 1;
                            break;
                        }
                        position = Math.max(position - 1, 0);
                        break;
                    case Key.Home:
                        position = 0;
                        break;
                    case Key.End:
                        position = itemElements.length - 1;
                        break;
                }
                itemElements[position].focus();
            }
            event.preventDefault();
        }
    };
    /**
     * @private
     * @return {?}
     */
    NgbDropdown.prototype._isDropup = /**
     * @private
     * @return {?}
     */
    function () { return this._elementRef.nativeElement.classList.contains('dropup'); };
    /**
     * @private
     * @param {?} event
     * @return {?}
     */
    NgbDropdown.prototype._isEventFromToggle = /**
     * @private
     * @param {?} event
     * @return {?}
     */
    function (event) {
        return this._anchor.getNativeElement().contains((/** @type {?} */ (event.target)));
    };
    /**
     * @private
     * @return {?}
     */
    NgbDropdown.prototype._getMenuElements = /**
     * @private
     * @return {?}
     */
    function () {
        /** @type {?} */
        var menu = this._menu;
        if (menu == null) {
            return [];
        }
        return menu.menuItems.filter((/**
         * @param {?} item
         * @return {?}
         */
        function (item) { return !item.disabled; })).map((/**
         * @param {?} item
         * @return {?}
         */
        function (item) { return item.elementRef.nativeElement; }));
    };
    /**
     * @private
     * @return {?}
     */
    NgbDropdown.prototype._positionMenu = /**
     * @private
     * @return {?}
     */
    function () {
        /** @type {?} */
        var menu = this._menu;
        if (this.isOpen() && menu) {
            this._applyPlacementClasses(this.display === 'dynamic' ?
                positionElements(this._anchor.anchorEl, this._bodyContainer || this._menuElement.nativeElement, this.placement, this.container === 'body') :
                this._getFirstPlacement(this.placement));
        }
    };
    /**
     * @private
     * @param {?} placement
     * @return {?}
     */
    NgbDropdown.prototype._getFirstPlacement = /**
     * @private
     * @param {?} placement
     * @return {?}
     */
    function (placement) {
        return Array.isArray(placement) ? placement[0] : (/** @type {?} */ (placement.split(' ')[0]));
    };
    /**
     * @private
     * @return {?}
     */
    NgbDropdown.prototype._resetContainer = /**
     * @private
     * @return {?}
     */
    function () {
        /** @type {?} */
        var renderer = this._renderer;
        /** @type {?} */
        var menuElement = this._menuElement;
        if (menuElement) {
            /** @type {?} */
            var dropdownElement = this._elementRef.nativeElement;
            /** @type {?} */
            var dropdownMenuElement = menuElement.nativeElement;
            renderer.appendChild(dropdownElement, dropdownMenuElement);
            renderer.removeStyle(dropdownMenuElement, 'position');
            renderer.removeStyle(dropdownMenuElement, 'transform');
        }
        if (this._bodyContainer) {
            renderer.removeChild(this._document.body, this._bodyContainer);
            this._bodyContainer = null;
        }
    };
    /**
     * @private
     * @param {?=} container
     * @return {?}
     */
    NgbDropdown.prototype._applyContainer = /**
     * @private
     * @param {?=} container
     * @return {?}
     */
    function (container) {
        if (container === void 0) { container = null; }
        this._resetContainer();
        if (container === 'body') {
            /** @type {?} */
            var renderer = this._renderer;
            /** @type {?} */
            var dropdownMenuElement = this._menuElement.nativeElement;
            /** @type {?} */
            var bodyContainer = this._bodyContainer = this._bodyContainer || renderer.createElement('div');
            // Override some styles to have the positionning working
            renderer.setStyle(bodyContainer, 'position', 'absolute');
            renderer.setStyle(dropdownMenuElement, 'position', 'static');
            renderer.setStyle(bodyContainer, 'z-index', '1050');
            renderer.appendChild(bodyContainer, dropdownMenuElement);
            renderer.appendChild(this._document.body, bodyContainer);
        }
    };
    /**
     * @private
     * @param {?=} placement
     * @return {?}
     */
    NgbDropdown.prototype._applyPlacementClasses = /**
     * @private
     * @param {?=} placement
     * @return {?}
     */
    function (placement) {
        /** @type {?} */
        var menu = this._menu;
        if (menu) {
            if (!placement) {
                placement = this._getFirstPlacement(this.placement);
            }
            /** @type {?} */
            var renderer = this._renderer;
            /** @type {?} */
            var dropdownElement = this._elementRef.nativeElement;
            // remove the current placement classes
            renderer.removeClass(dropdownElement, 'dropup');
            renderer.removeClass(dropdownElement, 'dropdown');
            menu.placement = this.display === 'static' ? null : placement;
            /*
                  * apply the new placement
                  * in case of top use up-arrow or down-arrow otherwise
                  */
            /** @type {?} */
            var dropdownClass = placement.search('^top') !== -1 ? 'dropup' : 'dropdown';
            renderer.addClass(dropdownElement, dropdownClass);
            /** @type {?} */
            var bodyContainer = this._bodyContainer;
            if (bodyContainer) {
                renderer.removeClass(bodyContainer, 'dropup');
                renderer.removeClass(bodyContainer, 'dropdown');
                renderer.addClass(bodyContainer, dropdownClass);
            }
        }
    };
    NgbDropdown.decorators = [
        { type: Directive, args: [{ selector: '[ngbDropdown]', exportAs: 'ngbDropdown', host: { '[class.show]': 'isOpen()' } },] }
    ];
    /** @nocollapse */
    NgbDropdown.ctorParameters = function () { return [
        { type: ChangeDetectorRef },
        { type: NgbDropdownConfig },
        { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
        { type: NgZone },
        { type: ElementRef },
        { type: Renderer2 },
        { type: NgbNavbar, decorators: [{ type: Optional }] }
    ]; };
    NgbDropdown.propDecorators = {
        _menu: [{ type: ContentChild, args: [NgbDropdownMenu, { static: false },] }],
        _menuElement: [{ type: ContentChild, args: [NgbDropdownMenu, { read: ElementRef, static: false },] }],
        _anchor: [{ type: ContentChild, args: [NgbDropdownAnchor, { static: false },] }],
        autoClose: [{ type: Input }],
        _open: [{ type: Input, args: ['open',] }],
        placement: [{ type: Input }],
        container: [{ type: Input }],
        display: [{ type: Input }],
        openChange: [{ type: Output }]
    };
    return NgbDropdown;
}());
export { NgbDropdown };
if (false) {
    /**
     * @type {?}
     * @private
     */
    NgbDropdown.prototype._closed$;
    /**
     * @type {?}
     * @private
     */
    NgbDropdown.prototype._zoneSubscription;
    /**
     * @type {?}
     * @private
     */
    NgbDropdown.prototype._bodyContainer;
    /**
     * @type {?}
     * @private
     */
    NgbDropdown.prototype._menu;
    /**
     * @type {?}
     * @private
     */
    NgbDropdown.prototype._menuElement;
    /**
     * @type {?}
     * @private
     */
    NgbDropdown.prototype._anchor;
    /**
     * Indicates whether the dropdown should be closed when clicking one of dropdown items or pressing ESC.
     *
     * * `true` - the dropdown will close on both outside and inside (menu) clicks.
     * * `false` - the dropdown can only be closed manually via `close()` or `toggle()` methods.
     * * `"inside"` - the dropdown will close on inside menu clicks, but not outside clicks.
     * * `"outside"` - the dropdown will close only on the outside clicks and not on menu clicks.
     * @type {?}
     */
    NgbDropdown.prototype.autoClose;
    /**
     * Defines whether or not the dropdown menu is opened initially.
     * @type {?}
     */
    NgbDropdown.prototype._open;
    /**
     * The preferred placement of the dropdown.
     *
     * Possible values are `"top"`, `"top-left"`, `"top-right"`, `"bottom"`, `"bottom-left"`,
     * `"bottom-right"`, `"left"`, `"left-top"`, `"left-bottom"`, `"right"`, `"right-top"`,
     * `"right-bottom"`
     *
     * Accepts an array of strings or a string with space separated possible values.
     *
     * The default order of preference is `"bottom-left bottom-right top-left top-right"`
     *
     * Please see the [positioning overview](#/positioning) for more details.
     * @type {?}
     */
    NgbDropdown.prototype.placement;
    /**
     * A selector specifying the element the dropdown should be appended to.
     * Currently only supports "body".
     *
     * \@since 4.1.0
     * @type {?}
     */
    NgbDropdown.prototype.container;
    /**
     * Enable or disable the dynamic positioning. The default value is dynamic unless the dropdown is used
     * inside a Bootstrap navbar. If you need custom placement for a dropdown in a navbar, set it to
     * dynamic explicitly. See the [positioning of dropdown](#/positioning#dropdown)
     * and the [navbar demo](/#/components/dropdown/examples#navbar) for more details.
     *
     * \@since 4.2.0
     * @type {?}
     */
    NgbDropdown.prototype.display;
    /**
     * An event fired when the dropdown is opened or closed.
     *
     * The event payload is a `boolean`:
     * * `true` - the dropdown was opened
     * * `false` - the dropdown was closed
     * @type {?}
     */
    NgbDropdown.prototype.openChange;
    /**
     * @type {?}
     * @private
     */
    NgbDropdown.prototype._changeDetector;
    /**
     * @type {?}
     * @private
     */
    NgbDropdown.prototype._document;
    /**
     * @type {?}
     * @private
     */
    NgbDropdown.prototype._ngZone;
    /**
     * @type {?}
     * @private
     */
    NgbDropdown.prototype._elementRef;
    /**
     * @type {?}
     * @private
     */
    NgbDropdown.prototype._renderer;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dropdown.js","sourceRoot":"ng://@ng-bootstrap/ng-bootstrap/","sources":["dropdown/dropdown.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectorRef,\n  ContentChild,\n  ContentChildren,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  forwardRef,\n  Inject,\n  Input,\n  NgZone,\n  AfterContentInit,\n  OnDestroy,\n  Output,\n  QueryList,\n  Renderer2,\n  SimpleChanges,\n  Optional\n} from '@angular/core';\nimport {DOCUMENT} from '@angular/common';\nimport {fromEvent, Subject, Subscription} from 'rxjs';\nimport {take} from 'rxjs/operators';\n\nimport {Placement, PlacementArray, positionElements} from '../util/positioning';\nimport {ngbAutoClose} from '../util/autoclose';\nimport {Key} from '../util/key';\n\nimport {NgbDropdownConfig} from './dropdown-config';\n\n@Directive({selector: '.navbar'})\nexport class NgbNavbar {\n}\n\n/**\n * A directive you should put on a dropdown item to enable keyboard navigation.\n * Arrow keys will move focus between items marked with this directive.\n *\n * @since 4.1.0\n */\n@Directive({selector: '[ngbDropdownItem]', host: {'class': 'dropdown-item', '[class.disabled]': 'disabled'}})\nexport class NgbDropdownItem {\n  private _disabled = false;\n\n  @Input()\n  set disabled(value: boolean) {\n    this._disabled = <any>value === '' || value === true;  // accept an empty attribute as true\n  }\n\n  get disabled(): boolean { return this._disabled; }\n\n  constructor(public elementRef: ElementRef<HTMLElement>) {}\n}\n\n/**\n * A directive that wraps dropdown menu content and dropdown items.\n */\n@Directive({\n  selector: '[ngbDropdownMenu]',\n  host: {\n    '[class.dropdown-menu]': 'true',\n    '[class.show]': 'dropdown.isOpen()',\n    '[attr.x-placement]': 'placement',\n    '(keydown.ArrowUp)': 'dropdown.onKeyDown($event)',\n    '(keydown.ArrowDown)': 'dropdown.onKeyDown($event)',\n    '(keydown.Home)': 'dropdown.onKeyDown($event)',\n    '(keydown.End)': 'dropdown.onKeyDown($event)',\n    '(keydown.Enter)': 'dropdown.onKeyDown($event)',\n    '(keydown.Space)': 'dropdown.onKeyDown($event)'\n  }\n})\nexport class NgbDropdownMenu {\n  placement: Placement = 'bottom';\n  isOpen = false;\n\n  @ContentChildren(NgbDropdownItem) menuItems: QueryList<NgbDropdownItem>;\n\n  constructor(@Inject(forwardRef(() => NgbDropdown)) public dropdown) {}\n}\n\n/**\n * A directive to mark an element to which dropdown menu will be anchored.\n *\n * This is a simple version of the `NgbDropdownToggle` directive.\n * It plays the same role, but doesn't listen to click events to toggle dropdown menu thus enabling support\n * for events other than click.\n *\n * @since 1.1.0\n */\n@Directive({\n  selector: '[ngbDropdownAnchor]',\n  host: {'class': 'dropdown-toggle', 'aria-haspopup': 'true', '[attr.aria-expanded]': 'dropdown.isOpen()'}\n})\nexport class NgbDropdownAnchor {\n  anchorEl;\n\n  constructor(@Inject(forwardRef(() => NgbDropdown)) public dropdown, private _elementRef: ElementRef<HTMLElement>) {\n    this.anchorEl = _elementRef.nativeElement;\n  }\n\n  getNativeElement() { return this._elementRef.nativeElement; }\n}\n\n/**\n * A directive to mark an element that will toggle dropdown via the `click` event.\n *\n * You can also use `NgbDropdownAnchor` as an alternative.\n */\n@Directive({\n  selector: '[ngbDropdownToggle]',\n  host: {\n    'class': 'dropdown-toggle',\n    'aria-haspopup': 'true',\n    '[attr.aria-expanded]': 'dropdown.isOpen()',\n    '(click)': 'dropdown.toggle()',\n    '(keydown.ArrowUp)': 'dropdown.onKeyDown($event)',\n    '(keydown.ArrowDown)': 'dropdown.onKeyDown($event)',\n    '(keydown.Home)': 'dropdown.onKeyDown($event)',\n    '(keydown.End)': 'dropdown.onKeyDown($event)'\n  },\n  providers: [{provide: NgbDropdownAnchor, useExisting: forwardRef(() => NgbDropdownToggle)}]\n})\nexport class NgbDropdownToggle extends NgbDropdownAnchor {\n  constructor(@Inject(forwardRef(() => NgbDropdown)) dropdown, elementRef: ElementRef<HTMLElement>) {\n    super(dropdown, elementRef);\n  }\n}\n\n/**\n * A directive that provides contextual overlays for displaying lists of links and more.\n */\n@Directive({selector: '[ngbDropdown]', exportAs: 'ngbDropdown', host: {'[class.show]': 'isOpen()'}})\nexport class NgbDropdown implements AfterContentInit, OnDestroy {\n  private _closed$ = new Subject<void>();\n  private _zoneSubscription: Subscription;\n  private _bodyContainer: HTMLElement;\n\n  @ContentChild(NgbDropdownMenu, {static: false}) private _menu: NgbDropdownMenu;\n  @ContentChild(NgbDropdownMenu, {read: ElementRef, static: false}) private _menuElement: ElementRef;\n  @ContentChild(NgbDropdownAnchor, {static: false}) private _anchor: NgbDropdownAnchor;\n\n  /**\n   * Indicates whether the dropdown should be closed when clicking one of dropdown items or pressing ESC.\n   *\n   * * `true` - the dropdown will close on both outside and inside (menu) clicks.\n   * * `false` - the dropdown can only be closed manually via `close()` or `toggle()` methods.\n   * * `\"inside\"` - the dropdown will close on inside menu clicks, but not outside clicks.\n   * * `\"outside\"` - the dropdown will close only on the outside clicks and not on menu clicks.\n   */\n  @Input() autoClose: boolean | 'outside' | 'inside';\n\n  /**\n   * Defines whether or not the dropdown menu is opened initially.\n   */\n  @Input('open') _open = false;\n\n  /**\n   * The preferred placement of the dropdown.\n   *\n   * Possible values are `\"top\"`, `\"top-left\"`, `\"top-right\"`, `\"bottom\"`, `\"bottom-left\"`,\n   * `\"bottom-right\"`, `\"left\"`, `\"left-top\"`, `\"left-bottom\"`, `\"right\"`, `\"right-top\"`,\n   * `\"right-bottom\"`\n   *\n   * Accepts an array of strings or a string with space separated possible values.\n   *\n   * The default order of preference is `\"bottom-left bottom-right top-left top-right\"`\n   *\n   * Please see the [positioning overview](#/positioning) for more details.\n   */\n  @Input() placement: PlacementArray;\n\n  /**\n  * A selector specifying the element the dropdown should be appended to.\n  * Currently only supports \"body\".\n  *\n  * @since 4.1.0\n  */\n  @Input() container: null | 'body';\n\n  /**\n   * Enable or disable the dynamic positioning. The default value is dynamic unless the dropdown is used\n   * inside a Bootstrap navbar. If you need custom placement for a dropdown in a navbar, set it to\n   * dynamic explicitly. See the [positioning of dropdown](#/positioning#dropdown)\n   * and the [navbar demo](/#/components/dropdown/examples#navbar) for more details.\n   *\n   * @since 4.2.0\n   */\n  @Input() display: 'dynamic' | 'static';\n\n  /**\n   * An event fired when the dropdown is opened or closed.\n   *\n   * The event payload is a `boolean`:\n   * * `true` - the dropdown was opened\n   * * `false` - the dropdown was closed\n   */\n  @Output() openChange = new EventEmitter<boolean>();\n\n  constructor(\n      private _changeDetector: ChangeDetectorRef, config: NgbDropdownConfig, @Inject(DOCUMENT) private _document: any,\n      private _ngZone: NgZone, private _elementRef: ElementRef<HTMLElement>, private _renderer: Renderer2,\n      @Optional() ngbNavbar: NgbNavbar) {\n    this.placement = config.placement;\n    this.container = config.container;\n    this.autoClose = config.autoClose;\n\n    this.display = ngbNavbar ? 'static' : 'dynamic';\n\n    this._zoneSubscription = _ngZone.onStable.subscribe(() => { this._positionMenu(); });\n  }\n\n  ngAfterContentInit() {\n    this._ngZone.onStable.pipe(take(1)).subscribe(() => {\n      this._applyPlacementClasses();\n      if (this._open) {\n        this._setCloseHandlers();\n      }\n    });\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (changes.container && this._open) {\n      this._applyContainer(this.container);\n    }\n\n    if (changes.placement && !changes.placement.isFirstChange) {\n      this._applyPlacementClasses();\n    }\n  }\n\n  /**\n   * Checks if the dropdown menu is open.\n   */\n  isOpen(): boolean { return this._open; }\n\n  /**\n   * Opens the dropdown menu.\n   */\n  open(): void {\n    if (!this._open) {\n      this._open = true;\n      this._applyContainer(this.container);\n      this.openChange.emit(true);\n      this._setCloseHandlers();\n    }\n  }\n\n  private _setCloseHandlers() {\n    const anchor = this._anchor;\n    ngbAutoClose(\n        this._ngZone, this._document, this.autoClose, () => this.close(), this._closed$,\n        this._menu ? [this._menuElement.nativeElement] : [], anchor ? [anchor.getNativeElement()] : [],\n        '.dropdown-item,.dropdown-divider');\n  }\n\n  /**\n   * Closes the dropdown menu.\n   */\n  close(): void {\n    if (this._open) {\n      this._open = false;\n      this._resetContainer();\n      this._closed$.next();\n      this.openChange.emit(false);\n      this._changeDetector.markForCheck();\n    }\n  }\n\n  /**\n   * Toggles the dropdown menu.\n   */\n  toggle(): void {\n    if (this.isOpen()) {\n      this.close();\n    } else {\n      this.open();\n    }\n  }\n\n  ngOnDestroy() {\n    this._resetContainer();\n\n    this._closed$.next();\n    this._zoneSubscription.unsubscribe();\n  }\n\n  onKeyDown(event: KeyboardEvent) {\n    // tslint:disable-next-line:deprecation\n    const key = event.which;\n    const itemElements = this._getMenuElements();\n\n    let position = -1;\n    let isEventFromItems = false;\n    let itemElement: HTMLElement = null;\n    const isEventFromToggle = this._isEventFromToggle(event);\n\n    if (!isEventFromToggle && itemElements.length) {\n      itemElements.forEach((item, index) => {\n        if (item.contains(event.target as HTMLElement)) {\n          isEventFromItems = true;\n          itemElement = item;\n        }\n        if (item === this._document.activeElement) {\n          position = index;\n        }\n      });\n    }\n\n    // closing on Enter / Space\n    if (key === Key.Space || key === Key.Enter) {\n      if (isEventFromItems && (this.autoClose === true || this.autoClose === 'inside')) {\n        // Item is either a button or a link, so click will be triggered by the browser on Enter or Space.\n        // So we have to register a one-time click handler that will fire after any user defined click handlers\n        // to close the dropdown\n        fromEvent(itemElement, 'click').pipe(take(1)).subscribe(() => this.close());\n      }\n      return;\n    }\n\n    // opening / navigating\n    if (isEventFromToggle || isEventFromItems) {\n      this.open();\n\n      if (itemElements.length) {\n        switch (key) {\n          case Key.ArrowDown:\n            position = Math.min(position + 1, itemElements.length - 1);\n            break;\n          case Key.ArrowUp:\n            if (this._isDropup() && position === -1) {\n              position = itemElements.length - 1;\n              break;\n            }\n            position = Math.max(position - 1, 0);\n            break;\n          case Key.Home:\n            position = 0;\n            break;\n          case Key.End:\n            position = itemElements.length - 1;\n            break;\n        }\n        itemElements[position].focus();\n      }\n      event.preventDefault();\n    }\n  }\n\n  private _isDropup(): boolean { return this._elementRef.nativeElement.classList.contains('dropup'); }\n\n  private _isEventFromToggle(event: KeyboardEvent) {\n    return this._anchor.getNativeElement().contains(event.target as HTMLElement);\n  }\n\n  private _getMenuElements(): HTMLElement[] {\n    const menu = this._menu;\n    if (menu == null) {\n      return [];\n    }\n    return menu.menuItems.filter(item => !item.disabled).map(item => item.elementRef.nativeElement);\n  }\n\n  private _positionMenu() {\n    const menu = this._menu;\n    if (this.isOpen() && menu) {\n      this._applyPlacementClasses(\n          this.display === 'dynamic' ?\n              positionElements(\n                  this._anchor.anchorEl, this._bodyContainer || this._menuElement.nativeElement, this.placement,\n                  this.container === 'body') :\n              this._getFirstPlacement(this.placement));\n    }\n  }\n\n  private _getFirstPlacement(placement: PlacementArray): Placement {\n    return Array.isArray(placement) ? placement[0] : placement.split(' ')[0] as Placement;\n  }\n\n  private _resetContainer() {\n    const renderer = this._renderer;\n    const menuElement = this._menuElement;\n    if (menuElement) {\n      const dropdownElement = this._elementRef.nativeElement;\n      const dropdownMenuElement = menuElement.nativeElement;\n\n      renderer.appendChild(dropdownElement, dropdownMenuElement);\n      renderer.removeStyle(dropdownMenuElement, 'position');\n      renderer.removeStyle(dropdownMenuElement, 'transform');\n    }\n    if (this._bodyContainer) {\n      renderer.removeChild(this._document.body, this._bodyContainer);\n      this._bodyContainer = null;\n    }\n  }\n\n  private _applyContainer(container: null | 'body' = null) {\n    this._resetContainer();\n    if (container === 'body') {\n      const renderer = this._renderer;\n      const dropdownMenuElement = this._menuElement.nativeElement;\n      const bodyContainer = this._bodyContainer = this._bodyContainer || renderer.createElement('div');\n\n      // Override some styles to have the positionning working\n      renderer.setStyle(bodyContainer, 'position', 'absolute');\n      renderer.setStyle(dropdownMenuElement, 'position', 'static');\n      renderer.setStyle(bodyContainer, 'z-index', '1050');\n\n      renderer.appendChild(bodyContainer, dropdownMenuElement);\n      renderer.appendChild(this._document.body, bodyContainer);\n    }\n  }\n\n  private _applyPlacementClasses(placement?: Placement) {\n    const menu = this._menu;\n    if (menu) {\n      if (!placement) {\n        placement = this._getFirstPlacement(this.placement);\n      }\n\n      const renderer = this._renderer;\n      const dropdownElement = this._elementRef.nativeElement;\n\n      // remove the current placement classes\n      renderer.removeClass(dropdownElement, 'dropup');\n      renderer.removeClass(dropdownElement, 'dropdown');\n      menu.placement = this.display === 'static' ? null : placement;\n\n      /*\n      * apply the new placement\n      * in case of top use up-arrow or down-arrow otherwise\n      */\n      const dropdownClass = placement.search('^top') !== -1 ? 'dropup' : 'dropdown';\n      renderer.addClass(dropdownElement, dropdownClass);\n\n      const bodyContainer = this._bodyContainer;\n      if (bodyContainer) {\n        renderer.removeClass(bodyContainer, 'dropup');\n        renderer.removeClass(bodyContainer, 'dropdown');\n        renderer.addClass(bodyContainer, dropdownClass);\n      }\n    }\n  }\n}\n"]}