/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { Component, Directive, Input, Output, EventEmitter, ChangeDetectionStrategy, Inject, Injector, Renderer2, ElementRef, TemplateRef, ViewContainerRef, ComponentFactoryResolver, NgZone, ViewEncapsulation, ChangeDetectorRef, ApplicationRef } from '@angular/core';
import { DOCUMENT } from '@angular/common';
import { listenToTriggers } from '../util/triggers';
import { ngbAutoClose } from '../util/autoclose';
import { positionElements } from '../util/positioning';
import { PopupService } from '../util/popup';
import { NgbPopoverConfig } from './popover-config';
/** @type {?} */
let nextId = 0;
export class NgbPopoverWindow {
/**
* @return {?}
*/
isTitleTemplate() { return this.title instanceof TemplateRef; }
}
NgbPopoverWindow.decorators = [
{ type: Component, args: [{
selector: 'ngb-popover-window',
changeDetection: ChangeDetectionStrategy.OnPush,
encapsulation: ViewEncapsulation.None,
host: { '[class]': '"popover" + (popoverClass ? " " + popoverClass : "")', 'role': 'tooltip', '[id]': 'id' },
template: `
`,
styles: ["ngb-popover-window.bs-popover-bottom>.arrow,ngb-popover-window.bs-popover-top>.arrow{left:50%;margin-left:-.5rem}ngb-popover-window.bs-popover-bottom-left>.arrow,ngb-popover-window.bs-popover-top-left>.arrow{left:2em}ngb-popover-window.bs-popover-bottom-right>.arrow,ngb-popover-window.bs-popover-top-right>.arrow{left:auto;right:2em}ngb-popover-window.bs-popover-left>.arrow,ngb-popover-window.bs-popover-right>.arrow{top:50%;margin-top:-.5rem}ngb-popover-window.bs-popover-left-top>.arrow,ngb-popover-window.bs-popover-right-top>.arrow{top:.7em}ngb-popover-window.bs-popover-left-bottom>.arrow,ngb-popover-window.bs-popover-right-bottom>.arrow{top:auto;bottom:.7em}"]
}] }
];
NgbPopoverWindow.propDecorators = {
title: [{ type: Input }],
id: [{ type: Input }],
popoverClass: [{ type: Input }],
context: [{ type: Input }]
};
if (false) {
/** @type {?} */
NgbPopoverWindow.prototype.title;
/** @type {?} */
NgbPopoverWindow.prototype.id;
/** @type {?} */
NgbPopoverWindow.prototype.popoverClass;
/** @type {?} */
NgbPopoverWindow.prototype.context;
}
/**
* A lightweight and extensible directive for fancy popover creation.
*/
export class NgbPopover {
/**
* @param {?} _elementRef
* @param {?} _renderer
* @param {?} injector
* @param {?} componentFactoryResolver
* @param {?} viewContainerRef
* @param {?} config
* @param {?} _ngZone
* @param {?} _document
* @param {?} _changeDetector
* @param {?} applicationRef
*/
constructor(_elementRef, _renderer, injector, componentFactoryResolver, viewContainerRef, config, _ngZone, _document, _changeDetector, applicationRef) {
this._elementRef = _elementRef;
this._renderer = _renderer;
this._ngZone = _ngZone;
this._document = _document;
this._changeDetector = _changeDetector;
/**
* An event emitted when the popover is shown. Contains no payload.
*/
this.shown = new EventEmitter();
/**
* An event emitted when the popover is hidden. Contains no payload.
*/
this.hidden = new EventEmitter();
this._ngbPopoverWindowId = `ngb-popover-${nextId++}`;
this.autoClose = config.autoClose;
this.placement = config.placement;
this.triggers = config.triggers;
this.container = config.container;
this.disablePopover = config.disablePopover;
this.popoverClass = config.popoverClass;
this.openDelay = config.openDelay;
this.closeDelay = config.closeDelay;
this._popupService = new PopupService(NgbPopoverWindow, injector, viewContainerRef, _renderer, componentFactoryResolver, applicationRef);
this._zoneSubscription = _ngZone.onStable.subscribe((/**
* @return {?}
*/
() => {
if (this._windowRef) {
positionElements(this._elementRef.nativeElement, this._windowRef.location.nativeElement, this.placement, this.container === 'body', 'bs-popover');
}
}));
}
/**
* @private
* @return {?}
*/
_isDisabled() {
if (this.disablePopover) {
return true;
}
if (!this.ngbPopover && !this.popoverTitle) {
return true;
}
return false;
}
/**
* Opens the popover.
*
* This is considered to be a "manual" triggering.
* The `context` is an optional value to be injected into the popover template when it is created.
* @param {?=} context
* @return {?}
*/
open(context) {
if (!this._windowRef && !this._isDisabled()) {
this._windowRef = this._popupService.open(this.ngbPopover, context);
this._windowRef.instance.title = this.popoverTitle;
this._windowRef.instance.context = context;
this._windowRef.instance.popoverClass = this.popoverClass;
this._windowRef.instance.id = this._ngbPopoverWindowId;
this._renderer.setAttribute(this._elementRef.nativeElement, 'aria-describedby', this._ngbPopoverWindowId);
if (this.container === 'body') {
this._document.querySelector(this.container).appendChild(this._windowRef.location.nativeElement);
}
// We need to detect changes, because we don't know where .open() might be called from.
// Ex. opening popover from one of lifecycle hooks that run after the CD
// (say from ngAfterViewInit) will result in 'ExpressionHasChanged' exception
this._windowRef.changeDetectorRef.detectChanges();
// We need to mark for check, because popover won't work inside the OnPush component.
// Ex. when we use expression like `{{ popover.isOpen() : 'opened' : 'closed' }}`
// inside the template of an OnPush component and we change the popover from
// open -> closed, the expression in question won't be updated unless we explicitly
// mark the parent component to be checked.
this._windowRef.changeDetectorRef.markForCheck();
ngbAutoClose(this._ngZone, this._document, this.autoClose, (/**
* @return {?}
*/
() => this.close()), this.hidden, [this._windowRef.location.nativeElement]);
this.shown.emit();
}
}
/**
* Closes the popover.
*
* This is considered to be a "manual" triggering of the popover.
* @return {?}
*/
close() {
if (this._windowRef) {
this._renderer.removeAttribute(this._elementRef.nativeElement, 'aria-describedby');
this._popupService.close();
this._windowRef = null;
this.hidden.emit();
this._changeDetector.markForCheck();
}
}
/**
* Toggles the popover.
*
* This is considered to be a "manual" triggering of the popover.
* @return {?}
*/
toggle() {
if (this._windowRef) {
this.close();
}
else {
this.open();
}
}
/**
* Returns `true`, if the popover is currently shown.
* @return {?}
*/
isOpen() { return this._windowRef != null; }
/**
* @return {?}
*/
ngOnInit() {
this._unregisterListenersFn = listenToTriggers(this._renderer, this._elementRef.nativeElement, this.triggers, this.isOpen.bind(this), this.open.bind(this), this.close.bind(this), +this.openDelay, +this.closeDelay);
}
/**
* @param {?} __0
* @return {?}
*/
ngOnChanges({ ngbPopover, popoverTitle, disablePopover, popoverClass }) {
if (popoverClass && this.isOpen()) {
this._windowRef.instance.popoverClass = popoverClass.currentValue;
}
// close popover if title and content become empty, or disablePopover set to true
if ((ngbPopover || popoverTitle || disablePopover) && this._isDisabled()) {
this.close();
}
}
/**
* @return {?}
*/
ngOnDestroy() {
this.close();
// This check is needed as it might happen that ngOnDestroy is called before ngOnInit
// under certain conditions, see: https://github.com/ng-bootstrap/ng-bootstrap/issues/2199
if (this._unregisterListenersFn) {
this._unregisterListenersFn();
}
this._zoneSubscription.unsubscribe();
}
}
NgbPopover.decorators = [
{ type: Directive, args: [{ selector: '[ngbPopover]', exportAs: 'ngbPopover' },] }
];
/** @nocollapse */
NgbPopover.ctorParameters = () => [
{ type: ElementRef },
{ type: Renderer2 },
{ type: Injector },
{ type: ComponentFactoryResolver },
{ type: ViewContainerRef },
{ type: NgbPopoverConfig },
{ type: NgZone },
{ type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
{ type: ChangeDetectorRef },
{ type: ApplicationRef }
];
NgbPopover.propDecorators = {
autoClose: [{ type: Input }],
ngbPopover: [{ type: Input }],
popoverTitle: [{ type: Input }],
placement: [{ type: Input }],
triggers: [{ type: Input }],
container: [{ type: Input }],
disablePopover: [{ type: Input }],
popoverClass: [{ type: Input }],
openDelay: [{ type: Input }],
closeDelay: [{ type: Input }],
shown: [{ type: Output }],
hidden: [{ type: Output }]
};
if (false) {
/**
* Indicates whether the popover should be closed on `Escape` key and inside/outside clicks:
*
* * `true` - closes on both outside and inside clicks as well as `Escape` presses
* * `false` - disables the autoClose feature (NB: triggers still apply)
* * `"inside"` - closes on inside clicks as well as Escape presses
* * `"outside"` - closes on outside clicks (sometimes also achievable through triggers)
* as well as `Escape` presses
*
* \@since 3.0.0
* @type {?}
*/
NgbPopover.prototype.autoClose;
/**
* The string content or a `TemplateRef` for the content to be displayed in the popover.
*
* If the title and the content are empty, the popover won't open.
* @type {?}
*/
NgbPopover.prototype.ngbPopover;
/**
* The title of the popover.
*
* If the title and the content are empty, the popover won't open.
* @type {?}
*/
NgbPopover.prototype.popoverTitle;
/**
* The preferred placement of the popover.
*
* 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 `"auto"` (same as the sequence above).
*
* Please see the [positioning overview](#/positioning) for more details.
* @type {?}
*/
NgbPopover.prototype.placement;
/**
* Specifies events that should trigger the tooltip.
*
* Supports a space separated list of event names.
* For more details see the [triggers demo](#/components/popover/examples#triggers).
* @type {?}
*/
NgbPopover.prototype.triggers;
/**
* A selector specifying the element the popover should be appended to.
*
* Currently only supports `body`.
* @type {?}
*/
NgbPopover.prototype.container;
/**
* If `true`, popover is disabled and won't be displayed.
*
* \@since 1.1.0
* @type {?}
*/
NgbPopover.prototype.disablePopover;
/**
* An optional class applied to the popover window element.
*
* \@since 2.2.0
* @type {?}
*/
NgbPopover.prototype.popoverClass;
/**
* The opening delay in ms. Works only for "non-manual" opening triggers defined by the `triggers` input.
*
* \@since 4.1.0
* @type {?}
*/
NgbPopover.prototype.openDelay;
/**
* The closing delay in ms. Works only for "non-manual" opening triggers defined by the `triggers` input.
*
* \@since 4.1.0
* @type {?}
*/
NgbPopover.prototype.closeDelay;
/**
* An event emitted when the popover is shown. Contains no payload.
* @type {?}
*/
NgbPopover.prototype.shown;
/**
* An event emitted when the popover is hidden. Contains no payload.
* @type {?}
*/
NgbPopover.prototype.hidden;
/**
* @type {?}
* @private
*/
NgbPopover.prototype._ngbPopoverWindowId;
/**
* @type {?}
* @private
*/
NgbPopover.prototype._popupService;
/**
* @type {?}
* @private
*/
NgbPopover.prototype._windowRef;
/**
* @type {?}
* @private
*/
NgbPopover.prototype._unregisterListenersFn;
/**
* @type {?}
* @private
*/
NgbPopover.prototype._zoneSubscription;
/**
* @type {?}
* @private
*/
NgbPopover.prototype._elementRef;
/**
* @type {?}
* @private
*/
NgbPopover.prototype._renderer;
/**
* @type {?}
* @private
*/
NgbPopover.prototype._ngZone;
/**
* @type {?}
* @private
*/
NgbPopover.prototype._document;
/**
* @type {?}
* @private
*/
NgbPopover.prototype._changeDetector;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"popover.js","sourceRoot":"ng://@ng-bootstrap/ng-bootstrap/","sources":["popover/popover.ts"],"names":[],"mappings":";;;;AAAA,OAAO,EACL,SAAS,EACT,SAAS,EACT,KAAK,EACL,MAAM,EACN,YAAY,EACZ,uBAAuB,EAIvB,MAAM,EACN,QAAQ,EACR,SAAS,EAET,UAAU,EACV,WAAW,EACX,gBAAgB,EAChB,wBAAwB,EACxB,MAAM,EAEN,iBAAiB,EACjB,iBAAiB,EACjB,cAAc,EACf,MAAM,eAAe,CAAC;AACvB,OAAO,EAAC,QAAQ,EAAC,MAAM,iBAAiB,CAAC;AAEzC,OAAO,EAAC,gBAAgB,EAAC,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAC,YAAY,EAAC,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAC,gBAAgB,EAAiB,MAAM,qBAAqB,CAAC;AACrE,OAAO,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAC,gBAAgB,EAAC,MAAM,kBAAkB,CAAC;;IAE9C,MAAM,GAAG,CAAC;AAgBd,MAAM,OAAO,gBAAgB;;;;IAM3B,eAAe,KAAK,OAAO,IAAI,CAAC,KAAK,YAAY,WAAW,CAAC,CAAC,CAAC;;;YApBhE,SAAS,SAAC;gBACT,QAAQ,EAAE,oBAAoB;gBAC9B,eAAe,EAAE,uBAAuB,CAAC,MAAM;gBAC/C,aAAa,EAAE,iBAAiB,CAAC,IAAI;gBACrC,IAAI,EAAE,EAAC,SAAS,EAAE,sDAAsD,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAC;gBAC1G,QAAQ,EAAE;;;;;;8DAMkD;;aAE7D;;;oBAEE,KAAK;iBACL,KAAK;2BACL,KAAK;sBACL,KAAK;;;;IAHN,iCAAsD;;IACtD,8BAAoB;;IACpB,wCAA8B;;IAC9B,mCAAsB;;;;;AASxB,MAAM,OAAO,UAAU;;;;;;;;;;;;;IA+GrB,YACY,WAAoC,EAAU,SAAoB,EAAE,QAAkB,EAC9F,wBAAkD,EAAE,gBAAkC,EAAE,MAAwB,EACxG,OAAe,EAA4B,SAAc,EAAU,eAAkC,EAC7G,cAA8B;QAHtB,gBAAW,GAAX,WAAW,CAAyB;QAAU,cAAS,GAAT,SAAS,CAAW;QAElE,YAAO,GAAP,OAAO,CAAQ;QAA4B,cAAS,GAAT,SAAS,CAAK;QAAU,oBAAe,GAAf,eAAe,CAAmB;;;;QAzBvG,UAAK,GAAG,IAAI,YAAY,EAAQ,CAAC;;;;QAKjC,WAAM,GAAG,IAAI,YAAY,EAAQ,CAAC;QAEpC,wBAAmB,GAAG,eAAe,MAAM,EAAE,EAAE,CAAC;QAoBtD,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;QAClC,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;QAClC,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;QAChC,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;QAClC,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC,cAAc,CAAC;QAC5C,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,YAAY,CAAC;QACxC,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;QAClC,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC;QACpC,IAAI,CAAC,aAAa,GAAG,IAAI,YAAY,CACjC,gBAAgB,EAAE,QAAQ,EAAE,gBAAgB,EAAE,SAAS,EAAE,wBAAwB,EAAE,cAAc,CAAC,CAAC;QAEvG,IAAI,CAAC,iBAAiB,GAAG,OAAO,CAAC,QAAQ,CAAC,SAAS;;;QAAC,GAAG,EAAE;YACvD,IAAI,IAAI,CAAC,UAAU,EAAE;gBACnB,gBAAgB,CACZ,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,aAAa,EAAE,IAAI,CAAC,SAAS,EACtF,IAAI,CAAC,SAAS,KAAK,MAAM,EAAE,YAAY,CAAC,CAAC;aAC9C;QACH,CAAC,EAAC,CAAC;IACL,CAAC;;;;;IAjCO,WAAW;QACjB,IAAI,IAAI,CAAC,cAAc,EAAE;YACvB,OAAO,IAAI,CAAC;SACb;QACD,IAAI,CAAC,IAAI,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;YAC1C,OAAO,IAAI,CAAC;SACb;QACD,OAAO,KAAK,CAAC;IACf,CAAC;;;;;;;;;IAiCD,IAAI,CAAC,OAAa;QAChB,IAAI,CAAC,IAAI,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE;YAC3C,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;YACpE,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC;YACnD,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,OAAO,GAAG,OAAO,CAAC;YAC3C,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC;YAC1D,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,GAAG,IAAI,CAAC,mBAAmB,CAAC;YAEvD,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,kBAAkB,EAAE,IAAI,CAAC,mBAAmB,CAAC,CAAC;YAE1G,IAAI,IAAI,CAAC,SAAS,KAAK,MAAM,EAAE;gBAC7B,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;aAClG;YAED,uFAAuF;YACvF,wEAAwE;YACxE,6EAA6E;YAC7E,IAAI,CAAC,UAAU,CAAC,iBAAiB,CAAC,aAAa,EAAE,CAAC;YAElD,qFAAqF;YACrF,iFAAiF;YACjF,4EAA4E;YAC5E,mFAAmF;YACnF,2CAA2C;YAC3C,IAAI,CAAC,UAAU,CAAC,iBAAiB,CAAC,YAAY,EAAE,CAAC;YAEjD,YAAY,CACR,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS;;;YAAE,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,GAAE,IAAI,CAAC,MAAM,EAC7E,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC;YAC9C,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;SACnB;IACH,CAAC;;;;;;;IAOD,KAAK;QACH,IAAI,IAAI,CAAC,UAAU,EAAE;YACnB,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,kBAAkB,CAAC,CAAC;YACnF,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;YAC3B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;YACvB,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;YACnB,IAAI,CAAC,eAAe,CAAC,YAAY,EAAE,CAAC;SACrC;IACH,CAAC;;;;;;;IAOD,MAAM;QACJ,IAAI,IAAI,CAAC,UAAU,EAAE;YACnB,IAAI,CAAC,KAAK,EAAE,CAAC;SACd;aAAM;YACL,IAAI,CAAC,IAAI,EAAE,CAAC;SACb;IACH,CAAC;;;;;IAKD,MAAM,KAAc,OAAO,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,CAAC,CAAC;;;;IAErD,QAAQ;QACN,IAAI,CAAC,sBAAsB,GAAG,gBAAgB,CAC1C,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAC3G,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAChE,CAAC;;;;;IAED,WAAW,CAAC,EAAC,UAAU,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAgB;QACjF,IAAI,YAAY,IAAI,IAAI,CAAC,MAAM,EAAE,EAAE;YACjC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,YAAY,GAAG,YAAY,CAAC,YAAY,CAAC;SACnE;QACD,iFAAiF;QACjF,IAAI,CAAC,UAAU,IAAI,YAAY,IAAI,cAAc,CAAC,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE;YACxE,IAAI,CAAC,KAAK,EAAE,CAAC;SACd;IACH,CAAC;;;;IAED,WAAW;QACT,IAAI,CAAC,KAAK,EAAE,CAAC;QACb,qFAAqF;QACrF,0FAA0F;QAC1F,IAAI,IAAI,CAAC,sBAAsB,EAAE;YAC/B,IAAI,CAAC,sBAAsB,EAAE,CAAC;SAC/B;QACD,IAAI,CAAC,iBAAiB,CAAC,WAAW,EAAE,CAAC;IACvC,CAAC;;;YAzOF,SAAS,SAAC,EAAC,QAAQ,EAAE,cAAc,EAAE,QAAQ,EAAE,YAAY,EAAC;;;;YA/C3D,UAAU;YAFV,SAAS;YADT,QAAQ;YAMR,wBAAwB;YADxB,gBAAgB;YAeV,gBAAgB;YAbtB,MAAM;4CA8JwB,MAAM,SAAC,QAAQ;YA3J7C,iBAAiB;YACjB,cAAc;;;wBAoDb,KAAK;yBAOL,KAAK;2BAOL,KAAK;wBAeL,KAAK;uBAQL,KAAK;wBAOL,KAAK;6BAOL,KAAK;2BAOL,KAAK;wBAOL,KAAK;yBAOL,KAAK;oBAKL,MAAM;qBAKN,MAAM;;;;;;;;;;;;;;;IAlFP,+BAAmD;;;;;;;IAOnD,gCAA+C;;;;;;;IAO/C,kCAAiD;;;;;;;;;;;;;;;IAejD,+BAAmC;;;;;;;;IAQnC,8BAA0B;;;;;;;IAO1B,+BAA2B;;;;;;;IAO3B,oCAAiC;;;;;;;IAOjC,kCAA8B;;;;;;;IAO9B,+BAA2B;;;;;;;IAO3B,gCAA4B;;;;;IAK5B,2BAA2C;;;;;IAK3C,4BAA4C;;;;;IAE5C,yCAAwD;;;;;IACxD,mCAAsD;;;;;IACtD,gCAAmD;;;;;IACnD,4CAA+B;;;;;IAC/B,uCAA+B;;;;;IAY3B,iCAA4C;;;;;IAAE,+BAA4B;;;;;IAE1E,6BAAuB;;;;;IAAE,+BAAwC;;;;;IAAE,qCAA0C","sourcesContent":["import {\n  Component,\n  Directive,\n  Input,\n  Output,\n  EventEmitter,\n  ChangeDetectionStrategy,\n  OnInit,\n  OnDestroy,\n  OnChanges,\n  Inject,\n  Injector,\n  Renderer2,\n  ComponentRef,\n  ElementRef,\n  TemplateRef,\n  ViewContainerRef,\n  ComponentFactoryResolver,\n  NgZone,\n  SimpleChanges,\n  ViewEncapsulation,\n  ChangeDetectorRef,\n  ApplicationRef\n} from '@angular/core';\nimport {DOCUMENT} from '@angular/common';\n\nimport {listenToTriggers} from '../util/triggers';\nimport {ngbAutoClose} from '../util/autoclose';\nimport {positionElements, PlacementArray} from '../util/positioning';\nimport {PopupService} from '../util/popup';\n\nimport {NgbPopoverConfig} from './popover-config';\n\nlet nextId = 0;\n\n@Component({\n  selector: 'ngb-popover-window',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n  host: {'[class]': '\"popover\" + (popoverClass ? \" \" + popoverClass : \"\")', 'role': 'tooltip', '[id]': 'id'},\n  template: `\n    <div class=\"arrow\"></div>\n    <h3 class=\"popover-header\" *ngIf=\"title != null\">\n      <ng-template #simpleTitle>{{title}}</ng-template>\n      <ng-template [ngTemplateOutlet]=\"isTitleTemplate() ? title : simpleTitle\" [ngTemplateOutletContext]=\"context\"></ng-template>\n    </h3>\n    <div class=\"popover-body\"><ng-content></ng-content></div>`,\n  styleUrls: ['./popover.scss']\n})\nexport class NgbPopoverWindow {\n  @Input() title: undefined | string | TemplateRef<any>;\n  @Input() id: string;\n  @Input() popoverClass: string;\n  @Input() context: any;\n\n  isTitleTemplate() { return this.title instanceof TemplateRef; }\n}\n\n/**\n * A lightweight and extensible directive for fancy popover creation.\n */\n@Directive({selector: '[ngbPopover]', exportAs: 'ngbPopover'})\nexport class NgbPopover implements OnInit, OnDestroy, OnChanges {\n  /**\n   * Indicates whether the popover should be closed on `Escape` key and inside/outside clicks:\n   *\n   * * `true` - closes on both outside and inside clicks as well as `Escape` presses\n   * * `false` - disables the autoClose feature (NB: triggers still apply)\n   * * `\"inside\"` - closes on inside clicks as well as Escape presses\n   * * `\"outside\"` - closes on outside clicks (sometimes also achievable through triggers)\n   * as well as `Escape` presses\n   *\n   * @since 3.0.0\n   */\n  @Input() autoClose: boolean | 'inside' | 'outside';\n\n  /**\n   * The string content or a `TemplateRef` for the content to be displayed in the popover.\n   *\n   * If the title and the content are empty, the popover won't open.\n   */\n  @Input() ngbPopover: string | TemplateRef<any>;\n\n  /**\n   * The title of the popover.\n   *\n   * If the title and the content are empty, the popover won't open.\n   */\n  @Input() popoverTitle: string | TemplateRef<any>;\n\n  /**\n   * The preferred placement of the popover.\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 `\"auto\"` (same as the sequence above).\n   *\n   * Please see the [positioning overview](#/positioning) for more details.\n   */\n  @Input() placement: PlacementArray;\n\n  /**\n   * Specifies events that should trigger the tooltip.\n   *\n   * Supports a space separated list of event names.\n   * For more details see the [triggers demo](#/components/popover/examples#triggers).\n   */\n  @Input() triggers: string;\n\n  /**\n   * A selector specifying the element the popover should be appended to.\n   *\n   * Currently only supports `body`.\n   */\n  @Input() container: string;\n\n  /**\n   * If `true`, popover is disabled and won't be displayed.\n   *\n   * @since 1.1.0\n   */\n  @Input() disablePopover: boolean;\n\n  /**\n   * An optional class applied to the popover window element.\n   *\n   * @since 2.2.0\n   */\n  @Input() popoverClass: string;\n\n  /**\n   * The opening delay in ms. Works only for \"non-manual\" opening triggers defined by the `triggers` input.\n   *\n   * @since 4.1.0\n   */\n  @Input() openDelay: number;\n\n  /**\n   * The closing delay in ms. Works only for \"non-manual\" opening triggers defined by the `triggers` input.\n   *\n   * @since 4.1.0\n   */\n  @Input() closeDelay: number;\n\n  /**\n   * An event emitted when the popover is shown. Contains no payload.\n   */\n  @Output() shown = new EventEmitter<void>();\n\n  /**\n   * An event emitted when the popover is hidden. Contains no payload.\n   */\n  @Output() hidden = new EventEmitter<void>();\n\n  private _ngbPopoverWindowId = `ngb-popover-${nextId++}`;\n  private _popupService: PopupService<NgbPopoverWindow>;\n  private _windowRef: ComponentRef<NgbPopoverWindow>;\n  private _unregisterListenersFn;\n  private _zoneSubscription: any;\n  private _isDisabled(): boolean {\n    if (this.disablePopover) {\n      return true;\n    }\n    if (!this.ngbPopover && !this.popoverTitle) {\n      return true;\n    }\n    return false;\n  }\n\n  constructor(\n      private _elementRef: ElementRef<HTMLElement>, private _renderer: Renderer2, injector: Injector,\n      componentFactoryResolver: ComponentFactoryResolver, viewContainerRef: ViewContainerRef, config: NgbPopoverConfig,\n      private _ngZone: NgZone, @Inject(DOCUMENT) private _document: any, private _changeDetector: ChangeDetectorRef,\n      applicationRef: ApplicationRef) {\n    this.autoClose = config.autoClose;\n    this.placement = config.placement;\n    this.triggers = config.triggers;\n    this.container = config.container;\n    this.disablePopover = config.disablePopover;\n    this.popoverClass = config.popoverClass;\n    this.openDelay = config.openDelay;\n    this.closeDelay = config.closeDelay;\n    this._popupService = new PopupService<NgbPopoverWindow>(\n        NgbPopoverWindow, injector, viewContainerRef, _renderer, componentFactoryResolver, applicationRef);\n\n    this._zoneSubscription = _ngZone.onStable.subscribe(() => {\n      if (this._windowRef) {\n        positionElements(\n            this._elementRef.nativeElement, this._windowRef.location.nativeElement, this.placement,\n            this.container === 'body', 'bs-popover');\n      }\n    });\n  }\n\n  /**\n   * Opens the popover.\n   *\n   * This is considered to be a \"manual\" triggering.\n   * The `context` is an optional value to be injected into the popover template when it is created.\n   */\n  open(context?: any) {\n    if (!this._windowRef && !this._isDisabled()) {\n      this._windowRef = this._popupService.open(this.ngbPopover, context);\n      this._windowRef.instance.title = this.popoverTitle;\n      this._windowRef.instance.context = context;\n      this._windowRef.instance.popoverClass = this.popoverClass;\n      this._windowRef.instance.id = this._ngbPopoverWindowId;\n\n      this._renderer.setAttribute(this._elementRef.nativeElement, 'aria-describedby', this._ngbPopoverWindowId);\n\n      if (this.container === 'body') {\n        this._document.querySelector(this.container).appendChild(this._windowRef.location.nativeElement);\n      }\n\n      // We need to detect changes, because we don't know where .open() might be called from.\n      // Ex. opening popover from one of lifecycle hooks that run after the CD\n      // (say from ngAfterViewInit) will result in 'ExpressionHasChanged' exception\n      this._windowRef.changeDetectorRef.detectChanges();\n\n      // We need to mark for check, because popover won't work inside the OnPush component.\n      // Ex. when we use expression like `{{ popover.isOpen() : 'opened' : 'closed' }}`\n      // inside the template of an OnPush component and we change the popover from\n      // open -> closed, the expression in question won't be updated unless we explicitly\n      // mark the parent component to be checked.\n      this._windowRef.changeDetectorRef.markForCheck();\n\n      ngbAutoClose(\n          this._ngZone, this._document, this.autoClose, () => this.close(), this.hidden,\n          [this._windowRef.location.nativeElement]);\n      this.shown.emit();\n    }\n  }\n\n  /**\n   * Closes the popover.\n   *\n   * This is considered to be a \"manual\" triggering of the popover.\n   */\n  close(): void {\n    if (this._windowRef) {\n      this._renderer.removeAttribute(this._elementRef.nativeElement, 'aria-describedby');\n      this._popupService.close();\n      this._windowRef = null;\n      this.hidden.emit();\n      this._changeDetector.markForCheck();\n    }\n  }\n\n  /**\n   * Toggles the popover.\n   *\n   * This is considered to be a \"manual\" triggering of the popover.\n   */\n  toggle(): void {\n    if (this._windowRef) {\n      this.close();\n    } else {\n      this.open();\n    }\n  }\n\n  /**\n   * Returns `true`, if the popover is currently shown.\n   */\n  isOpen(): boolean { return this._windowRef != null; }\n\n  ngOnInit() {\n    this._unregisterListenersFn = listenToTriggers(\n        this._renderer, this._elementRef.nativeElement, this.triggers, this.isOpen.bind(this), this.open.bind(this),\n        this.close.bind(this), +this.openDelay, +this.closeDelay);\n  }\n\n  ngOnChanges({ngbPopover, popoverTitle, disablePopover, popoverClass}: SimpleChanges) {\n    if (popoverClass && this.isOpen()) {\n      this._windowRef.instance.popoverClass = popoverClass.currentValue;\n    }\n    // close popover if title and content become empty, or disablePopover set to true\n    if ((ngbPopover || popoverTitle || disablePopover) && this._isDisabled()) {\n      this.close();\n    }\n  }\n\n  ngOnDestroy() {\n    this.close();\n    // This check is needed as it might happen that ngOnDestroy is called before ngOnInit\n    // under certain conditions, see: https://github.com/ng-bootstrap/ng-bootstrap/issues/2199\n    if (this._unregisterListenersFn) {\n      this._unregisterListenersFn();\n    }\n    this._zoneSubscription.unsubscribe();\n  }\n}\n"]}