ahcdashboardui/node_modules/@angular/cdk/esm2015/overlay/overlay.js

/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */
import { Directionality } from '@angular/cdk/bidi';
import { DomPortalOutlet } from '@angular/cdk/portal';
import { DOCUMENT, Location } from '@angular/common';
import { ApplicationRef, ComponentFactoryResolver, Inject, Injectable, Injector, NgZone, } from '@angular/core';
import { OverlayKeyboardDispatcher } from './dispatchers/overlay-keyboard-dispatcher';
import { OverlayOutsideClickDispatcher } from './dispatchers/overlay-outside-click-dispatcher';
import { OverlayConfig } from './overlay-config';
import { OverlayContainer } from './overlay-container';
import { OverlayRef } from './overlay-ref';
import { OverlayPositionBuilder } from './position/overlay-position-builder';
import { ScrollStrategyOptions } from './scroll/index';
/** Next overlay unique ID. */
import * as ɵngcc0 from '@angular/core';
import * as ɵngcc1 from './scroll/index';
import * as ɵngcc2 from './overlay-container';
import * as ɵngcc3 from './position/overlay-position-builder';
import * as ɵngcc4 from './dispatchers/overlay-keyboard-dispatcher';
import * as ɵngcc5 from '@angular/cdk/bidi';
import * as ɵngcc6 from '@angular/common';
import * as ɵngcc7 from './dispatchers/overlay-outside-click-dispatcher';
let nextUniqueId = 0;
// Note that Overlay is *not* scoped to the app root because of the ComponentFactoryResolver
// which needs to be different depending on where OverlayModule is imported.
/**
 * Service to create Overlays. Overlays are dynamically added pieces of floating UI, meant to be
 * used as a low-level building block for other components. Dialogs, tooltips, menus,
 * selects, etc. can all be built using overlays. The service should primarily be used by authors
 * of re-usable components rather than developers building end-user applications.
 *
 * An overlay *is* a PortalOutlet, so any kind of Portal can be loaded into one.
 */
export class Overlay {
    constructor(
    /** Scrolling strategies that can be used when creating an overlay. */
    scrollStrategies, _overlayContainer, _componentFactoryResolver, _positionBuilder, _keyboardDispatcher, _injector, _ngZone, _document, _directionality, _location, _outsideClickDispatcher) {
        this.scrollStrategies = scrollStrategies;
        this._overlayContainer = _overlayContainer;
        this._componentFactoryResolver = _componentFactoryResolver;
        this._positionBuilder = _positionBuilder;
        this._keyboardDispatcher = _keyboardDispatcher;
        this._injector = _injector;
        this._ngZone = _ngZone;
        this._document = _document;
        this._directionality = _directionality;
        this._location = _location;
        this._outsideClickDispatcher = _outsideClickDispatcher;
    }
    /**
     * Creates an overlay.
     * @param config Configuration applied to the overlay.
     * @returns Reference to the created overlay.
     */
    create(config) {
        const host = this._createHostElement();
        const pane = this._createPaneElement(host);
        const portalOutlet = this._createPortalOutlet(pane);
        const overlayConfig = new OverlayConfig(config);
        overlayConfig.direction = overlayConfig.direction || this._directionality.value;
        return new OverlayRef(portalOutlet, host, pane, overlayConfig, this._ngZone, this._keyboardDispatcher, this._document, this._location, this._outsideClickDispatcher);
    }
    /**
     * Gets a position builder that can be used, via fluent API,
     * to construct and configure a position strategy.
     * @returns An overlay position builder.
     */
    position() {
        return this._positionBuilder;
    }
    /**
     * Creates the DOM element for an overlay and appends it to the overlay container.
     * @returns Newly-created pane element
     */
    _createPaneElement(host) {
        const pane = this._document.createElement('div');
        pane.id = `cdk-overlay-${nextUniqueId++}`;
        pane.classList.add('cdk-overlay-pane');
        host.appendChild(pane);
        return pane;
    }
    /**
     * Creates the host element that wraps around an overlay
     * and can be used for advanced positioning.
     * @returns Newly-create host element.
     */
    _createHostElement() {
        const host = this._document.createElement('div');
        this._overlayContainer.getContainerElement().appendChild(host);
        return host;
    }
    /**
     * Create a DomPortalOutlet into which the overlay content can be loaded.
     * @param pane The DOM element to turn into a portal outlet.
     * @returns A portal outlet for the given DOM element.
     */
    _createPortalOutlet(pane) {
        // We have to resolve the ApplicationRef later in order to allow people
        // to use overlay-based providers during app initialization.
        if (!this._appRef) {
            this._appRef = this._injector.get(ApplicationRef);
        }
        return new DomPortalOutlet(pane, this._componentFactoryResolver, this._appRef, this._injector, this._document);
    }
}
Overlay.ɵfac = function Overlay_Factory(t) { return new (t || Overlay)(ɵngcc0.ɵɵinject(ɵngcc1.ScrollStrategyOptions), ɵngcc0.ɵɵinject(ɵngcc2.OverlayContainer), ɵngcc0.ɵɵinject(ɵngcc0.ComponentFactoryResolver), ɵngcc0.ɵɵinject(ɵngcc3.OverlayPositionBuilder), ɵngcc0.ɵɵinject(ɵngcc4.OverlayKeyboardDispatcher), ɵngcc0.ɵɵinject(ɵngcc0.Injector), ɵngcc0.ɵɵinject(ɵngcc0.NgZone), ɵngcc0.ɵɵinject(DOCUMENT), ɵngcc0.ɵɵinject(ɵngcc5.Directionality), ɵngcc0.ɵɵinject(ɵngcc6.Location), ɵngcc0.ɵɵinject(ɵngcc7.OverlayOutsideClickDispatcher)); };
Overlay.ɵprov = /*@__PURE__*/ ɵngcc0.ɵɵdefineInjectable({ token: Overlay, factory: Overlay.ɵfac });
Overlay.ctorParameters = () => [
    { type: ScrollStrategyOptions },
    { type: OverlayContainer },
    { type: ComponentFactoryResolver },
    { type: OverlayPositionBuilder },
    { type: OverlayKeyboardDispatcher },
    { type: Injector },
    { type: NgZone },
    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
    { type: Directionality },
    { type: Location },
    { type: OverlayOutsideClickDispatcher }
];
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(Overlay, [{
        type: Injectable
    }], function () { return [{ type: ɵngcc1.ScrollStrategyOptions }, { type: ɵngcc2.OverlayContainer }, { type: ɵngcc0.ComponentFactoryResolver }, { type: ɵngcc3.OverlayPositionBuilder }, { type: ɵngcc4.OverlayKeyboardDispatcher }, { type: ɵngcc0.Injector }, { type: ɵngcc0.NgZone }, { type: undefined, decorators: [{
                type: Inject,
                args: [DOCUMENT]
            }] }, { type: ɵngcc5.Directionality }, { type: ɵngcc6.Location }, { type: ɵngcc7.OverlayOutsideClickDispatcher }]; }, null); })();

//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"overlay.js","sources":["../../../../../../src/cdk/overlay/overlay.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Directionality} from '@angular/cdk/bidi';\nimport {DomPortalOutlet} from '@angular/cdk/portal';\nimport {DOCUMENT, Location} from '@angular/common';\nimport {\n  ApplicationRef,\n  ComponentFactoryResolver,\n  Inject,\n  Injectable,\n  Injector,\n  NgZone,\n} from '@angular/core';\nimport {OverlayKeyboardDispatcher} from './dispatchers/overlay-keyboard-dispatcher';\nimport {OverlayOutsideClickDispatcher} from './dispatchers/overlay-outside-click-dispatcher';\nimport {OverlayConfig} from './overlay-config';\nimport {OverlayContainer} from './overlay-container';\nimport {OverlayRef} from './overlay-ref';\nimport {OverlayPositionBuilder} from './position/overlay-position-builder';\nimport {ScrollStrategyOptions} from './scroll/index';\n\n\n/** Next overlay unique ID. */\nlet nextUniqueId = 0;\n\n// Note that Overlay is *not* scoped to the app root because of the ComponentFactoryResolver\n// which needs to be different depending on where OverlayModule is imported.\n\n/**\n * Service to create Overlays. Overlays are dynamically added pieces of floating UI, meant to be\n * used as a low-level building block for other components. Dialogs, tooltips, menus,\n * selects, etc. can all be built using overlays. The service should primarily be used by authors\n * of re-usable components rather than developers building end-user applications.\n *\n * An overlay *is* a PortalOutlet, so any kind of Portal can be loaded into one.\n */\n@Injectable()\nexport class Overlay {\n  private _appRef: ApplicationRef;\n\n  constructor(\n              /** Scrolling strategies that can be used when creating an overlay. */\n              public scrollStrategies: ScrollStrategyOptions,\n              private _overlayContainer: OverlayContainer,\n              private _componentFactoryResolver: ComponentFactoryResolver,\n              private _positionBuilder: OverlayPositionBuilder,\n              private _keyboardDispatcher: OverlayKeyboardDispatcher,\n              private _injector: Injector,\n              private _ngZone: NgZone,\n              @Inject(DOCUMENT) private _document: any,\n              private _directionality: Directionality,\n              private _location: Location,\n              private _outsideClickDispatcher: OverlayOutsideClickDispatcher) { }\n\n  /**\n   * Creates an overlay.\n   * @param config Configuration applied to the overlay.\n   * @returns Reference to the created overlay.\n   */\n  create(config?: OverlayConfig): OverlayRef {\n    const host = this._createHostElement();\n    const pane = this._createPaneElement(host);\n    const portalOutlet = this._createPortalOutlet(pane);\n    const overlayConfig = new OverlayConfig(config);\n\n    overlayConfig.direction = overlayConfig.direction || this._directionality.value;\n\n    return new OverlayRef(portalOutlet, host, pane, overlayConfig, this._ngZone,\n      this._keyboardDispatcher, this._document, this._location, this._outsideClickDispatcher);\n  }\n\n  /**\n   * Gets a position builder that can be used, via fluent API,\n   * to construct and configure a position strategy.\n   * @returns An overlay position builder.\n   */\n  position(): OverlayPositionBuilder {\n    return this._positionBuilder;\n  }\n\n  /**\n   * Creates the DOM element for an overlay and appends it to the overlay container.\n   * @returns Newly-created pane element\n   */\n  private _createPaneElement(host: HTMLElement): HTMLElement {\n    const pane = this._document.createElement('div');\n\n    pane.id = `cdk-overlay-${nextUniqueId++}`;\n    pane.classList.add('cdk-overlay-pane');\n    host.appendChild(pane);\n\n    return pane;\n  }\n\n  /**\n   * Creates the host element that wraps around an overlay\n   * and can be used for advanced positioning.\n   * @returns Newly-create host element.\n   */\n  private _createHostElement(): HTMLElement {\n    const host = this._document.createElement('div');\n    this._overlayContainer.getContainerElement().appendChild(host);\n    return host;\n  }\n\n  /**\n   * Create a DomPortalOutlet into which the overlay content can be loaded.\n   * @param pane The DOM element to turn into a portal outlet.\n   * @returns A portal outlet for the given DOM element.\n   */\n  private _createPortalOutlet(pane: HTMLElement): DomPortalOutlet {\n    // We have to resolve the ApplicationRef later in order to allow people\n    // to use overlay-based providers during app initialization.\n    if (!this._appRef) {\n      this._appRef = this._injector.get<ApplicationRef>(ApplicationRef);\n    }\n\n    return new DomPortalOutlet(pane, this._componentFactoryResolver, this._appRef, this._injector,\n                               this._document);\n  }\n}\n"]}