/** * @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"]}