@angular/cdk-experimental 13.0.0-next.7 → 13.0.0-rc.2

package/esm2020/dialog/dialog-container.mjs

@@ -0,0 +1,310 @@
+/**
+ * @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 { animate, state, style, transition, trigger } from '@angular/animations';
+import { FocusTrapFactory, InteractivityChecker } from '@angular/cdk/a11y';
+import { _getFocusedElementPierceShadowDom } from '@angular/cdk/platform';
+import { BasePortalOutlet, CdkPortalOutlet, } from '@angular/cdk/portal';
+import { DOCUMENT } from '@angular/common';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, HostBinding, Inject, NgZone, Optional, ViewChild, ViewEncapsulation, } from '@angular/core';
+import { Subject } from 'rxjs';
+import { distinctUntilChanged } from 'rxjs/operators';
+import { DialogConfig } from './dialog-config';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/a11y";
+import * as i2 from "./dialog-config";
+import * as i3 from "@angular/cdk/portal";
+export function throwDialogContentAlreadyAttachedError() {
+    throw Error('Attempting to attach dialog content after content is already attached');
+}
+/**
+ * Internal component that wraps user-provided dialog content.
+ * @docs-private
+ */
+export class CdkDialogContainer extends BasePortalOutlet {
+    constructor(_elementRef, _focusTrapFactory, _changeDetectorRef, _interactivityChecker, _ngZone, _document, 
+    /** The dialog configuration. */
+    _config) {
+        super();
+        this._elementRef = _elementRef;
+        this._focusTrapFactory = _focusTrapFactory;
+        this._changeDetectorRef = _changeDetectorRef;
+        this._interactivityChecker = _interactivityChecker;
+        this._ngZone = _ngZone;
+        this._config = _config;
+        /** State of the dialog animation. */
+        this._state = 'enter';
+        /** Element that was focused before the dialog was opened. Save this to restore upon close. */
+        this._elementFocusedBeforeDialogWasOpened = null;
+        /** The class that traps and manages focus within the dialog. */
+        this._focusTrap = this._focusTrapFactory.create(this._elementRef.nativeElement);
+        this._ariaModal = true;
+        /** A subject emitting before the dialog enters the view. */
+        this._beforeEnter = new Subject();
+        /** A subject emitting after the dialog enters the view. */
+        this._afterEnter = new Subject();
+        /** A subject emitting before the dialog exits the view. */
+        this._beforeExit = new Subject();
+        /** A subject emitting after the dialog exits the view. */
+        this._afterExit = new Subject();
+        /** Stream of animation `done` events. */
+        this._animationDone = new Subject();
+        /**
+         * Attaches a DOM portal to the dialog container.
+         * @param portal Portal to be attached.
+         * @deprecated To be turned into a method.
+         * @breaking-change 10.0.0
+         */
+        this.attachDomPortal = (portal) => {
+            if (this._portalHost.hasAttached() && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+                throwDialogContentAlreadyAttachedError();
+            }
+            return this._portalHost.attachDomPortal(portal);
+        };
+        this._document = _document;
+        // We use a Subject with a distinctUntilChanged, rather than a callback attached to .done,
+        // because some browsers fire the done event twice and we don't want to emit duplicate events.
+        // See: https://github.com/angular/angular/issues/24084
+        this._animationDone
+            .pipe(distinctUntilChanged((x, y) => {
+            return x.fromState === y.fromState && x.toState === y.toState;
+        }))
+            .subscribe(event => {
+            // Emit lifecycle events based on animation `done` callback.
+            if (event.toState === 'enter') {
+                this._autoFocus();
+                this._afterEnter.next();
+                this._afterEnter.complete();
+            }
+            if (event.fromState === 'enter' && (event.toState === 'void' || event.toState === 'exit')) {
+                this._returnFocusAfterDialog();
+                this._afterExit.next();
+                this._afterExit.complete();
+            }
+        });
+    }
+    // @HostBinding is used in the class as it is expected to be extended. Since @Component decorator
+    // metadata is not inherited by child classes, instead the host binding data is defined in a way
+    // that can be inherited.
+    // tslint:disable:no-host-decorator-in-concrete no-private-getters
+    get _ariaLabel() {
+        return this._config.ariaLabel || null;
+    }
+    get _ariaDescribedBy() {
+        return this._config.ariaDescribedBy;
+    }
+    get _role() {
+        return this._config.role;
+    }
+    get _tabindex() {
+        return -1;
+    }
+    /** Initializes the dialog container with the attached content. */
+    _initializeWithAttachedContent() {
+        // Save the previously focused element. This element will be re-focused
+        // when the dialog closes.
+        this._savePreviouslyFocusedElement();
+        // Move focus onto the dialog immediately in order to prevent the user
+        // from accidentally opening multiple dialogs at the same time.
+        this._focusDialogContainer();
+    }
+    /** Destroy focus trap to place focus back to the element focused before the dialog opened. */
+    ngOnDestroy() {
+        this._focusTrap.destroy();
+        this._animationDone.complete();
+    }
+    /**
+     * Attach a ComponentPortal as content to this dialog container.
+     * @param portal Portal to be attached as the dialog content.
+     */
+    attachComponentPortal(portal) {
+        if (this._portalHost.hasAttached() && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+            throwDialogContentAlreadyAttachedError();
+        }
+        return this._portalHost.attachComponentPortal(portal);
+    }
+    /**
+     * Attach a TemplatePortal as content to this dialog container.
+     * @param portal Portal to be attached as the dialog content.
+     */
+    attachTemplatePortal(portal) {
+        if (this._portalHost.hasAttached() && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+            throwDialogContentAlreadyAttachedError();
+        }
+        return this._portalHost.attachTemplatePortal(portal);
+    }
+    /** Emit lifecycle events based on animation `start` callback. */
+    _onAnimationStart(event) {
+        if (event.toState === 'enter') {
+            this._beforeEnter.next();
+            this._beforeEnter.complete();
+        }
+        if (event.fromState === 'enter' && (event.toState === 'void' || event.toState === 'exit')) {
+            this._beforeExit.next();
+            this._beforeExit.complete();
+        }
+    }
+    /** Starts the dialog exit animation. */
+    _startExiting() {
+        this._state = 'exit';
+        // Mark the container for check so it can react if the
+        // view container is using OnPush change detection.
+        this._changeDetectorRef.markForCheck();
+    }
+    /** Saves a reference to the element that was focused before the dialog was opened. */
+    _savePreviouslyFocusedElement() {
+        if (this._document) {
+            this._elementFocusedBeforeDialogWasOpened = _getFocusedElementPierceShadowDom();
+        }
+    }
+    /** Focuses the dialog container. */
+    _focusDialogContainer() {
+        // Note that there is no focus method when rendering on the server.
+        if (this._elementRef.nativeElement.focus) {
+            this._elementRef.nativeElement.focus();
+        }
+    }
+    /**
+     * Focuses the provided element. If the element is not focusable, it will add a tabIndex
+     * attribute to forcefully focus it. The attribute is removed after focus is moved.
+     * @param element The element to focus.
+     */
+    _forceFocus(element, options) {
+        if (!this._interactivityChecker.isFocusable(element)) {
+            element.tabIndex = -1;
+            // The tabindex attribute should be removed to avoid navigating to that element again
+            this._ngZone.runOutsideAngular(() => {
+                element.addEventListener('blur', () => element.removeAttribute('tabindex'));
+                element.addEventListener('mousedown', () => element.removeAttribute('tabindex'));
+            });
+        }
+        element.focus(options);
+    }
+    /**
+     * Focuses the first element that matches the given selector within the focus trap.
+     * @param selector The CSS selector for the element to set focus to.
+     */
+    _focusByCssSelector(selector, options) {
+        let elementToFocus = this._elementRef.nativeElement.querySelector(selector);
+        if (elementToFocus) {
+            this._forceFocus(elementToFocus, options);
+        }
+    }
+    /**
+     * Autofocus the element specified by the autoFocus field. When autoFocus is not 'dialog', if
+     * for some reason the element cannot be focused, the dialog container will be focused.
+     */
+    _autoFocus() {
+        const element = this._elementRef.nativeElement;
+        // If were to attempt to focus immediately, then the content of the dialog would not yet be
+        // ready in instances where change detection has to run first. To deal with this, we simply
+        // wait for the microtask queue to be empty when setting focus when autoFocus isn't set to
+        // dialog. If the element inside the dialog can't be focused, then the container is focused
+        // so the user can't tab into other elements behind it.
+        switch (this._config.autoFocus) {
+            case false:
+            case 'dialog':
+                const activeElement = _getFocusedElementPierceShadowDom();
+                // Ensure that focus is on the dialog container. It's possible that a different
+                // component tried to move focus while the open animation was running. See:
+                // https://github.com/angular/components/issues/16215. Note that we only want to do this
+                // if the focus isn't inside the dialog already, because it's possible that the consumer
+                // turned off `autoFocus` in order to move focus themselves.
+                if (activeElement !== element && !element.contains(activeElement)) {
+                    element.focus();
+                }
+                break;
+            case true:
+            case 'first-tabbable':
+                this._focusTrap.focusInitialElementWhenReady().then(hasMovedFocus => {
+                    if (!hasMovedFocus) {
+                        element.focus();
+                    }
+                });
+                break;
+            case 'first-heading':
+                this._focusByCssSelector('h1, h2, h3, h4, h5, h6, [role="heading"]');
+                break;
+            default:
+                this._focusByCssSelector(this._config.autoFocus);
+                break;
+        }
+    }
+    /** Returns the focus to the element focused before the dialog was open. */
+    _returnFocusAfterDialog() {
+        const toFocus = this._elementFocusedBeforeDialogWasOpened;
+        // We need the extra check, because IE can set the `activeElement` to null in some cases.
+        if (toFocus && typeof toFocus.focus === 'function') {
+            const activeElement = _getFocusedElementPierceShadowDom();
+            const element = this._elementRef.nativeElement;
+            // Make sure that focus is still inside the dialog or is on the body (usually because a
+            // non-focusable element like the backdrop was clicked) before moving it. It's possible that
+            // the consumer moved it themselves before the animation was done, in which case we shouldn't
+            // do anything.
+            if (!activeElement ||
+                activeElement === this._document.body ||
+                activeElement === element ||
+                element.contains(activeElement)) {
+                toFocus.focus();
+            }
+        }
+    }
+}
+CdkDialogContainer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkDialogContainer, deps: [{ token: i0.ElementRef }, { token: i1.FocusTrapFactory }, { token: i0.ChangeDetectorRef }, { token: i1.InteractivityChecker }, { token: i0.NgZone }, { token: DOCUMENT, optional: true }, { token: i2.DialogConfig }], target: i0.ɵɵFactoryTarget.Component });
+CdkDialogContainer.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0-next.15", type: CdkDialogContainer, selector: "cdk-dialog-container", host: { listeners: { "@dialog.start": "_onAnimationStart($event)", "@dialog.done": "_animationDone.next($event)" }, properties: { "@dialog": "{\n      value: _state,\n      params: {\n        enterAnimationDuration: _config.enterAnimationDuration,\n        exitAnimationDuration: _config.exitAnimationDuration\n      }\n    }", "attr.aria-label": "this._ariaLabel", "attr.aria-describedby": "this._ariaDescribedBy", "attr.role": "this._role", "attr.aria-modal": "this._ariaModal", "attr.tabindex": "this._tabindex" } }, viewQueries: [{ propertyName: "_portalHost", first: true, predicate: CdkPortalOutlet, descendants: true, static: true }], usesInheritance: true, ngImport: i0, template: "<ng-template cdkPortalOutlet></ng-template>\n", styles: ["cdk-dialog-container{background:#fff;border-radius:5px;display:block;padding:10px}\n"], directives: [{ type: i3.CdkPortalOutlet, selector: "[cdkPortalOutlet]", inputs: ["cdkPortalOutlet"], outputs: ["attached"], exportAs: ["cdkPortalOutlet"] }], animations: [
+        trigger('dialog', [
+            state('enter', style({ opacity: 1 })),
+            state('exit, void', style({ opacity: 0 })),
+            transition('* => enter', animate('{{enterAnimationDuration}}')),
+            transition('* => exit, * => void', animate('{{exitAnimationDuration}}')),
+        ]),
+    ], changeDetection: i0.ChangeDetectionStrategy.Default, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkDialogContainer, decorators: [{
+            type: Component,
+            args: [{ selector: 'cdk-dialog-container', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.Default, animations: [
+                        trigger('dialog', [
+                            state('enter', style({ opacity: 1 })),
+                            state('exit, void', style({ opacity: 0 })),
+                            transition('* => enter', animate('{{enterAnimationDuration}}')),
+                            transition('* => exit, * => void', animate('{{exitAnimationDuration}}')),
+                        ]),
+                    ], host: {
+                        '[@dialog]': `{
+      value: _state,
+      params: {
+        enterAnimationDuration: _config.enterAnimationDuration,
+        exitAnimationDuration: _config.exitAnimationDuration
+      }
+    }`,
+                        '(@dialog.start)': '_onAnimationStart($event)',
+                        '(@dialog.done)': '_animationDone.next($event)',
+                    }, template: "<ng-template cdkPortalOutlet></ng-template>\n", styles: ["cdk-dialog-container{background:#fff;border-radius:5px;display:block;padding:10px}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.FocusTrapFactory }, { type: i0.ChangeDetectorRef }, { type: i1.InteractivityChecker }, { type: i0.NgZone }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i2.DialogConfig }]; }, propDecorators: { _ariaLabel: [{
+                type: HostBinding,
+                args: ['attr.aria-label']
+            }], _ariaDescribedBy: [{
+                type: HostBinding,
+                args: ['attr.aria-describedby']
+            }], _role: [{
+                type: HostBinding,
+                args: ['attr.role']
+            }], _ariaModal: [{
+                type: HostBinding,
+                args: ['attr.aria-modal']
+            }], _tabindex: [{
+                type: HostBinding,
+                args: ['attr.tabindex']
+            }], _portalHost: [{
+                type: ViewChild,
+                args: [CdkPortalOutlet, { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog-container.js","sourceRoot":"","sources":["../../../../../../src/cdk-experimental/dialog/dialog-container.ts","../../../../../../src/cdk-experimental/dialog/dialog-container.html"],"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 {animate, AnimationEvent, state, style, transition, trigger} from '@angular/animations';\nimport {FocusTrapFactory, InteractivityChecker} from '@angular/cdk/a11y';\nimport {_getFocusedElementPierceShadowDom} from '@angular/cdk/platform';\nimport {\n  BasePortalOutlet,\n  CdkPortalOutlet,\n  ComponentPortal,\n  DomPortal,\n  TemplatePortal,\n} from '@angular/cdk/portal';\nimport {DOCUMENT} from '@angular/common';\nimport {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ComponentRef,\n  ElementRef,\n  EmbeddedViewRef,\n  HostBinding,\n  Inject,\n  NgZone,\n  OnDestroy,\n  Optional,\n  ViewChild,\n  ViewEncapsulation,\n} from '@angular/core';\nimport {Subject} from 'rxjs';\nimport {distinctUntilChanged} from 'rxjs/operators';\nimport {DialogConfig} from './dialog-config';\n\nexport function throwDialogContentAlreadyAttachedError() {\n  throw Error('Attempting to attach dialog content after content is already attached');\n}\n\n/**\n * Internal component that wraps user-provided dialog content.\n * @docs-private\n */\n@Component({\n  selector: 'cdk-dialog-container',\n  templateUrl: './dialog-container.html',\n  styleUrls: ['dialog-container.css'],\n  encapsulation: ViewEncapsulation.None,\n  // Using OnPush for dialogs caused some G3 sync issues. Disabled until we can track them down.\n  // tslint:disable-next-line:validate-decorators\n  changeDetection: ChangeDetectionStrategy.Default,\n  animations: [\n    trigger('dialog', [\n      state('enter', style({opacity: 1})),\n      state('exit, void', style({opacity: 0})),\n      transition('* => enter', animate('{{enterAnimationDuration}}')),\n      transition('* => exit, * => void', animate('{{exitAnimationDuration}}')),\n    ]),\n  ],\n  host: {\n    '[@dialog]': `{\n      value: _state,\n      params: {\n        enterAnimationDuration: _config.enterAnimationDuration,\n        exitAnimationDuration: _config.exitAnimationDuration\n      }\n    }`,\n    '(@dialog.start)': '_onAnimationStart($event)',\n    '(@dialog.done)': '_animationDone.next($event)',\n  },\n})\nexport class CdkDialogContainer extends BasePortalOutlet implements OnDestroy {\n  private readonly _document: Document;\n\n  /** State of the dialog animation. */\n  _state: 'void' | 'enter' | 'exit' = 'enter';\n\n  /** Element that was focused before the dialog was opened. Save this to restore upon close. */\n  private _elementFocusedBeforeDialogWasOpened: HTMLElement | null = null;\n\n  /** The class that traps and manages focus within the dialog. */\n  private _focusTrap = this._focusTrapFactory.create(this._elementRef.nativeElement);\n\n  // @HostBinding is used in the class as it is expected to be extended. Since @Component decorator\n  // metadata is not inherited by child classes, instead the host binding data is defined in a way\n  // that can be inherited.\n  // tslint:disable:no-host-decorator-in-concrete no-private-getters\n  @HostBinding('attr.aria-label') get _ariaLabel() {\n    return this._config.ariaLabel || null;\n  }\n\n  @HostBinding('attr.aria-describedby')\n  get _ariaDescribedBy() {\n    return this._config.ariaDescribedBy;\n  }\n\n  @HostBinding('attr.role') get _role() {\n    return this._config.role;\n  }\n\n  @HostBinding('attr.aria-modal') _ariaModal: boolean = true;\n\n  @HostBinding('attr.tabindex') get _tabindex() {\n    return -1;\n  }\n  // tslint:disable:no-host-decorator-in-concrete no-private-getters\n\n  /** The portal host inside of this container into which the dialog content will be loaded. */\n  @ViewChild(CdkPortalOutlet, {static: true}) _portalHost: CdkPortalOutlet;\n\n  /** A subject emitting before the dialog enters the view. */\n  readonly _beforeEnter = new Subject<void>();\n\n  /** A subject emitting after the dialog enters the view. */\n  readonly _afterEnter = new Subject<void>();\n\n  /** A subject emitting before the dialog exits the view. */\n  readonly _beforeExit = new Subject<void>();\n\n  /** A subject emitting after the dialog exits the view. */\n  readonly _afterExit = new Subject<void>();\n\n  /** Stream of animation `done` events. */\n  readonly _animationDone = new Subject<AnimationEvent>();\n\n  constructor(\n    private _elementRef: ElementRef<HTMLElement>,\n    private _focusTrapFactory: FocusTrapFactory,\n    private _changeDetectorRef: ChangeDetectorRef,\n    private readonly _interactivityChecker: InteractivityChecker,\n    private readonly _ngZone: NgZone,\n    @Optional() @Inject(DOCUMENT) _document: any,\n    /** The dialog configuration. */\n    public _config: DialogConfig,\n  ) {\n    super();\n\n    this._document = _document;\n\n    // We use a Subject with a distinctUntilChanged, rather than a callback attached to .done,\n    // because some browsers fire the done event twice and we don't want to emit duplicate events.\n    // See: https://github.com/angular/angular/issues/24084\n    this._animationDone\n      .pipe(\n        distinctUntilChanged((x, y) => {\n          return x.fromState === y.fromState && x.toState === y.toState;\n        }),\n      )\n      .subscribe(event => {\n        // Emit lifecycle events based on animation `done` callback.\n        if (event.toState === 'enter') {\n          this._autoFocus();\n          this._afterEnter.next();\n          this._afterEnter.complete();\n        }\n\n        if (event.fromState === 'enter' && (event.toState === 'void' || event.toState === 'exit')) {\n          this._returnFocusAfterDialog();\n          this._afterExit.next();\n          this._afterExit.complete();\n        }\n      });\n  }\n\n  /** Initializes the dialog container with the attached content. */\n  _initializeWithAttachedContent() {\n    // Save the previously focused element. This element will be re-focused\n    // when the dialog closes.\n    this._savePreviouslyFocusedElement();\n    // Move focus onto the dialog immediately in order to prevent the user\n    // from accidentally opening multiple dialogs at the same time.\n    this._focusDialogContainer();\n  }\n\n  /** Destroy focus trap to place focus back to the element focused before the dialog opened. */\n  ngOnDestroy() {\n    this._focusTrap.destroy();\n    this._animationDone.complete();\n  }\n\n  /**\n   * Attach a ComponentPortal as content to this dialog container.\n   * @param portal Portal to be attached as the dialog content.\n   */\n  attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T> {\n    if (this._portalHost.hasAttached() && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throwDialogContentAlreadyAttachedError();\n    }\n\n    return this._portalHost.attachComponentPortal(portal);\n  }\n\n  /**\n   * Attach a TemplatePortal as content to this dialog container.\n   * @param portal Portal to be attached as the dialog content.\n   */\n  attachTemplatePortal<C>(portal: TemplatePortal<C>): EmbeddedViewRef<C> {\n    if (this._portalHost.hasAttached() && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throwDialogContentAlreadyAttachedError();\n    }\n\n    return this._portalHost.attachTemplatePortal(portal);\n  }\n\n  /**\n   * Attaches a DOM portal to the dialog container.\n   * @param portal Portal to be attached.\n   * @deprecated To be turned into a method.\n   * @breaking-change 10.0.0\n   */\n  override attachDomPortal = (portal: DomPortal) => {\n    if (this._portalHost.hasAttached() && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throwDialogContentAlreadyAttachedError();\n    }\n\n    return this._portalHost.attachDomPortal(portal);\n  };\n\n  /** Emit lifecycle events based on animation `start` callback. */\n  _onAnimationStart(event: AnimationEvent) {\n    if (event.toState === 'enter') {\n      this._beforeEnter.next();\n      this._beforeEnter.complete();\n    }\n    if (event.fromState === 'enter' && (event.toState === 'void' || event.toState === 'exit')) {\n      this._beforeExit.next();\n      this._beforeExit.complete();\n    }\n  }\n\n  /** Starts the dialog exit animation. */\n  _startExiting(): void {\n    this._state = 'exit';\n\n    // Mark the container for check so it can react if the\n    // view container is using OnPush change detection.\n    this._changeDetectorRef.markForCheck();\n  }\n\n  /** Saves a reference to the element that was focused before the dialog was opened. */\n  private _savePreviouslyFocusedElement() {\n    if (this._document) {\n      this._elementFocusedBeforeDialogWasOpened = _getFocusedElementPierceShadowDom();\n    }\n  }\n\n  /** Focuses the dialog container. */\n  private _focusDialogContainer() {\n    // Note that there is no focus method when rendering on the server.\n    if (this._elementRef.nativeElement.focus) {\n      this._elementRef.nativeElement.focus();\n    }\n  }\n\n  /**\n   * Focuses the provided element. If the element is not focusable, it will add a tabIndex\n   * attribute to forcefully focus it. The attribute is removed after focus is moved.\n   * @param element The element to focus.\n   */\n  private _forceFocus(element: HTMLElement, options?: FocusOptions) {\n    if (!this._interactivityChecker.isFocusable(element)) {\n      element.tabIndex = -1;\n      // The tabindex attribute should be removed to avoid navigating to that element again\n      this._ngZone.runOutsideAngular(() => {\n        element.addEventListener('blur', () => element.removeAttribute('tabindex'));\n        element.addEventListener('mousedown', () => element.removeAttribute('tabindex'));\n      });\n    }\n    element.focus(options);\n  }\n\n  /**\n   * Focuses the first element that matches the given selector within the focus trap.\n   * @param selector The CSS selector for the element to set focus to.\n   */\n  private _focusByCssSelector(selector: string, options?: FocusOptions) {\n    let elementToFocus = this._elementRef.nativeElement.querySelector(\n      selector,\n    ) as HTMLElement | null;\n    if (elementToFocus) {\n      this._forceFocus(elementToFocus, options);\n    }\n  }\n\n  /**\n   * Autofocus the element specified by the autoFocus field. When autoFocus is not 'dialog', if\n   * for some reason the element cannot be focused, the dialog container will be focused.\n   */\n  private _autoFocus() {\n    const element = this._elementRef.nativeElement;\n\n    // If were to attempt to focus immediately, then the content of the dialog would not yet be\n    // ready in instances where change detection has to run first. To deal with this, we simply\n    // wait for the microtask queue to be empty when setting focus when autoFocus isn't set to\n    // dialog. If the element inside the dialog can't be focused, then the container is focused\n    // so the user can't tab into other elements behind it.\n    switch (this._config.autoFocus) {\n      case false:\n      case 'dialog':\n        const activeElement = _getFocusedElementPierceShadowDom();\n        // Ensure that focus is on the dialog container. It's possible that a different\n        // component tried to move focus while the open animation was running. See:\n        // https://github.com/angular/components/issues/16215. Note that we only want to do this\n        // if the focus isn't inside the dialog already, because it's possible that the consumer\n        // turned off `autoFocus` in order to move focus themselves.\n        if (activeElement !== element && !element.contains(activeElement)) {\n          element.focus();\n        }\n        break;\n      case true:\n      case 'first-tabbable':\n        this._focusTrap.focusInitialElementWhenReady().then(hasMovedFocus => {\n          if (!hasMovedFocus) {\n            element.focus();\n          }\n        });\n        break;\n      case 'first-heading':\n        this._focusByCssSelector('h1, h2, h3, h4, h5, h6, [role=\"heading\"]');\n        break;\n      default:\n        this._focusByCssSelector(this._config.autoFocus!);\n        break;\n    }\n  }\n\n  /** Returns the focus to the element focused before the dialog was open. */\n  private _returnFocusAfterDialog() {\n    const toFocus = this._elementFocusedBeforeDialogWasOpened;\n    // We need the extra check, because IE can set the `activeElement` to null in some cases.\n    if (toFocus && typeof toFocus.focus === 'function') {\n      const activeElement = _getFocusedElementPierceShadowDom();\n      const element = this._elementRef.nativeElement;\n\n      // Make sure that focus is still inside the dialog or is on the body (usually because a\n      // non-focusable element like the backdrop was clicked) before moving it. It's possible that\n      // the consumer moved it themselves before the animation was done, in which case we shouldn't\n      // do anything.\n      if (\n        !activeElement ||\n        activeElement === this._document.body ||\n        activeElement === element ||\n        element.contains(activeElement)\n      ) {\n        toFocus.focus();\n      }\n    }\n  }\n}\n","<ng-template cdkPortalOutlet></ng-template>\n"]}

package/esm2020/dialog/dialog-injectors.mjs

@@ -0,0 +1,30 @@
+/**
+ * @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 { InjectionToken } from '@angular/core';
+import { Overlay } from '@angular/cdk/overlay';
+/** Injection token for the Dialog's ScrollStrategy. */
+export const DIALOG_SCROLL_STRATEGY = new InjectionToken('DialogScrollStrategy');
+/** Injection token for the Dialog's Data. */
+export const DIALOG_DATA = new InjectionToken('DialogData');
+/** Injection token for the DialogRef constructor. */
+export const DIALOG_REF = new InjectionToken('DialogRef');
+/** Injection token for the DialogConfig. */
+export const DIALOG_CONFIG = new InjectionToken('DialogConfig');
+/** Injection token for the Dialog's DialogContainer component. */
+export const DIALOG_CONTAINER = new InjectionToken('DialogContainer');
+/** @docs-private */
+export function MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {
+    return () => overlay.scrollStrategies.block();
+}
+/** @docs-private */
+export const MAT_DIALOG_SCROLL_STRATEGY_PROVIDER = {
+    provide: DIALOG_SCROLL_STRATEGY,
+    deps: [Overlay],
+    useFactory: MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/dialog/dialog-module.mjs

@@ -0,0 +1,57 @@
+/**
+ * @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 { NgModule } from '@angular/core';
+import { OverlayModule } from '@angular/cdk/overlay';
+import { PortalModule } from '@angular/cdk/portal';
+import { A11yModule } from '@angular/cdk/a11y';
+import { Dialog } from './dialog';
+import { CdkDialogContainer } from './dialog-container';
+import { DialogConfig } from './dialog-config';
+import { DialogRef } from './dialog-ref';
+import { DIALOG_CONFIG, DIALOG_CONTAINER, DIALOG_REF, MAT_DIALOG_SCROLL_STRATEGY_PROVIDER, } from './dialog-injectors';
+import * as i0 from "@angular/core";
+export class DialogModule {
+}
+DialogModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: DialogModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+DialogModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: DialogModule, declarations: [CdkDialogContainer], imports: [OverlayModule, PortalModule, A11yModule], exports: [
+        // Re-export the PortalModule so that people extending the `CdkDialogContainer`
+        // don't have to remember to import it or be faced with an unhelpful error.
+        PortalModule,
+        CdkDialogContainer] });
+DialogModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: DialogModule, providers: [
+        Dialog,
+        MAT_DIALOG_SCROLL_STRATEGY_PROVIDER,
+        { provide: DIALOG_REF, useValue: DialogRef },
+        { provide: DIALOG_CONTAINER, useValue: CdkDialogContainer },
+        { provide: DIALOG_CONFIG, useValue: DialogConfig },
+    ], imports: [[OverlayModule, PortalModule, A11yModule], 
+        // Re-export the PortalModule so that people extending the `CdkDialogContainer`
+        // don't have to remember to import it or be faced with an unhelpful error.
+        PortalModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: DialogModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [OverlayModule, PortalModule, A11yModule],
+                    exports: [
+                        // Re-export the PortalModule so that people extending the `CdkDialogContainer`
+                        // don't have to remember to import it or be faced with an unhelpful error.
+                        PortalModule,
+                        CdkDialogContainer,
+                    ],
+                    declarations: [CdkDialogContainer],
+                    providers: [
+                        Dialog,
+                        MAT_DIALOG_SCROLL_STRATEGY_PROVIDER,
+                        { provide: DIALOG_REF, useValue: DialogRef },
+                        { provide: DIALOG_CONTAINER, useValue: CdkDialogContainer },
+                        { provide: DIALOG_CONFIG, useValue: DialogConfig },
+                    ],
+                    entryComponents: [CdkDialogContainer],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/dialog/dialog-ref.mjs

@@ -0,0 +1,116 @@
+/**
+ * @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 { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';
+import { map, filter } from 'rxjs/operators';
+/** Unique id for the created dialog. */
+let uniqueId = 0;
+/**
+ * Reference to a dialog opened via the Dialog service.
+ */
+export class DialogRef {
+    constructor(_overlayRef, _containerInstance, id = `dialog-${uniqueId++}`) {
+        this._overlayRef = _overlayRef;
+        this._containerInstance = _containerInstance;
+        this.id = id;
+        // If the dialog has a backdrop, handle clicks from the backdrop.
+        if (_containerInstance._config.hasBackdrop) {
+            _overlayRef.backdropClick().subscribe(() => {
+                if (!this.disableClose) {
+                    this.close();
+                }
+            });
+        }
+        this.beforeClosed().subscribe(() => {
+            this._overlayRef.detachBackdrop();
+        });
+        this.afterClosed().subscribe(() => {
+            this._overlayRef.detach();
+            this._overlayRef.dispose();
+            this.componentInstance = null;
+        });
+        // Close when escape keydown event occurs
+        _overlayRef
+            .keydownEvents()
+            .pipe(filter(event => {
+            return event.keyCode === ESCAPE && !this.disableClose && !hasModifierKey(event);
+        }))
+            .subscribe(event => {
+            event.preventDefault();
+            this.close();
+        });
+    }
+    /** Gets an observable that emits when the overlay's backdrop has been clicked. */
+    backdropClick() {
+        return this._overlayRef.backdropClick();
+    }
+    /**
+     * Close the dialog.
+     * @param dialogResult Optional result to return to the dialog opener.
+     */
+    close(dialogResult) {
+        this._result = dialogResult;
+        this._containerInstance._startExiting();
+    }
+    /**
+     * Updates the dialog's position.
+     * @param position New dialog position.
+     */
+    updatePosition(position) {
+        let strategy = this._getPositionStrategy();
+        if (position && (position.left || position.right)) {
+            position.left ? strategy.left(position.left) : strategy.right(position.right);
+        }
+        else {
+            strategy.centerHorizontally();
+        }
+        if (position && (position.top || position.bottom)) {
+            position.top ? strategy.top(position.top) : strategy.bottom(position.bottom);
+        }
+        else {
+            strategy.centerVertically();
+        }
+        this._overlayRef.updatePosition();
+        return this;
+    }
+    /**
+     * Gets an observable that emits when keydown events are targeted on the overlay.
+     */
+    keydownEvents() {
+        return this._overlayRef.keydownEvents();
+    }
+    /**
+     * Updates the dialog's width and height, defined, min and max.
+     * @param size New size for the overlay.
+     */
+    updateSize(size) {
+        this._overlayRef.updateSize(size);
+        this._overlayRef.updatePosition();
+        return this;
+    }
+    /** Fetches the position strategy object from the overlay ref. */
+    _getPositionStrategy() {
+        return this._overlayRef.getConfig().positionStrategy;
+    }
+    /** Gets an observable that emits when dialog begins opening. */
+    beforeOpened() {
+        return this._containerInstance._beforeEnter;
+    }
+    /** Gets an observable that emits when dialog is finished opening. */
+    afterOpened() {
+        return this._containerInstance._afterEnter;
+    }
+    /** Gets an observable that emits when dialog begins closing. */
+    beforeClosed() {
+        return this._containerInstance._beforeExit.pipe(map(() => this._result));
+    }
+    /** Gets an observable that emits when dialog is finished closing. */
+    afterClosed() {
+        return this._containerInstance._afterExit.pipe(map(() => this._result));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog-ref.js","sourceRoot":"","sources":["../../../../../../src/cdk-experimental/dialog/dialog-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 {OverlayRef, GlobalPositionStrategy, OverlaySizeConfig} from '@angular/cdk/overlay';\nimport {ESCAPE, hasModifierKey} from '@angular/cdk/keycodes';\nimport {Observable} from 'rxjs';\nimport {map, filter} from 'rxjs/operators';\nimport {DialogPosition} from './dialog-config';\nimport {CdkDialogContainer} from './dialog-container';\n\n/** Unique id for the created dialog. */\nlet uniqueId = 0;\n\n/**\n * Reference to a dialog opened via the Dialog service.\n */\nexport class DialogRef<T, R = any> {\n  /** The instance of the component in the dialog. */\n  componentInstance: T;\n\n  /** Whether the user is allowed to close the dialog. */\n  disableClose: boolean | undefined;\n\n  /** Result to be passed to afterClosed. */\n  private _result: R | undefined;\n\n  constructor(\n    public _overlayRef: OverlayRef,\n    protected _containerInstance: CdkDialogContainer,\n    readonly id: string = `dialog-${uniqueId++}`,\n  ) {\n    // If the dialog has a backdrop, handle clicks from the backdrop.\n    if (_containerInstance._config.hasBackdrop) {\n      _overlayRef.backdropClick().subscribe(() => {\n        if (!this.disableClose) {\n          this.close();\n        }\n      });\n    }\n\n    this.beforeClosed().subscribe(() => {\n      this._overlayRef.detachBackdrop();\n    });\n\n    this.afterClosed().subscribe(() => {\n      this._overlayRef.detach();\n      this._overlayRef.dispose();\n      this.componentInstance = null!;\n    });\n\n    // Close when escape keydown event occurs\n    _overlayRef\n      .keydownEvents()\n      .pipe(\n        filter(event => {\n          return event.keyCode === ESCAPE && !this.disableClose && !hasModifierKey(event);\n        }),\n      )\n      .subscribe(event => {\n        event.preventDefault();\n        this.close();\n      });\n  }\n\n  /** Gets an observable that emits when the overlay's backdrop has been clicked. */\n  backdropClick(): Observable<MouseEvent> {\n    return this._overlayRef.backdropClick();\n  }\n\n  /**\n   * Close the dialog.\n   * @param dialogResult Optional result to return to the dialog opener.\n   */\n  close(dialogResult?: R): void {\n    this._result = dialogResult;\n    this._containerInstance._startExiting();\n  }\n\n  /**\n   * Updates the dialog's position.\n   * @param position New dialog position.\n   */\n  updatePosition(position?: DialogPosition): this {\n    let strategy = this._getPositionStrategy();\n\n    if (position && (position.left || position.right)) {\n      position.left ? strategy.left(position.left) : strategy.right(position.right);\n    } else {\n      strategy.centerHorizontally();\n    }\n\n    if (position && (position.top || position.bottom)) {\n      position.top ? strategy.top(position.top) : strategy.bottom(position.bottom);\n    } else {\n      strategy.centerVertically();\n    }\n\n    this._overlayRef.updatePosition();\n\n    return this;\n  }\n\n  /**\n   * Gets an observable that emits when keydown events are targeted on the overlay.\n   */\n  keydownEvents(): Observable<KeyboardEvent> {\n    return this._overlayRef.keydownEvents();\n  }\n\n  /**\n   * Updates the dialog's width and height, defined, min and max.\n   * @param size New size for the overlay.\n   */\n  updateSize(size: OverlaySizeConfig): this {\n    this._overlayRef.updateSize(size);\n    this._overlayRef.updatePosition();\n    return this;\n  }\n\n  /** Fetches the position strategy object from the overlay ref. */\n  private _getPositionStrategy(): GlobalPositionStrategy {\n    return this._overlayRef.getConfig().positionStrategy as GlobalPositionStrategy;\n  }\n\n  /** Gets an observable that emits when dialog begins opening. */\n  beforeOpened(): Observable<void> {\n    return this._containerInstance._beforeEnter;\n  }\n\n  /** Gets an observable that emits when dialog is finished opening. */\n  afterOpened(): Observable<void> {\n    return this._containerInstance._afterEnter;\n  }\n\n  /** Gets an observable that emits when dialog begins closing. */\n  beforeClosed(): Observable<R | undefined> {\n    return this._containerInstance._beforeExit.pipe(map(() => this._result));\n  }\n\n  /** Gets an observable that emits when dialog is finished closing. */\n  afterClosed(): Observable<R | undefined> {\n    return this._containerInstance._afterExit.pipe(map(() => this._result));\n  }\n}\n"]}