/**
 * @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, 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 { NgbTooltipConfig } from './tooltip-config';
/** @type {?} */
let nextId = 0;
export class NgbTooltipWindow {
}
NgbTooltipWindow.decorators = [
    { type: Component, args: [{
                selector: 'ngb-tooltip-window',
                changeDetection: ChangeDetectionStrategy.OnPush,
                encapsulation: ViewEncapsulation.None,
                host: { '[class]': '"tooltip show" + (tooltipClass ? " " + tooltipClass : "")', 'role': 'tooltip', '[id]': 'id' },
                template: `<div class="arrow"></div><div class="tooltip-inner"><ng-content></ng-content></div>`,
                styles: ["ngb-tooltip-window.bs-tooltip-bottom .arrow,ngb-tooltip-window.bs-tooltip-top .arrow{left:calc(50% - .4rem)}ngb-tooltip-window.bs-tooltip-bottom-left .arrow,ngb-tooltip-window.bs-tooltip-top-left .arrow{left:1em}ngb-tooltip-window.bs-tooltip-bottom-right .arrow,ngb-tooltip-window.bs-tooltip-top-right .arrow{left:auto;right:.8rem}ngb-tooltip-window.bs-tooltip-left .arrow,ngb-tooltip-window.bs-tooltip-right .arrow{top:calc(50% - .4rem)}ngb-tooltip-window.bs-tooltip-left-top .arrow,ngb-tooltip-window.bs-tooltip-right-top .arrow{top:.4rem}ngb-tooltip-window.bs-tooltip-left-bottom .arrow,ngb-tooltip-window.bs-tooltip-right-bottom .arrow{top:auto;bottom:.4rem}"]
            }] }
];
NgbTooltipWindow.propDecorators = {
    id: [{ type: Input }],
    tooltipClass: [{ type: Input }]
};
if (false) {
    /** @type {?} */
    NgbTooltipWindow.prototype.id;
    /** @type {?} */
    NgbTooltipWindow.prototype.tooltipClass;
}
/**
 * A lightweight and extensible directive for fancy tooltip creation.
 */
export class NgbTooltip {
    /**
     * @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 tooltip 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._ngbTooltipWindowId = `ngb-tooltip-${nextId++}`;
        this.autoClose = config.autoClose;
        this.placement = config.placement;
        this.triggers = config.triggers;
        this.container = config.container;
        this.disableTooltip = config.disableTooltip;
        this.tooltipClass = config.tooltipClass;
        this.openDelay = config.openDelay;
        this.closeDelay = config.closeDelay;
        this._popupService = new PopupService(NgbTooltipWindow, 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-tooltip');
            }
        }));
    }
    /**
     * The string content or a `TemplateRef` for the content to be displayed in the tooltip.
     *
     * If the content if falsy, the tooltip won't open.
     * @param {?} value
     * @return {?}
     */
    set ngbTooltip(value) {
        this._ngbTooltip = value;
        if (!value && this._windowRef) {
            this.close();
        }
    }
    /**
     * @return {?}
     */
    get ngbTooltip() { return this._ngbTooltip; }
    /**
     * Opens the tooltip.
     *
     * This is considered to be a "manual" triggering.
     * The `context` is an optional value to be injected into the tooltip template when it is created.
     * @param {?=} context
     * @return {?}
     */
    open(context) {
        if (!this._windowRef && this._ngbTooltip && !this.disableTooltip) {
            this._windowRef = this._popupService.open(this._ngbTooltip, context);
            this._windowRef.instance.tooltipClass = this.tooltipClass;
            this._windowRef.instance.id = this._ngbTooltipWindowId;
            this._renderer.setAttribute(this._elementRef.nativeElement, 'aria-describedby', this._ngbTooltipWindowId);
            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 tooltip 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 tooltip won't work inside the OnPush component.
            // Ex. when we use expression like `{{ tooltip.isOpen() : 'opened' : 'closed' }}`
            // inside the template of an OnPush component and we change the tooltip 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 tooltip.
     *
     * This is considered to be a "manual" triggering of the tooltip.
     * @return {?}
     */
    close() {
        if (this._windowRef != null) {
            this._renderer.removeAttribute(this._elementRef.nativeElement, 'aria-describedby');
            this._popupService.close();
            this._windowRef = null;
            this.hidden.emit();
            this._changeDetector.markForCheck();
        }
    }
    /**
     * Toggles the tooltip.
     *
     * This is considered to be a "manual" triggering of the tooltip.
     * @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({ tooltipClass }) {
        if (tooltipClass && this.isOpen()) {
            this._windowRef.instance.tooltipClass = tooltipClass.currentValue;
        }
    }
    /**
     * @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();
    }
}
NgbTooltip.decorators = [
    { type: Directive, args: [{ selector: '[ngbTooltip]', exportAs: 'ngbTooltip' },] }
];
/** @nocollapse */
NgbTooltip.ctorParameters = () => [
    { type: ElementRef },
    { type: Renderer2 },
    { type: Injector },
    { type: ComponentFactoryResolver },
    { type: ViewContainerRef },
    { type: NgbTooltipConfig },
    { type: NgZone },
    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
    { type: ChangeDetectorRef },
    { type: ApplicationRef }
];
NgbTooltip.propDecorators = {
    autoClose: [{ type: Input }],
    placement: [{ type: Input }],
    triggers: [{ type: Input }],
    container: [{ type: Input }],
    disableTooltip: [{ type: Input }],
    tooltipClass: [{ type: Input }],
    openDelay: [{ type: Input }],
    closeDelay: [{ type: Input }],
    shown: [{ type: Output }],
    hidden: [{ type: Output }],
    ngbTooltip: [{ type: Input }]
};
if (false) {
    /**
     * Indicates whether the tooltip 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 {?}
     */
    NgbTooltip.prototype.autoClose;
    /**
     * The preferred placement of the tooltip.
     *
     * 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 {?}
     */
    NgbTooltip.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/tooltip/examples#triggers).
     * @type {?}
     */
    NgbTooltip.prototype.triggers;
    /**
     * A selector specifying the element the tooltip should be appended to.
     *
     * Currently only supports `"body"`.
     * @type {?}
     */
    NgbTooltip.prototype.container;
    /**
     * If `true`, tooltip is disabled and won't be displayed.
     *
     * \@since 1.1.0
     * @type {?}
     */
    NgbTooltip.prototype.disableTooltip;
    /**
     * An optional class applied to the tooltip window element.
     *
     * \@since 3.2.0
     * @type {?}
     */
    NgbTooltip.prototype.tooltipClass;
    /**
     * The opening delay in ms. Works only for "non-manual" opening triggers defined by the `triggers` input.
     *
     * \@since 4.1.0
     * @type {?}
     */
    NgbTooltip.prototype.openDelay;
    /**
     * The closing delay in ms. Works only for "non-manual" opening triggers defined by the `triggers` input.
     *
     * \@since 4.1.0
     * @type {?}
     */
    NgbTooltip.prototype.closeDelay;
    /**
     * An event emitted when the tooltip is shown. Contains no payload.
     * @type {?}
     */
    NgbTooltip.prototype.shown;
    /**
     * An event emitted when the popover is hidden. Contains no payload.
     * @type {?}
     */
    NgbTooltip.prototype.hidden;
    /**
     * @type {?}
     * @private
     */
    NgbTooltip.prototype._ngbTooltip;
    /**
     * @type {?}
     * @private
     */
    NgbTooltip.prototype._ngbTooltipWindowId;
    /**
     * @type {?}
     * @private
     */
    NgbTooltip.prototype._popupService;
    /**
     * @type {?}
     * @private
     */
    NgbTooltip.prototype._windowRef;
    /**
     * @type {?}
     * @private
     */
    NgbTooltip.prototype._unregisterListenersFn;
    /**
     * @type {?}
     * @private
     */
    NgbTooltip.prototype._zoneSubscription;
    /**
     * @type {?}
     * @private
     */
    NgbTooltip.prototype._elementRef;
    /**
     * @type {?}
     * @private
     */
    NgbTooltip.prototype._renderer;
    /**
     * @type {?}
     * @private
     */
    NgbTooltip.prototype._ngZone;
    /**
     * @type {?}
     * @private
     */
    NgbTooltip.prototype._document;
    /**
     * @type {?}
     * @private
     */
    NgbTooltip.prototype._changeDetector;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tooltip.js","sourceRoot":"ng://@ng-bootstrap/ng-bootstrap/","sources":["tooltip/tooltip.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  Inject,\n  Injector,\n  Renderer2,\n  ComponentRef,\n  ElementRef,\n  TemplateRef,\n  ViewContainerRef,\n  ComponentFactoryResolver,\n  NgZone,\n  ViewEncapsulation,\n  ChangeDetectorRef,\n  ApplicationRef,\n  OnChanges,\n  SimpleChanges\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 {NgbTooltipConfig} from './tooltip-config';\n\nlet nextId = 0;\n\n@Component({\n  selector: 'ngb-tooltip-window',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n  host: {'[class]': '\"tooltip show\" + (tooltipClass ? \" \" + tooltipClass : \"\")', 'role': 'tooltip', '[id]': 'id'},\n  template: `<div class=\"arrow\"></div><div class=\"tooltip-inner\"><ng-content></ng-content></div>`,\n  styleUrls: ['./tooltip.scss']\n})\nexport class NgbTooltipWindow {\n  @Input() id: string;\n  @Input() tooltipClass: string;\n}\n\n/**\n * A lightweight and extensible directive for fancy tooltip creation.\n */\n@Directive({selector: '[ngbTooltip]', exportAs: 'ngbTooltip'})\nexport class NgbTooltip implements OnInit, OnDestroy, OnChanges {\n  /**\n   * Indicates whether the tooltip 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 preferred placement of the tooltip.\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/tooltip/examples#triggers).\n   */\n  @Input() triggers: string;\n\n  /**\n   * A selector specifying the element the tooltip should be appended to.\n   *\n   * Currently only supports `\"body\"`.\n   */\n  @Input() container: string;\n\n  /**\n   * If `true`, tooltip is disabled and won't be displayed.\n   *\n   * @since 1.1.0\n   */\n  @Input() disableTooltip: boolean;\n\n  /**\n   * An optional class applied to the tooltip window element.\n   *\n   * @since 3.2.0\n   */\n  @Input() tooltipClass: 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 tooltip is shown. Contains no payload.\n   */\n  @Output() shown = new EventEmitter();\n  /**\n   * An event emitted when the popover is hidden. Contains no payload.\n   */\n  @Output() hidden = new EventEmitter();\n\n  private _ngbTooltip: string | TemplateRef<any>;\n  private _ngbTooltipWindowId = `ngb-tooltip-${nextId++}`;\n  private _popupService: PopupService<NgbTooltipWindow>;\n  private _windowRef: ComponentRef<NgbTooltipWindow>;\n  private _unregisterListenersFn;\n  private _zoneSubscription: any;\n\n  constructor(\n      private _elementRef: ElementRef<HTMLElement>, private _renderer: Renderer2, injector: Injector,\n      componentFactoryResolver: ComponentFactoryResolver, viewContainerRef: ViewContainerRef, config: NgbTooltipConfig,\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.disableTooltip = config.disableTooltip;\n    this.tooltipClass = config.tooltipClass;\n    this.openDelay = config.openDelay;\n    this.closeDelay = config.closeDelay;\n    this._popupService = new PopupService<NgbTooltipWindow>(\n        NgbTooltipWindow, 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-tooltip');\n      }\n    });\n  }\n\n  /**\n   * The string content or a `TemplateRef` for the content to be displayed in the tooltip.\n   *\n   * If the content if falsy, the tooltip won't open.\n   */\n  @Input()\n  set ngbTooltip(value: string | TemplateRef<any>) {\n    this._ngbTooltip = value;\n    if (!value && this._windowRef) {\n      this.close();\n    }\n  }\n\n  get ngbTooltip() { return this._ngbTooltip; }\n\n  /**\n   * Opens the tooltip.\n   *\n   * This is considered to be a \"manual\" triggering.\n   * The `context` is an optional value to be injected into the tooltip template when it is created.\n   */\n  open(context?: any) {\n    if (!this._windowRef && this._ngbTooltip && !this.disableTooltip) {\n      this._windowRef = this._popupService.open(this._ngbTooltip, context);\n      this._windowRef.instance.tooltipClass = this.tooltipClass;\n      this._windowRef.instance.id = this._ngbTooltipWindowId;\n\n      this._renderer.setAttribute(this._elementRef.nativeElement, 'aria-describedby', this._ngbTooltipWindowId);\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 tooltip 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 tooltip won't work inside the OnPush component.\n      // Ex. when we use expression like `{{ tooltip.isOpen() : 'opened' : 'closed' }}`\n      // inside the template of an OnPush component and we change the tooltip 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\n      this.shown.emit();\n    }\n  }\n\n  /**\n   * Closes the tooltip.\n   *\n   * This is considered to be a \"manual\" triggering of the tooltip.\n   */\n  close(): void {\n    if (this._windowRef != null) {\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 tooltip.\n   *\n   * This is considered to be a \"manual\" triggering of the tooltip.\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({tooltipClass}: SimpleChanges) {\n    if (tooltipClass && this.isOpen()) {\n      this._windowRef.instance.tooltipClass = tooltipClass.currentValue;\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"]}