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

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
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';
export class NgbNavbar {
}
NgbNavbar.decorators = [
    { type: Directive, args: [{ selector: '.navbar' },] }
];
/**
 * 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
 */
export class NgbDropdownItem {
    /**
     * @param {?} elementRef
     */
    constructor(elementRef) {
        this.elementRef = elementRef;
        this._disabled = false;
    }
    /**
     * @param {?} value
     * @return {?}
     */
    set disabled(value) {
        this._disabled = (/** @type {?} */ (value)) === '' || value === true; // accept an empty attribute as true
    }
    /**
     * @return {?}
     */
    get disabled() { return this._disabled; }
}
NgbDropdownItem.decorators = [
    { type: Directive, args: [{ selector: '[ngbDropdownItem]', host: { 'class': 'dropdown-item', '[class.disabled]': 'disabled' } },] }
];
/** @nocollapse */
NgbDropdownItem.ctorParameters = () => [
    { type: ElementRef }
];
NgbDropdownItem.propDecorators = {
    disabled: [{ type: Input }]
};
if (false) {
    /**
     * @type {?}
     * @private
     */
    NgbDropdownItem.prototype._disabled;
    /** @type {?} */
    NgbDropdownItem.prototype.elementRef;
}
/**
 * A directive that wraps dropdown menu content and dropdown items.
 */
export class NgbDropdownMenu {
    /**
     * @param {?} dropdown
     */
    constructor(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 = () => [
    { type: undefined, decorators: [{ type: Inject, args: [forwardRef((/**
                     * @return {?}
                     */
                    () => NgbDropdown)),] }] }
];
NgbDropdownMenu.propDecorators = {
    menuItems: [{ type: ContentChildren, args: [NgbDropdownItem,] }]
};
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
 */
export class NgbDropdownAnchor {
    /**
     * @param {?} dropdown
     * @param {?} _elementRef
     */
    constructor(dropdown, _elementRef) {
        this.dropdown = dropdown;
        this._elementRef = _elementRef;
        this.anchorEl = _elementRef.nativeElement;
    }
    /**
     * @return {?}
     */
    getNativeElement() { 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 = () => [
    { type: undefined, decorators: [{ type: Inject, args: [forwardRef((/**
                     * @return {?}
                     */
                    () => NgbDropdown)),] }] },
    { type: ElementRef }
];
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.
 */
export class NgbDropdownToggle extends NgbDropdownAnchor {
    /**
     * @param {?} dropdown
     * @param {?} elementRef
     */
    constructor(dropdown, elementRef) {
        super(dropdown, elementRef);
    }
}
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 {?}
                         */
                        () => NgbDropdownToggle)) }]
            },] }
];
/** @nocollapse */
NgbDropdownToggle.ctorParameters = () => [
    { type: undefined, decorators: [{ type: Inject, args: [forwardRef((/**
                     * @return {?}
                     */
                    () => NgbDropdown)),] }] },
    { type: ElementRef }
];
/**
 * A directive that provides contextual overlays for displaying lists of links and more.
 */
export class NgbDropdown {
    /**
     * @param {?} _changeDetector
     * @param {?} config
     * @param {?} _document
     * @param {?} _ngZone
     * @param {?} _elementRef
     * @param {?} _renderer
     * @param {?} ngbNavbar
     */
    constructor(_changeDetector, config, _document, _ngZone, _elementRef, _renderer, ngbNavbar) {
        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 {?}
         */
        () => { this._positionMenu(); }));
    }
    /**
     * @return {?}
     */
    ngAfterContentInit() {
        this._ngZone.onStable.pipe(take(1)).subscribe((/**
         * @return {?}
         */
        () => {
            this._applyPlacementClasses();
            if (this._open) {
                this._setCloseHandlers();
            }
        }));
    }
    /**
     * @param {?} changes
     * @return {?}
     */
    ngOnChanges(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.
     * @return {?}
     */
    isOpen() { return this._open; }
    /**
     * Opens the dropdown menu.
     * @return {?}
     */
    open() {
        if (!this._open) {
            this._open = true;
            this._applyContainer(this.container);
            this.openChange.emit(true);
            this._setCloseHandlers();
        }
    }
    /**
     * @private
     * @return {?}
     */
    _setCloseHandlers() {
        /** @type {?} */
        const anchor = this._anchor;
        ngbAutoClose(this._ngZone, this._document, this.autoClose, (/**
         * @return {?}
         */
        () => this.close()), this._closed$, this._menu ? [this._menuElement.nativeElement] : [], anchor ? [anchor.getNativeElement()] : [], '.dropdown-item,.dropdown-divider');
    }
    /**
     * Closes the dropdown menu.
     * @return {?}
     */
    close() {
        if (this._open) {
            this._open = false;
            this._resetContainer();
            this._closed$.next();
            this.openChange.emit(false);
            this._changeDetector.markForCheck();
        }
    }
    /**
     * Toggles the dropdown menu.
     * @return {?}
     */
    toggle() {
        if (this.isOpen()) {
            this.close();
        }
        else {
            this.open();
        }
    }
    /**
     * @return {?}
     */
    ngOnDestroy() {
        this._resetContainer();
        this._closed$.next();
        this._zoneSubscription.unsubscribe();
    }
    /**
     * @param {?} event
     * @return {?}
     */
    onKeyDown(event) {
        // tslint:disable-next-line:deprecation
        /** @type {?} */
        const key = event.which;
        /** @type {?} */
        const itemElements = this._getMenuElements();
        /** @type {?} */
        let position = -1;
        /** @type {?} */
        let isEventFromItems = false;
        /** @type {?} */
        let itemElement = null;
        /** @type {?} */
        const isEventFromToggle = this._isEventFromToggle(event);
        if (!isEventFromToggle && itemElements.length) {
            itemElements.forEach((/**
             * @param {?} item
             * @param {?} index
             * @return {?}
             */
            (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 {?}
                 */
                () => 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 {?}
     */
    _isDropup() { return this._elementRef.nativeElement.classList.contains('dropup'); }
    /**
     * @private
     * @param {?} event
     * @return {?}
     */
    _isEventFromToggle(event) {
        return this._anchor.getNativeElement().contains((/** @type {?} */ (event.target)));
    }
    /**
     * @private
     * @return {?}
     */
    _getMenuElements() {
        /** @type {?} */
        const menu = this._menu;
        if (menu == null) {
            return [];
        }
        return menu.menuItems.filter((/**
         * @param {?} item
         * @return {?}
         */
        item => !item.disabled)).map((/**
         * @param {?} item
         * @return {?}
         */
        item => item.elementRef.nativeElement));
    }
    /**
     * @private
     * @return {?}
     */
    _positionMenu() {
        /** @type {?} */
        const 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 {?}
     */
    _getFirstPlacement(placement) {
        return Array.isArray(placement) ? placement[0] : (/** @type {?} */ (placement.split(' ')[0]));
    }
    /**
     * @private
     * @return {?}
     */
    _resetContainer() {
        /** @type {?} */
        const renderer = this._renderer;
        /** @type {?} */
        const menuElement = this._menuElement;
        if (menuElement) {
            /** @type {?} */
            const dropdownElement = this._elementRef.nativeElement;
            /** @type {?} */
            const 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 {?}
     */
    _applyContainer(container = null) {
        this._resetContainer();
        if (container === 'body') {
            /** @type {?} */
            const renderer = this._renderer;
            /** @type {?} */
            const dropdownMenuElement = this._menuElement.nativeElement;
            /** @type {?} */
            const 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 {?}
     */
    _applyPlacementClasses(placement) {
        /** @type {?} */
        const menu = this._menu;
        if (menu) {
            if (!placement) {
                placement = this._getFirstPlacement(this.placement);
            }
            /** @type {?} */
            const renderer = this._renderer;
            /** @type {?} */
            const 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 {?} */
            const dropdownClass = placement.search('^top') !== -1 ? 'dropup' : 'dropdown';
            renderer.addClass(dropdownElement, dropdownClass);
            /** @type {?} */
            const 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 = () => [
    { 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 }]
};
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"]}