@angular/cdk
Version:
Angular Material Component Development Kit
202 lines • 16.9 kB
JavaScript
/**
* @fileoverview added by tsickle
* Generated from: src/cdk/overlay/overlay.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @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, Optional, } from '@angular/core';
import { OverlayKeyboardDispatcher } from './keyboard/overlay-keyboard-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.
* @type {?}
*/
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 {
/**
* @param {?} scrollStrategies
* @param {?} _overlayContainer
* @param {?} _componentFactoryResolver
* @param {?} _positionBuilder
* @param {?} _keyboardDispatcher
* @param {?} _injector
* @param {?} _ngZone
* @param {?} _document
* @param {?} _directionality
* @param {?=} _location
*/
constructor(scrollStrategies, _overlayContainer, _componentFactoryResolver, _positionBuilder, _keyboardDispatcher, _injector, _ngZone, _document, _directionality, _location) {
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;
}
/**
* Creates an overlay.
* @param {?=} config Configuration applied to the overlay.
* @return {?} Reference to the created overlay.
*/
create(config) {
/** @type {?} */
const host = this._createHostElement();
/** @type {?} */
const pane = this._createPaneElement(host);
/** @type {?} */
const portalOutlet = this._createPortalOutlet(pane);
/** @type {?} */
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);
}
/**
* Gets a position builder that can be used, via fluent API,
* to construct and configure a position strategy.
* @return {?} An overlay position builder.
*/
position() {
return this._positionBuilder;
}
/**
* Creates the DOM element for an overlay and appends it to the overlay container.
* @private
* @param {?} host
* @return {?} Newly-created pane element
*/
_createPaneElement(host) {
/** @type {?} */
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.
* @private
* @return {?} Newly-create host element.
*/
_createHostElement() {
/** @type {?} */
const host = this._document.createElement('div');
this._overlayContainer.getContainerElement().appendChild(host);
return host;
}
/**
* Create a DomPortalOutlet into which the overlay content can be loaded.
* @private
* @param {?} pane The DOM element to turn into a portal outlet.
* @return {?} 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.decorators = [
{ type: Injectable }
];
/** @nocollapse */
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, decorators: [{ type: Optional }] }
];
if (false) {
/**
* @type {?}
* @private
*/
Overlay.prototype._appRef;
/**
* Scrolling strategies that can be used when creating an overlay.
* @type {?}
*/
Overlay.prototype.scrollStrategies;
/**
* @type {?}
* @private
*/
Overlay.prototype._overlayContainer;
/**
* @type {?}
* @private
*/
Overlay.prototype._componentFactoryResolver;
/**
* @type {?}
* @private
*/
Overlay.prototype._positionBuilder;
/**
* @type {?}
* @private
*/
Overlay.prototype._keyboardDispatcher;
/**
* @type {?}
* @private
*/
Overlay.prototype._injector;
/**
* @type {?}
* @private
*/
Overlay.prototype._ngZone;
/**
* @type {?}
* @private
*/
Overlay.prototype._document;
/**
* @type {?}
* @private
*/
Overlay.prototype._directionality;
/**
* @type {?}
* @private
*/
Overlay.prototype._location;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay.js","sourceRoot":"","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  Optional,\n} from '@angular/core';\nimport {OverlayKeyboardDispatcher} from './keyboard/overlay-keyboard-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              // @breaking-change 8.0.0 `_location` parameter to be made required.\n              @Optional() private _location?: Location) { }\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);\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"]}