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

/**
 * @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: `
    <div class="arrow"></div>
    <h3 class="popover-header" *ngIf="title != null">
      <ng-template #simpleTitle>{{title}}</ng-template>
      <ng-template [ngTemplateOutlet]="isTitleTemplate() ? title : simpleTitle" [ngTemplateOutletContext]="context"></ng-template>
    </h3>
    <div class="popover-body"><ng-content></ng-content></div>`,
                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":"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","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"]}