@kato-lee/cdk 14.2.7

package/esm2020/overlay/overlay-ref.mjs

@@ -0,0 +1,427 @@
+/**
+ * @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 { Subject, merge, Subscription } from 'rxjs';
+import { take, takeUntil } from 'rxjs/operators';
+import { coerceCssPixelValue, coerceArray } from '@kato-lee/cdk/coercion';
+/**
+ * Reference to an overlay that has been created with the Overlay service.
+ * Used to manipulate or dispose of said overlay.
+ */
+export class OverlayRef {
+    constructor(_portalOutlet, _host, _pane, _config, _ngZone, _keyboardDispatcher, _document, _location, _outsideClickDispatcher, _animationsDisabled = false) {
+        this._portalOutlet = _portalOutlet;
+        this._host = _host;
+        this._pane = _pane;
+        this._config = _config;
+        this._ngZone = _ngZone;
+        this._keyboardDispatcher = _keyboardDispatcher;
+        this._document = _document;
+        this._location = _location;
+        this._outsideClickDispatcher = _outsideClickDispatcher;
+        this._animationsDisabled = _animationsDisabled;
+        this._backdropElement = null;
+        this._backdropClick = new Subject();
+        this._attachments = new Subject();
+        this._detachments = new Subject();
+        this._locationChanges = Subscription.EMPTY;
+        this._backdropClickHandler = (event) => this._backdropClick.next(event);
+        this._backdropTransitionendHandler = (event) => {
+            this._disposeBackdrop(event.target);
+        };
+        /** Stream of keydown events dispatched to this overlay. */
+        this._keydownEvents = new Subject();
+        /** Stream of mouse outside events dispatched to this overlay. */
+        this._outsidePointerEvents = new Subject();
+        if (_config.scrollStrategy) {
+            this._scrollStrategy = _config.scrollStrategy;
+            this._scrollStrategy.attach(this);
+        }
+        this._positionStrategy = _config.positionStrategy;
+    }
+    /** The overlay's HTML element */
+    get overlayElement() {
+        return this._pane;
+    }
+    /** The overlay's backdrop HTML element. */
+    get backdropElement() {
+        return this._backdropElement;
+    }
+    /**
+     * Wrapper around the panel element. Can be used for advanced
+     * positioning where a wrapper with specific styling is
+     * required around the overlay pane.
+     */
+    get hostElement() {
+        return this._host;
+    }
+    /**
+     * Attaches content, given via a Portal, to the overlay.
+     * If the overlay is configured to have a backdrop, it will be created.
+     *
+     * @param portal Portal instance to which to attach the overlay.
+     * @returns The portal attachment result.
+     */
+    attach(portal) {
+        // Insert the host into the DOM before attaching the portal, otherwise
+        // the animations module will skip animations on repeat attachments.
+        if (!this._host.parentElement && this._previousHostParent) {
+            this._previousHostParent.appendChild(this._host);
+        }
+        const attachResult = this._portalOutlet.attach(portal);
+        if (this._positionStrategy) {
+            this._positionStrategy.attach(this);
+        }
+        this._updateStackingOrder();
+        this._updateElementSize();
+        this._updateElementDirection();
+        if (this._scrollStrategy) {
+            this._scrollStrategy.enable();
+        }
+        // Update the position once the zone is stable so that the overlay will be fully rendered
+        // before attempting to position it, as the position may depend on the size of the rendered
+        // content.
+        this._ngZone.onStable.pipe(take(1)).subscribe(() => {
+            // The overlay could've been detached before the zone has stabilized.
+            if (this.hasAttached()) {
+                this.updatePosition();
+            }
+        });
+        // Enable pointer events for the overlay pane element.
+        this._togglePointerEvents(true);
+        if (this._config.hasBackdrop) {
+            this._attachBackdrop();
+        }
+        if (this._config.panelClass) {
+            this._toggleClasses(this._pane, this._config.panelClass, true);
+        }
+        // Only emit the `attachments` event once all other setup is done.
+        this._attachments.next();
+        // Track this overlay by the keyboard dispatcher
+        this._keyboardDispatcher.add(this);
+        if (this._config.disposeOnNavigation) {
+            this._locationChanges = this._location.subscribe(() => this.dispose());
+        }
+        this._outsideClickDispatcher.add(this);
+        // TODO(crisbeto): the null check is here, because the portal outlet returns `any`.
+        // We should be guaranteed for the result to be `ComponentRef | EmbeddedViewRef`, but
+        // `instanceof EmbeddedViewRef` doesn't appear to work at the moment.
+        if (typeof attachResult?.onDestroy === 'function') {
+            // In most cases we control the portal and we know when it is being detached so that
+            // we can finish the disposal process. The exception is if the user passes in a custom
+            // `ViewContainerRef` that isn't destroyed through the overlay API. Note that we use
+            // `detach` here instead of `dispose`, because we don't know if the user intends to
+            // reattach the overlay at a later point. It also has the advantage of waiting for animations.
+            attachResult.onDestroy(() => {
+                if (this.hasAttached()) {
+                    // We have to delay the `detach` call, because detaching immediately prevents
+                    // other destroy hooks from running. This is likely a framework bug similar to
+                    // https://github.com/angular/angular/issues/46119
+                    this._ngZone.runOutsideAngular(() => Promise.resolve().then(() => this.detach()));
+                }
+            });
+        }
+        return attachResult;
+    }
+    /**
+     * Detaches an overlay from a portal.
+     * @returns The portal detachment result.
+     */
+    detach() {
+        if (!this.hasAttached()) {
+            return;
+        }
+        this.detachBackdrop();
+        // When the overlay is detached, the pane element should disable pointer events.
+        // This is necessary because otherwise the pane element will cover the page and disable
+        // pointer events therefore. Depends on the position strategy and the applied pane boundaries.
+        this._togglePointerEvents(false);
+        if (this._positionStrategy && this._positionStrategy.detach) {
+            this._positionStrategy.detach();
+        }
+        if (this._scrollStrategy) {
+            this._scrollStrategy.disable();
+        }
+        const detachmentResult = this._portalOutlet.detach();
+        // Only emit after everything is detached.
+        this._detachments.next();
+        // Remove this overlay from keyboard dispatcher tracking.
+        this._keyboardDispatcher.remove(this);
+        // Keeping the host element in the DOM can cause scroll jank, because it still gets
+        // rendered, even though it's transparent and unclickable which is why we remove it.
+        this._detachContentWhenStable();
+        this._locationChanges.unsubscribe();
+        this._outsideClickDispatcher.remove(this);
+        return detachmentResult;
+    }
+    /** Cleans up the overlay from the DOM. */
+    dispose() {
+        const isAttached = this.hasAttached();
+        if (this._positionStrategy) {
+            this._positionStrategy.dispose();
+        }
+        this._disposeScrollStrategy();
+        this._disposeBackdrop(this._backdropElement);
+        this._locationChanges.unsubscribe();
+        this._keyboardDispatcher.remove(this);
+        this._portalOutlet.dispose();
+        this._attachments.complete();
+        this._backdropClick.complete();
+        this._keydownEvents.complete();
+        this._outsidePointerEvents.complete();
+        this._outsideClickDispatcher.remove(this);
+        this._host?.remove();
+        this._previousHostParent = this._pane = this._host = null;
+        if (isAttached) {
+            this._detachments.next();
+        }
+        this._detachments.complete();
+    }
+    /** Whether the overlay has attached content. */
+    hasAttached() {
+        return this._portalOutlet.hasAttached();
+    }
+    /** Gets an observable that emits when the backdrop has been clicked. */
+    backdropClick() {
+        return this._backdropClick;
+    }
+    /** Gets an observable that emits when the overlay has been attached. */
+    attachments() {
+        return this._attachments;
+    }
+    /** Gets an observable that emits when the overlay has been detached. */
+    detachments() {
+        return this._detachments;
+    }
+    /** Gets an observable of keydown events targeted to this overlay. */
+    keydownEvents() {
+        return this._keydownEvents;
+    }
+    /** Gets an observable of pointer events targeted outside this overlay. */
+    outsidePointerEvents() {
+        return this._outsidePointerEvents;
+    }
+    /** Gets the current overlay configuration, which is immutable. */
+    getConfig() {
+        return this._config;
+    }
+    /** Updates the position of the overlay based on the position strategy. */
+    updatePosition() {
+        if (this._positionStrategy) {
+            this._positionStrategy.apply();
+        }
+    }
+    /** Switches to a new position strategy and updates the overlay position. */
+    updatePositionStrategy(strategy) {
+        if (strategy === this._positionStrategy) {
+            return;
+        }
+        if (this._positionStrategy) {
+            this._positionStrategy.dispose();
+        }
+        this._positionStrategy = strategy;
+        if (this.hasAttached()) {
+            strategy.attach(this);
+            this.updatePosition();
+        }
+    }
+    /** Update the size properties of the overlay. */
+    updateSize(sizeConfig) {
+        this._config = { ...this._config, ...sizeConfig };
+        this._updateElementSize();
+    }
+    /** Sets the LTR/RTL direction for the overlay. */
+    setDirection(dir) {
+        this._config = { ...this._config, direction: dir };
+        this._updateElementDirection();
+    }
+    /** Add a CSS class or an array of classes to the overlay pane. */
+    addPanelClass(classes) {
+        if (this._pane) {
+            this._toggleClasses(this._pane, classes, true);
+        }
+    }
+    /** Remove a CSS class or an array of classes from the overlay pane. */
+    removePanelClass(classes) {
+        if (this._pane) {
+            this._toggleClasses(this._pane, classes, false);
+        }
+    }
+    /**
+     * Returns the layout direction of the overlay panel.
+     */
+    getDirection() {
+        const direction = this._config.direction;
+        if (!direction) {
+            return 'ltr';
+        }
+        return typeof direction === 'string' ? direction : direction.value;
+    }
+    /** Switches to a new scroll strategy. */
+    updateScrollStrategy(strategy) {
+        if (strategy === this._scrollStrategy) {
+            return;
+        }
+        this._disposeScrollStrategy();
+        this._scrollStrategy = strategy;
+        if (this.hasAttached()) {
+            strategy.attach(this);
+            strategy.enable();
+        }
+    }
+    /** Updates the text direction of the overlay panel. */
+    _updateElementDirection() {
+        this._host.setAttribute('dir', this.getDirection());
+    }
+    /** Updates the size of the overlay element based on the overlay config. */
+    _updateElementSize() {
+        if (!this._pane) {
+            return;
+        }
+        const style = this._pane.style;
+        style.width = coerceCssPixelValue(this._config.width);
+        style.height = coerceCssPixelValue(this._config.height);
+        style.minWidth = coerceCssPixelValue(this._config.minWidth);
+        style.minHeight = coerceCssPixelValue(this._config.minHeight);
+        style.maxWidth = coerceCssPixelValue(this._config.maxWidth);
+        style.maxHeight = coerceCssPixelValue(this._config.maxHeight);
+    }
+    /** Toggles the pointer events for the overlay pane element. */
+    _togglePointerEvents(enablePointer) {
+        this._pane.style.pointerEvents = enablePointer ? '' : 'none';
+    }
+    /** Attaches a backdrop for this overlay. */
+    _attachBackdrop() {
+        const showingClass = 'cdk-overlay-backdrop-showing';
+        this._backdropElement = this._document.createElement('div');
+        this._backdropElement.classList.add('cdk-overlay-backdrop');
+        if (this._animationsDisabled) {
+            this._backdropElement.classList.add('cdk-overlay-backdrop-noop-animation');
+        }
+        if (this._config.backdropClass) {
+            this._toggleClasses(this._backdropElement, this._config.backdropClass, true);
+        }
+        // Insert the backdrop before the pane in the DOM order,
+        // in order to handle stacked overlays properly.
+        this._host.parentElement.insertBefore(this._backdropElement, this._host);
+        // Forward backdrop clicks such that the consumer of the overlay can perform whatever
+        // action desired when such a click occurs (usually closing the overlay).
+        this._backdropElement.addEventListener('click', this._backdropClickHandler);
+        // Add class to fade-in the backdrop after one frame.
+        if (!this._animationsDisabled && typeof requestAnimationFrame !== 'undefined') {
+            this._ngZone.runOutsideAngular(() => {
+                requestAnimationFrame(() => {
+                    if (this._backdropElement) {
+                        this._backdropElement.classList.add(showingClass);
+                    }
+                });
+            });
+        }
+        else {
+            this._backdropElement.classList.add(showingClass);
+        }
+    }
+    /**
+     * Updates the stacking order of the element, moving it to the top if necessary.
+     * This is required in cases where one overlay was detached, while another one,
+     * that should be behind it, was destroyed. The next time both of them are opened,
+     * the stacking will be wrong, because the detached element's pane will still be
+     * in its original DOM position.
+     */
+    _updateStackingOrder() {
+        if (this._host.nextSibling) {
+            this._host.parentNode.appendChild(this._host);
+        }
+    }
+    /** Detaches the backdrop (if any) associated with the overlay. */
+    detachBackdrop() {
+        const backdropToDetach = this._backdropElement;
+        if (!backdropToDetach) {
+            return;
+        }
+        if (this._animationsDisabled) {
+            this._disposeBackdrop(backdropToDetach);
+            return;
+        }
+        backdropToDetach.classList.remove('cdk-overlay-backdrop-showing');
+        this._ngZone.runOutsideAngular(() => {
+            backdropToDetach.addEventListener('transitionend', this._backdropTransitionendHandler);
+        });
+        // If the backdrop doesn't have a transition, the `transitionend` event won't fire.
+        // In this case we make it unclickable and we try to remove it after a delay.
+        backdropToDetach.style.pointerEvents = 'none';
+        // Run this outside the Angular zone because there's nothing that Angular cares about.
+        // If it were to run inside the Angular zone, every test that used Overlay would have to be
+        // either async or fakeAsync.
+        this._backdropTimeout = this._ngZone.runOutsideAngular(() => setTimeout(() => {
+            this._disposeBackdrop(backdropToDetach);
+        }, 500));
+    }
+    /** Toggles a single CSS class or an array of classes on an element. */
+    _toggleClasses(element, cssClasses, isAdd) {
+        const classes = coerceArray(cssClasses || []).filter(c => !!c);
+        if (classes.length) {
+            isAdd ? element.classList.add(...classes) : element.classList.remove(...classes);
+        }
+    }
+    /** Detaches the overlay content next time the zone stabilizes. */
+    _detachContentWhenStable() {
+        // Normally we wouldn't have to explicitly run this outside the `NgZone`, however
+        // if the consumer is using `zone-patch-rxjs`, the `Subscription.unsubscribe` call will
+        // be patched to run inside the zone, which will throw us into an infinite loop.
+        this._ngZone.runOutsideAngular(() => {
+            // We can't remove the host here immediately, because the overlay pane's content
+            // might still be animating. This stream helps us avoid interrupting the animation
+            // by waiting for the pane to become empty.
+            const subscription = this._ngZone.onStable
+                .pipe(takeUntil(merge(this._attachments, this._detachments)))
+                .subscribe(() => {
+                // Needs a couple of checks for the pane and host, because
+                // they may have been removed by the time the zone stabilizes.
+                if (!this._pane || !this._host || this._pane.children.length === 0) {
+                    if (this._pane && this._config.panelClass) {
+                        this._toggleClasses(this._pane, this._config.panelClass, false);
+                    }
+                    if (this._host && this._host.parentElement) {
+                        this._previousHostParent = this._host.parentElement;
+                        this._host.remove();
+                    }
+                    subscription.unsubscribe();
+                }
+            });
+        });
+    }
+    /** Disposes of a scroll strategy. */
+    _disposeScrollStrategy() {
+        const scrollStrategy = this._scrollStrategy;
+        if (scrollStrategy) {
+            scrollStrategy.disable();
+            if (scrollStrategy.detach) {
+                scrollStrategy.detach();
+            }
+        }
+    }
+    /** Removes a backdrop element from the DOM. */
+    _disposeBackdrop(backdrop) {
+        if (backdrop) {
+            backdrop.removeEventListener('click', this._backdropClickHandler);
+            backdrop.removeEventListener('transitionend', this._backdropTransitionendHandler);
+            backdrop.remove();
+            // It is possible that a new portal has been attached to this overlay since we started
+            // removing the backdrop. If that is the case, only clear the backdrop reference if it
+            // is still the same instance that we started to remove.
+            if (this._backdropElement === backdrop) {
+                this._backdropElement = null;
+            }
+        }
+        if (this._backdropTimeout) {
+            clearTimeout(this._backdropTimeout);
+            this._backdropTimeout = undefined;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay-ref.js","sourceRoot":"","sources":["../../../../../../src/cdk/overlay/overlay-ref.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 {Direction, Directionality} from '@angular/cdk/bidi';\nimport {ComponentPortal, Portal, PortalOutlet, TemplatePortal} from '@angular/cdk/portal';\nimport {ComponentRef, EmbeddedViewRef, NgZone} from '@angular/core';\nimport {Location} from '@angular/common';\nimport {Observable, Subject, merge, SubscriptionLike, Subscription} from 'rxjs';\nimport {take, takeUntil} from 'rxjs/operators';\nimport {OverlayKeyboardDispatcher} from './dispatchers/overlay-keyboard-dispatcher';\nimport {OverlayOutsideClickDispatcher} from './dispatchers/overlay-outside-click-dispatcher';\nimport {OverlayConfig} from './overlay-config';\nimport {coerceCssPixelValue, coerceArray} from '@angular/cdk/coercion';\nimport {OverlayReference} from './overlay-reference';\nimport {PositionStrategy} from './position/position-strategy';\nimport {ScrollStrategy} from './scroll';\n\n/** An object where all of its properties cannot be written. */\nexport type ImmutableObject<T> = {\n  readonly [P in keyof T]: T[P];\n};\n\n/**\n * Reference to an overlay that has been created with the Overlay service.\n * Used to manipulate or dispose of said overlay.\n */\nexport class OverlayRef implements PortalOutlet, OverlayReference {\n  private _backdropElement: HTMLElement | null = null;\n  private _backdropTimeout: number | undefined;\n  private readonly _backdropClick = new Subject<MouseEvent>();\n  private readonly _attachments = new Subject<void>();\n  private readonly _detachments = new Subject<void>();\n  private _positionStrategy: PositionStrategy | undefined;\n  private _scrollStrategy: ScrollStrategy | undefined;\n  private _locationChanges: SubscriptionLike = Subscription.EMPTY;\n  private _backdropClickHandler = (event: MouseEvent) => this._backdropClick.next(event);\n  private _backdropTransitionendHandler = (event: TransitionEvent) => {\n    this._disposeBackdrop(event.target as HTMLElement | null);\n  };\n\n  /**\n   * Reference to the parent of the `_host` at the time it was detached. Used to restore\n   * the `_host` to its original position in the DOM when it gets re-attached.\n   */\n  private _previousHostParent: HTMLElement;\n\n  /** Stream of keydown events dispatched to this overlay. */\n  readonly _keydownEvents = new Subject<KeyboardEvent>();\n\n  /** Stream of mouse outside events dispatched to this overlay. */\n  readonly _outsidePointerEvents = new Subject<MouseEvent>();\n\n  constructor(\n    private _portalOutlet: PortalOutlet,\n    private _host: HTMLElement,\n    private _pane: HTMLElement,\n    private _config: ImmutableObject<OverlayConfig>,\n    private _ngZone: NgZone,\n    private _keyboardDispatcher: OverlayKeyboardDispatcher,\n    private _document: Document,\n    private _location: Location,\n    private _outsideClickDispatcher: OverlayOutsideClickDispatcher,\n    private _animationsDisabled = false,\n  ) {\n    if (_config.scrollStrategy) {\n      this._scrollStrategy = _config.scrollStrategy;\n      this._scrollStrategy.attach(this);\n    }\n\n    this._positionStrategy = _config.positionStrategy;\n  }\n\n  /** The overlay's HTML element */\n  get overlayElement(): HTMLElement {\n    return this._pane;\n  }\n\n  /** The overlay's backdrop HTML element. */\n  get backdropElement(): HTMLElement | null {\n    return this._backdropElement;\n  }\n\n  /**\n   * Wrapper around the panel element. Can be used for advanced\n   * positioning where a wrapper with specific styling is\n   * required around the overlay pane.\n   */\n  get hostElement(): HTMLElement {\n    return this._host;\n  }\n\n  attach<T>(portal: ComponentPortal<T>): ComponentRef<T>;\n  attach<T>(portal: TemplatePortal<T>): EmbeddedViewRef<T>;\n  attach(portal: any): any;\n\n  /**\n   * Attaches content, given via a Portal, to the overlay.\n   * If the overlay is configured to have a backdrop, it will be created.\n   *\n   * @param portal Portal instance to which to attach the overlay.\n   * @returns The portal attachment result.\n   */\n  attach(portal: Portal<any>): any {\n    // Insert the host into the DOM before attaching the portal, otherwise\n    // the animations module will skip animations on repeat attachments.\n    if (!this._host.parentElement && this._previousHostParent) {\n      this._previousHostParent.appendChild(this._host);\n    }\n\n    const attachResult = this._portalOutlet.attach(portal);\n\n    if (this._positionStrategy) {\n      this._positionStrategy.attach(this);\n    }\n\n    this._updateStackingOrder();\n    this._updateElementSize();\n    this._updateElementDirection();\n\n    if (this._scrollStrategy) {\n      this._scrollStrategy.enable();\n    }\n\n    // Update the position once the zone is stable so that the overlay will be fully rendered\n    // before attempting to position it, as the position may depend on the size of the rendered\n    // content.\n    this._ngZone.onStable.pipe(take(1)).subscribe(() => {\n      // The overlay could've been detached before the zone has stabilized.\n      if (this.hasAttached()) {\n        this.updatePosition();\n      }\n    });\n\n    // Enable pointer events for the overlay pane element.\n    this._togglePointerEvents(true);\n\n    if (this._config.hasBackdrop) {\n      this._attachBackdrop();\n    }\n\n    if (this._config.panelClass) {\n      this._toggleClasses(this._pane, this._config.panelClass, true);\n    }\n\n    // Only emit the `attachments` event once all other setup is done.\n    this._attachments.next();\n\n    // Track this overlay by the keyboard dispatcher\n    this._keyboardDispatcher.add(this);\n\n    if (this._config.disposeOnNavigation) {\n      this._locationChanges = this._location.subscribe(() => this.dispose());\n    }\n\n    this._outsideClickDispatcher.add(this);\n\n    // TODO(crisbeto): the null check is here, because the portal outlet returns `any`.\n    // We should be guaranteed for the result to be `ComponentRef | EmbeddedViewRef`, but\n    // `instanceof EmbeddedViewRef` doesn't appear to work at the moment.\n    if (typeof attachResult?.onDestroy === 'function') {\n      // In most cases we control the portal and we know when it is being detached so that\n      // we can finish the disposal process. The exception is if the user passes in a custom\n      // `ViewContainerRef` that isn't destroyed through the overlay API. Note that we use\n      // `detach` here instead of `dispose`, because we don't know if the user intends to\n      // reattach the overlay at a later point. It also has the advantage of waiting for animations.\n      attachResult.onDestroy(() => {\n        if (this.hasAttached()) {\n          // We have to delay the `detach` call, because detaching immediately prevents\n          // other destroy hooks from running. This is likely a framework bug similar to\n          // https://github.com/angular/angular/issues/46119\n          this._ngZone.runOutsideAngular(() => Promise.resolve().then(() => this.detach()));\n        }\n      });\n    }\n\n    return attachResult;\n  }\n\n  /**\n   * Detaches an overlay from a portal.\n   * @returns The portal detachment result.\n   */\n  detach(): any {\n    if (!this.hasAttached()) {\n      return;\n    }\n\n    this.detachBackdrop();\n\n    // When the overlay is detached, the pane element should disable pointer events.\n    // This is necessary because otherwise the pane element will cover the page and disable\n    // pointer events therefore. Depends on the position strategy and the applied pane boundaries.\n    this._togglePointerEvents(false);\n\n    if (this._positionStrategy && this._positionStrategy.detach) {\n      this._positionStrategy.detach();\n    }\n\n    if (this._scrollStrategy) {\n      this._scrollStrategy.disable();\n    }\n\n    const detachmentResult = this._portalOutlet.detach();\n\n    // Only emit after everything is detached.\n    this._detachments.next();\n\n    // Remove this overlay from keyboard dispatcher tracking.\n    this._keyboardDispatcher.remove(this);\n\n    // Keeping the host element in the DOM can cause scroll jank, because it still gets\n    // rendered, even though it's transparent and unclickable which is why we remove it.\n    this._detachContentWhenStable();\n    this._locationChanges.unsubscribe();\n    this._outsideClickDispatcher.remove(this);\n    return detachmentResult;\n  }\n\n  /** Cleans up the overlay from the DOM. */\n  dispose(): void {\n    const isAttached = this.hasAttached();\n\n    if (this._positionStrategy) {\n      this._positionStrategy.dispose();\n    }\n\n    this._disposeScrollStrategy();\n    this._disposeBackdrop(this._backdropElement);\n    this._locationChanges.unsubscribe();\n    this._keyboardDispatcher.remove(this);\n    this._portalOutlet.dispose();\n    this._attachments.complete();\n    this._backdropClick.complete();\n    this._keydownEvents.complete();\n    this._outsidePointerEvents.complete();\n    this._outsideClickDispatcher.remove(this);\n    this._host?.remove();\n\n    this._previousHostParent = this._pane = this._host = null!;\n\n    if (isAttached) {\n      this._detachments.next();\n    }\n\n    this._detachments.complete();\n  }\n\n  /** Whether the overlay has attached content. */\n  hasAttached(): boolean {\n    return this._portalOutlet.hasAttached();\n  }\n\n  /** Gets an observable that emits when the backdrop has been clicked. */\n  backdropClick(): Observable<MouseEvent> {\n    return this._backdropClick;\n  }\n\n  /** Gets an observable that emits when the overlay has been attached. */\n  attachments(): Observable<void> {\n    return this._attachments;\n  }\n\n  /** Gets an observable that emits when the overlay has been detached. */\n  detachments(): Observable<void> {\n    return this._detachments;\n  }\n\n  /** Gets an observable of keydown events targeted to this overlay. */\n  keydownEvents(): Observable<KeyboardEvent> {\n    return this._keydownEvents;\n  }\n\n  /** Gets an observable of pointer events targeted outside this overlay. */\n  outsidePointerEvents(): Observable<MouseEvent> {\n    return this._outsidePointerEvents;\n  }\n\n  /** Gets the current overlay configuration, which is immutable. */\n  getConfig(): OverlayConfig {\n    return this._config;\n  }\n\n  /** Updates the position of the overlay based on the position strategy. */\n  updatePosition(): void {\n    if (this._positionStrategy) {\n      this._positionStrategy.apply();\n    }\n  }\n\n  /** Switches to a new position strategy and updates the overlay position. */\n  updatePositionStrategy(strategy: PositionStrategy): void {\n    if (strategy === this._positionStrategy) {\n      return;\n    }\n\n    if (this._positionStrategy) {\n      this._positionStrategy.dispose();\n    }\n\n    this._positionStrategy = strategy;\n\n    if (this.hasAttached()) {\n      strategy.attach(this);\n      this.updatePosition();\n    }\n  }\n\n  /** Update the size properties of the overlay. */\n  updateSize(sizeConfig: OverlaySizeConfig): void {\n    this._config = {...this._config, ...sizeConfig};\n    this._updateElementSize();\n  }\n\n  /** Sets the LTR/RTL direction for the overlay. */\n  setDirection(dir: Direction | Directionality): void {\n    this._config = {...this._config, direction: dir};\n    this._updateElementDirection();\n  }\n\n  /** Add a CSS class or an array of classes to the overlay pane. */\n  addPanelClass(classes: string | string[]): void {\n    if (this._pane) {\n      this._toggleClasses(this._pane, classes, true);\n    }\n  }\n\n  /** Remove a CSS class or an array of classes from the overlay pane. */\n  removePanelClass(classes: string | string[]): void {\n    if (this._pane) {\n      this._toggleClasses(this._pane, classes, false);\n    }\n  }\n\n  /**\n   * Returns the layout direction of the overlay panel.\n   */\n  getDirection(): Direction {\n    const direction = this._config.direction;\n\n    if (!direction) {\n      return 'ltr';\n    }\n\n    return typeof direction === 'string' ? direction : direction.value;\n  }\n\n  /** Switches to a new scroll strategy. */\n  updateScrollStrategy(strategy: ScrollStrategy): void {\n    if (strategy === this._scrollStrategy) {\n      return;\n    }\n\n    this._disposeScrollStrategy();\n    this._scrollStrategy = strategy;\n\n    if (this.hasAttached()) {\n      strategy.attach(this);\n      strategy.enable();\n    }\n  }\n\n  /** Updates the text direction of the overlay panel. */\n  private _updateElementDirection() {\n    this._host.setAttribute('dir', this.getDirection());\n  }\n\n  /** Updates the size of the overlay element based on the overlay config. */\n  private _updateElementSize() {\n    if (!this._pane) {\n      return;\n    }\n\n    const style = this._pane.style;\n\n    style.width = coerceCssPixelValue(this._config.width);\n    style.height = coerceCssPixelValue(this._config.height);\n    style.minWidth = coerceCssPixelValue(this._config.minWidth);\n    style.minHeight = coerceCssPixelValue(this._config.minHeight);\n    style.maxWidth = coerceCssPixelValue(this._config.maxWidth);\n    style.maxHeight = coerceCssPixelValue(this._config.maxHeight);\n  }\n\n  /** Toggles the pointer events for the overlay pane element. */\n  private _togglePointerEvents(enablePointer: boolean) {\n    this._pane.style.pointerEvents = enablePointer ? '' : 'none';\n  }\n\n  /** Attaches a backdrop for this overlay. */\n  private _attachBackdrop() {\n    const showingClass = 'cdk-overlay-backdrop-showing';\n\n    this._backdropElement = this._document.createElement('div');\n    this._backdropElement.classList.add('cdk-overlay-backdrop');\n\n    if (this._animationsDisabled) {\n      this._backdropElement.classList.add('cdk-overlay-backdrop-noop-animation');\n    }\n\n    if (this._config.backdropClass) {\n      this._toggleClasses(this._backdropElement, this._config.backdropClass, true);\n    }\n\n    // Insert the backdrop before the pane in the DOM order,\n    // in order to handle stacked overlays properly.\n    this._host.parentElement!.insertBefore(this._backdropElement, this._host);\n\n    // Forward backdrop clicks such that the consumer of the overlay can perform whatever\n    // action desired when such a click occurs (usually closing the overlay).\n    this._backdropElement.addEventListener('click', this._backdropClickHandler);\n\n    // Add class to fade-in the backdrop after one frame.\n    if (!this._animationsDisabled && typeof requestAnimationFrame !== 'undefined') {\n      this._ngZone.runOutsideAngular(() => {\n        requestAnimationFrame(() => {\n          if (this._backdropElement) {\n            this._backdropElement.classList.add(showingClass);\n          }\n        });\n      });\n    } else {\n      this._backdropElement.classList.add(showingClass);\n    }\n  }\n\n  /**\n   * Updates the stacking order of the element, moving it to the top if necessary.\n   * This is required in cases where one overlay was detached, while another one,\n   * that should be behind it, was destroyed. The next time both of them are opened,\n   * the stacking will be wrong, because the detached element's pane will still be\n   * in its original DOM position.\n   */\n  private _updateStackingOrder() {\n    if (this._host.nextSibling) {\n      this._host.parentNode!.appendChild(this._host);\n    }\n  }\n\n  /** Detaches the backdrop (if any) associated with the overlay. */\n  detachBackdrop(): void {\n    const backdropToDetach = this._backdropElement;\n\n    if (!backdropToDetach) {\n      return;\n    }\n\n    if (this._animationsDisabled) {\n      this._disposeBackdrop(backdropToDetach);\n      return;\n    }\n\n    backdropToDetach.classList.remove('cdk-overlay-backdrop-showing');\n\n    this._ngZone.runOutsideAngular(() => {\n      backdropToDetach!.addEventListener('transitionend', this._backdropTransitionendHandler);\n    });\n\n    // If the backdrop doesn't have a transition, the `transitionend` event won't fire.\n    // In this case we make it unclickable and we try to remove it after a delay.\n    backdropToDetach.style.pointerEvents = 'none';\n\n    // Run this outside the Angular zone because there's nothing that Angular cares about.\n    // If it were to run inside the Angular zone, every test that used Overlay would have to be\n    // either async or fakeAsync.\n    this._backdropTimeout = this._ngZone.runOutsideAngular(() =>\n      setTimeout(() => {\n        this._disposeBackdrop(backdropToDetach);\n      }, 500),\n    );\n  }\n\n  /** Toggles a single CSS class or an array of classes on an element. */\n  private _toggleClasses(element: HTMLElement, cssClasses: string | string[], isAdd: boolean) {\n    const classes = coerceArray(cssClasses || []).filter(c => !!c);\n\n    if (classes.length) {\n      isAdd ? element.classList.add(...classes) : element.classList.remove(...classes);\n    }\n  }\n\n  /** Detaches the overlay content next time the zone stabilizes. */\n  private _detachContentWhenStable() {\n    // Normally we wouldn't have to explicitly run this outside the `NgZone`, however\n    // if the consumer is using `zone-patch-rxjs`, the `Subscription.unsubscribe` call will\n    // be patched to run inside the zone, which will throw us into an infinite loop.\n    this._ngZone.runOutsideAngular(() => {\n      // We can't remove the host here immediately, because the overlay pane's content\n      // might still be animating. This stream helps us avoid interrupting the animation\n      // by waiting for the pane to become empty.\n      const subscription = this._ngZone.onStable\n        .pipe(takeUntil(merge(this._attachments, this._detachments)))\n        .subscribe(() => {\n          // Needs a couple of checks for the pane and host, because\n          // they may have been removed by the time the zone stabilizes.\n          if (!this._pane || !this._host || this._pane.children.length === 0) {\n            if (this._pane && this._config.panelClass) {\n              this._toggleClasses(this._pane, this._config.panelClass, false);\n            }\n\n            if (this._host && this._host.parentElement) {\n              this._previousHostParent = this._host.parentElement;\n              this._host.remove();\n            }\n\n            subscription.unsubscribe();\n          }\n        });\n    });\n  }\n\n  /** Disposes of a scroll strategy. */\n  private _disposeScrollStrategy() {\n    const scrollStrategy = this._scrollStrategy;\n\n    if (scrollStrategy) {\n      scrollStrategy.disable();\n\n      if (scrollStrategy.detach) {\n        scrollStrategy.detach();\n      }\n    }\n  }\n\n  /** Removes a backdrop element from the DOM. */\n  private _disposeBackdrop(backdrop: HTMLElement | null) {\n    if (backdrop) {\n      backdrop.removeEventListener('click', this._backdropClickHandler);\n      backdrop.removeEventListener('transitionend', this._backdropTransitionendHandler);\n      backdrop.remove();\n\n      // It is possible that a new portal has been attached to this overlay since we started\n      // removing the backdrop. If that is the case, only clear the backdrop reference if it\n      // is still the same instance that we started to remove.\n      if (this._backdropElement === backdrop) {\n        this._backdropElement = null;\n      }\n    }\n\n    if (this._backdropTimeout) {\n      clearTimeout(this._backdropTimeout);\n      this._backdropTimeout = undefined;\n    }\n  }\n}\n\n/** Size properties for an overlay. */\nexport interface OverlaySizeConfig {\n  width?: number | string;\n  height?: number | string;\n  minWidth?: number | string;\n  minHeight?: number | string;\n  maxWidth?: number | string;\n  maxHeight?: number | string;\n}\n"]}

package/esm2020/overlay/overlay-reference.mjs

@@ -0,0 +1,9 @@
+/**
+ * @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
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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