@angular/material
Version:
Angular Material
477 lines • 47.7 kB
JavaScript
/**
* @fileoverview added by tsickle
* Generated from: src/material/dialog/dialog.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 { Overlay, OverlayConfig, OverlayContainer, } from '@angular/cdk/overlay';
import { ComponentPortal, PortalInjector, TemplatePortal } from '@angular/cdk/portal';
import { Location } from '@angular/common';
import { Inject, Injectable, InjectionToken, Injector, Optional, SkipSelf, TemplateRef, } from '@angular/core';
import { defer, of as observableOf, Subject } from 'rxjs';
import { startWith } from 'rxjs/operators';
import { MatDialogConfig } from './dialog-config';
import { MatDialogContainer } from './dialog-container';
import { MatDialogRef } from './dialog-ref';
/**
* Injection token that can be used to access the data that was passed in to a dialog.
* @type {?}
*/
export const MAT_DIALOG_DATA = new InjectionToken('MatDialogData');
/**
* Injection token that can be used to specify default dialog options.
* @type {?}
*/
export const MAT_DIALOG_DEFAULT_OPTIONS = new InjectionToken('mat-dialog-default-options');
/**
* Injection token that determines the scroll handling while the dialog is open.
* @type {?}
*/
export const MAT_DIALOG_SCROLL_STRATEGY = new InjectionToken('mat-dialog-scroll-strategy');
/**
* \@docs-private
* @param {?} overlay
* @return {?}
*/
export function MAT_DIALOG_SCROLL_STRATEGY_FACTORY(overlay) {
return (/**
* @return {?}
*/
() => overlay.scrollStrategies.block());
}
/**
* \@docs-private
* @param {?} overlay
* @return {?}
*/
export function MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {
return (/**
* @return {?}
*/
() => overlay.scrollStrategies.block());
}
/**
* \@docs-private
* @type {?}
*/
export const MAT_DIALOG_SCROLL_STRATEGY_PROVIDER = {
provide: MAT_DIALOG_SCROLL_STRATEGY,
deps: [Overlay],
useFactory: MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY,
};
/**
* Service to open Material Design modal dialogs.
*/
export class MatDialog {
/**
* @param {?} _overlay
* @param {?} _injector
* @param {?} _location
* @param {?} _defaultOptions
* @param {?} scrollStrategy
* @param {?} _parentDialog
* @param {?} _overlayContainer
*/
constructor(_overlay, _injector,
/**
* @deprecated `_location` parameter to be removed.
* @breaking-change 10.0.0
*/
_location, _defaultOptions, scrollStrategy, _parentDialog, _overlayContainer) {
this._overlay = _overlay;
this._injector = _injector;
this._defaultOptions = _defaultOptions;
this._parentDialog = _parentDialog;
this._overlayContainer = _overlayContainer;
this._openDialogsAtThisLevel = [];
this._afterAllClosedAtThisLevel = new Subject();
this._afterOpenedAtThisLevel = new Subject();
this._ariaHiddenElements = new Map();
// TODO (jelbourn): tighten the typing right-hand side of this expression.
/**
* Stream that emits when all open dialog have finished closing.
* Will emit on subscribe if there are no open dialogs to begin with.
*/
this.afterAllClosed = (/** @type {?} */ (defer((/**
* @return {?}
*/
() => this.openDialogs.length ?
this._afterAllClosed :
this._afterAllClosed.pipe(startWith(undefined))))));
this._scrollStrategy = scrollStrategy;
}
/**
* Keeps track of the currently-open dialogs.
* @return {?}
*/
get openDialogs() {
return this._parentDialog ? this._parentDialog.openDialogs : this._openDialogsAtThisLevel;
}
/**
* Stream that emits when a dialog has been opened.
* @return {?}
*/
get afterOpened() {
return this._parentDialog ? this._parentDialog.afterOpened : this._afterOpenedAtThisLevel;
}
/**
* @return {?}
*/
get _afterAllClosed() {
/** @type {?} */
const parent = this._parentDialog;
return parent ? parent._afterAllClosed : this._afterAllClosedAtThisLevel;
}
/**
* Opens a modal dialog containing the given component.
* @template T, D, R
* @param {?} componentOrTemplateRef Type of the component to load into the dialog,
* or a TemplateRef to instantiate as the dialog content.
* @param {?=} config Extra configuration options.
* @return {?} Reference to the newly-opened dialog.
*/
open(componentOrTemplateRef, config) {
config = _applyConfigDefaults(config, this._defaultOptions || new MatDialogConfig());
if (config.id && this.getDialogById(config.id)) {
throw Error(`Dialog with id "${config.id}" exists already. The dialog id must be unique.`);
}
/** @type {?} */
const overlayRef = this._createOverlay(config);
/** @type {?} */
const dialogContainer = this._attachDialogContainer(overlayRef, config);
/** @type {?} */
const dialogRef = this._attachDialogContent(componentOrTemplateRef, dialogContainer, overlayRef, config);
// If this is the first dialog that we're opening, hide all the non-overlay content.
if (!this.openDialogs.length) {
this._hideNonDialogContentFromAssistiveTechnology();
}
this.openDialogs.push(dialogRef);
dialogRef.afterClosed().subscribe((/**
* @return {?}
*/
() => this._removeOpenDialog(dialogRef)));
this.afterOpened.next(dialogRef);
return dialogRef;
}
/**
* Closes all of the currently-open dialogs.
* @return {?}
*/
closeAll() {
this._closeDialogs(this.openDialogs);
}
/**
* Finds an open dialog by its id.
* @param {?} id ID to use when looking up the dialog.
* @return {?}
*/
getDialogById(id) {
return this.openDialogs.find((/**
* @param {?} dialog
* @return {?}
*/
dialog => dialog.id === id));
}
/**
* @return {?}
*/
ngOnDestroy() {
// Only close the dialogs at this level on destroy
// since the parent service may still be active.
this._closeDialogs(this._openDialogsAtThisLevel);
this._afterAllClosedAtThisLevel.complete();
this._afterOpenedAtThisLevel.complete();
}
/**
* Creates the overlay into which the dialog will be loaded.
* @private
* @param {?} config The dialog configuration.
* @return {?} A promise resolving to the OverlayRef for the created overlay.
*/
_createOverlay(config) {
/** @type {?} */
const overlayConfig = this._getOverlayConfig(config);
return this._overlay.create(overlayConfig);
}
/**
* Creates an overlay config from a dialog config.
* @private
* @param {?} dialogConfig The dialog configuration.
* @return {?} The overlay configuration.
*/
_getOverlayConfig(dialogConfig) {
/** @type {?} */
const state = new OverlayConfig({
positionStrategy: this._overlay.position().global(),
scrollStrategy: dialogConfig.scrollStrategy || this._scrollStrategy(),
panelClass: dialogConfig.panelClass,
hasBackdrop: dialogConfig.hasBackdrop,
direction: dialogConfig.direction,
minWidth: dialogConfig.minWidth,
minHeight: dialogConfig.minHeight,
maxWidth: dialogConfig.maxWidth,
maxHeight: dialogConfig.maxHeight,
disposeOnNavigation: dialogConfig.closeOnNavigation
});
if (dialogConfig.backdropClass) {
state.backdropClass = dialogConfig.backdropClass;
}
return state;
}
/**
* Attaches an MatDialogContainer to a dialog's already-created overlay.
* @private
* @param {?} overlay Reference to the dialog's underlying overlay.
* @param {?} config The dialog configuration.
* @return {?} A promise resolving to a ComponentRef for the attached container.
*/
_attachDialogContainer(overlay, config) {
/** @type {?} */
const userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;
/** @type {?} */
const injector = new PortalInjector(userInjector || this._injector, new WeakMap([
[MatDialogConfig, config]
]));
/** @type {?} */
const containerPortal = new ComponentPortal(MatDialogContainer, config.viewContainerRef, injector, config.componentFactoryResolver);
/** @type {?} */
const containerRef = overlay.attach(containerPortal);
return containerRef.instance;
}
/**
* Attaches the user-provided component to the already-created MatDialogContainer.
* @private
* @template T, R
* @param {?} componentOrTemplateRef The type of component being loaded into the dialog,
* or a TemplateRef to instantiate as the content.
* @param {?} dialogContainer Reference to the wrapping MatDialogContainer.
* @param {?} overlayRef Reference to the overlay in which the dialog resides.
* @param {?} config The dialog configuration.
* @return {?} A promise resolving to the MatDialogRef that should be returned to the user.
*/
_attachDialogContent(componentOrTemplateRef, dialogContainer, overlayRef, config) {
// Create a reference to the dialog we're creating in order to give the user a handle
// to modify and close it.
/** @type {?} */
const dialogRef = new MatDialogRef(overlayRef, dialogContainer, config.id);
// When the dialog backdrop is clicked, we want to close it.
if (config.hasBackdrop) {
overlayRef.backdropClick().subscribe((/**
* @return {?}
*/
() => {
if (!dialogRef.disableClose) {
dialogRef.close();
}
}));
}
if (componentOrTemplateRef instanceof TemplateRef) {
dialogContainer.attachTemplatePortal(new TemplatePortal(componentOrTemplateRef, (/** @type {?} */ (null)), (/** @type {?} */ ({ $implicit: config.data, dialogRef }))));
}
else {
/** @type {?} */
const injector = this._createInjector(config, dialogRef, dialogContainer);
/** @type {?} */
const contentRef = dialogContainer.attachComponentPortal(new ComponentPortal(componentOrTemplateRef, config.viewContainerRef, injector));
dialogRef.componentInstance = contentRef.instance;
}
dialogRef
.updateSize(config.width, config.height)
.updatePosition(config.position);
return dialogRef;
}
/**
* Creates a custom injector to be used inside the dialog. This allows a component loaded inside
* of a dialog to close itself and, optionally, to return a value.
* @private
* @template T
* @param {?} config Config object that is used to construct the dialog.
* @param {?} dialogRef Reference to the dialog.
* @param {?} dialogContainer
* @return {?} The custom injector that can be used inside the dialog.
*/
_createInjector(config, dialogRef, dialogContainer) {
/** @type {?} */
const userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;
// The MatDialogContainer is injected in the portal as the MatDialogContainer and the dialog's
// content are created out of the same ViewContainerRef and as such, are siblings for injector
// purposes. To allow the hierarchy that is expected, the MatDialogContainer is explicitly
// added to the injection tokens.
/** @type {?} */
const injectionTokens = new WeakMap([
[MatDialogContainer, dialogContainer],
[MAT_DIALOG_DATA, config.data],
[MatDialogRef, dialogRef]
]);
if (config.direction &&
(!userInjector || !userInjector.get(Directionality, null))) {
injectionTokens.set(Directionality, {
value: config.direction,
change: observableOf()
});
}
return new PortalInjector(userInjector || this._injector, injectionTokens);
}
/**
* Removes a dialog from the array of open dialogs.
* @private
* @param {?} dialogRef Dialog to be removed.
* @return {?}
*/
_removeOpenDialog(dialogRef) {
/** @type {?} */
const index = this.openDialogs.indexOf(dialogRef);
if (index > -1) {
this.openDialogs.splice(index, 1);
// If all the dialogs were closed, remove/restore the `aria-hidden`
// to a the siblings and emit to the `afterAllClosed` stream.
if (!this.openDialogs.length) {
this._ariaHiddenElements.forEach((/**
* @param {?} previousValue
* @param {?} element
* @return {?}
*/
(previousValue, element) => {
if (previousValue) {
element.setAttribute('aria-hidden', previousValue);
}
else {
element.removeAttribute('aria-hidden');
}
}));
this._ariaHiddenElements.clear();
this._afterAllClosed.next();
}
}
}
/**
* Hides all of the content that isn't an overlay from assistive technology.
* @private
* @return {?}
*/
_hideNonDialogContentFromAssistiveTechnology() {
/** @type {?} */
const overlayContainer = this._overlayContainer.getContainerElement();
// Ensure that the overlay container is attached to the DOM.
if (overlayContainer.parentElement) {
/** @type {?} */
const siblings = overlayContainer.parentElement.children;
for (let i = siblings.length - 1; i > -1; i--) {
/** @type {?} */
let sibling = siblings[i];
if (sibling !== overlayContainer &&
sibling.nodeName !== 'SCRIPT' &&
sibling.nodeName !== 'STYLE' &&
!sibling.hasAttribute('aria-live')) {
this._ariaHiddenElements.set(sibling, sibling.getAttribute('aria-hidden'));
sibling.setAttribute('aria-hidden', 'true');
}
}
}
}
/**
* Closes all of the dialogs in an array.
* @private
* @param {?} dialogs
* @return {?}
*/
_closeDialogs(dialogs) {
/** @type {?} */
let i = dialogs.length;
while (i--) {
// The `_openDialogs` property isn't updated after close until the rxjs subscription
// runs on the next microtask, in addition to modifying the array as we're going
// through it. We loop through all of them and call close without assuming that
// they'll be removed from the list instantaneously.
dialogs[i].close();
}
}
}
MatDialog.decorators = [
{ type: Injectable }
];
/** @nocollapse */
MatDialog.ctorParameters = () => [
{ type: Overlay },
{ type: Injector },
{ type: Location, decorators: [{ type: Optional }] },
{ type: MatDialogConfig, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DIALOG_DEFAULT_OPTIONS,] }] },
{ type: undefined, decorators: [{ type: Inject, args: [MAT_DIALOG_SCROLL_STRATEGY,] }] },
{ type: MatDialog, decorators: [{ type: Optional }, { type: SkipSelf }] },
{ type: OverlayContainer }
];
if (false) {
/**
* @type {?}
* @private
*/
MatDialog.prototype._openDialogsAtThisLevel;
/**
* @type {?}
* @private
*/
MatDialog.prototype._afterAllClosedAtThisLevel;
/**
* @type {?}
* @private
*/
MatDialog.prototype._afterOpenedAtThisLevel;
/**
* @type {?}
* @private
*/
MatDialog.prototype._ariaHiddenElements;
/**
* @type {?}
* @private
*/
MatDialog.prototype._scrollStrategy;
/**
* Stream that emits when all open dialog have finished closing.
* Will emit on subscribe if there are no open dialogs to begin with.
* @type {?}
*/
MatDialog.prototype.afterAllClosed;
/**
* @type {?}
* @private
*/
MatDialog.prototype._overlay;
/**
* @type {?}
* @private
*/
MatDialog.prototype._injector;
/**
* @type {?}
* @private
*/
MatDialog.prototype._defaultOptions;
/**
* @type {?}
* @private
*/
MatDialog.prototype._parentDialog;
/**
* @type {?}
* @private
*/
MatDialog.prototype._overlayContainer;
}
/**
* Applies default options to the dialog config.
* @param {?=} config Config to be modified.
* @param {?=} defaultOptions Default options provided.
* @return {?} The new configuration object.
*/
function _applyConfigDefaults(config, defaultOptions) {
return Object.assign(Object.assign({}, defaultOptions), config);
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog.js","sourceRoot":"","sources":["../../../../../../src/material/dialog/dialog.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 {\n  Overlay,\n  OverlayConfig,\n  OverlayContainer,\n  OverlayRef,\n  ScrollStrategy,\n} from '@angular/cdk/overlay';\nimport {ComponentPortal, ComponentType, PortalInjector, TemplatePortal} from '@angular/cdk/portal';\nimport {Location} from '@angular/common';\nimport {\n  Inject,\n  Injectable,\n  InjectionToken,\n  Injector,\n  OnDestroy,\n  Optional,\n  SkipSelf,\n  TemplateRef,\n} from '@angular/core';\nimport {defer, Observable, of as observableOf, Subject} from 'rxjs';\nimport {startWith} from 'rxjs/operators';\nimport {MatDialogConfig} from './dialog-config';\nimport {MatDialogContainer} from './dialog-container';\nimport {MatDialogRef} from './dialog-ref';\n\n\n/** Injection token that can be used to access the data that was passed in to a dialog. */\nexport const MAT_DIALOG_DATA = new InjectionToken<any>('MatDialogData');\n\n/** Injection token that can be used to specify default dialog options. */\nexport const MAT_DIALOG_DEFAULT_OPTIONS =\n    new InjectionToken<MatDialogConfig>('mat-dialog-default-options');\n\n/** Injection token that determines the scroll handling while the dialog is open. */\nexport const MAT_DIALOG_SCROLL_STRATEGY =\n    new InjectionToken<() => ScrollStrategy>('mat-dialog-scroll-strategy');\n\n/** @docs-private */\nexport function MAT_DIALOG_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy {\n  return () => overlay.scrollStrategies.block();\n}\n\n/** @docs-private */\nexport function MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay: Overlay):\n  () => ScrollStrategy {\n  return () => overlay.scrollStrategies.block();\n}\n\n/** @docs-private */\nexport const MAT_DIALOG_SCROLL_STRATEGY_PROVIDER = {\n  provide: MAT_DIALOG_SCROLL_STRATEGY,\n  deps: [Overlay],\n  useFactory: MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY,\n};\n\n\n/**\n * Service to open Material Design modal dialogs.\n */\n@Injectable()\nexport class MatDialog implements OnDestroy {\n  private _openDialogsAtThisLevel: MatDialogRef<any>[] = [];\n  private readonly _afterAllClosedAtThisLevel = new Subject<void>();\n  private readonly _afterOpenedAtThisLevel = new Subject<MatDialogRef<any>>();\n  private _ariaHiddenElements = new Map<Element, string|null>();\n  private _scrollStrategy: () => ScrollStrategy;\n\n  /** Keeps track of the currently-open dialogs. */\n  get openDialogs(): MatDialogRef<any>[] {\n    return this._parentDialog ? this._parentDialog.openDialogs : this._openDialogsAtThisLevel;\n  }\n\n  /** Stream that emits when a dialog has been opened. */\n  get afterOpened(): Subject<MatDialogRef<any>> {\n    return this._parentDialog ? this._parentDialog.afterOpened : this._afterOpenedAtThisLevel;\n  }\n\n  get _afterAllClosed(): Subject<void> {\n    const parent = this._parentDialog;\n    return parent ? parent._afterAllClosed : this._afterAllClosedAtThisLevel;\n  }\n\n  // TODO (jelbourn): tighten the typing right-hand side of this expression.\n  /**\n   * Stream that emits when all open dialog have finished closing.\n   * Will emit on subscribe if there are no open dialogs to begin with.\n   */\n  readonly afterAllClosed: Observable<void> = defer(() => this.openDialogs.length ?\n      this._afterAllClosed :\n      this._afterAllClosed.pipe(startWith(undefined))) as Observable<any>;\n\n  constructor(\n      private _overlay: Overlay,\n      private _injector: Injector,\n      /**\n       * @deprecated `_location` parameter to be removed.\n       * @breaking-change 10.0.0\n       */\n      @Optional() _location: Location,\n      @Optional() @Inject(MAT_DIALOG_DEFAULT_OPTIONS) private _defaultOptions: MatDialogConfig,\n      @Inject(MAT_DIALOG_SCROLL_STRATEGY) scrollStrategy: any,\n      @Optional() @SkipSelf() private _parentDialog: MatDialog,\n      private _overlayContainer: OverlayContainer) {\n    this._scrollStrategy = scrollStrategy;\n  }\n\n  /**\n   * Opens a modal dialog containing the given component.\n   * @param componentOrTemplateRef Type of the component to load into the dialog,\n   *     or a TemplateRef to instantiate as the dialog content.\n   * @param config Extra configuration options.\n   * @returns Reference to the newly-opened dialog.\n   */\n  open<T, D = any, R = any>(componentOrTemplateRef: ComponentType<T> | TemplateRef<T>,\n          config?: MatDialogConfig<D>): MatDialogRef<T, R> {\n\n    config = _applyConfigDefaults(config, this._defaultOptions || new MatDialogConfig());\n\n    if (config.id && this.getDialogById(config.id)) {\n      throw Error(`Dialog with id \"${config.id}\" exists already. The dialog id must be unique.`);\n    }\n\n    const overlayRef = this._createOverlay(config);\n    const dialogContainer = this._attachDialogContainer(overlayRef, config);\n    const dialogRef = this._attachDialogContent<T, R>(componentOrTemplateRef,\n                                                      dialogContainer,\n                                                      overlayRef,\n                                                      config);\n\n    // If this is the first dialog that we're opening, hide all the non-overlay content.\n    if (!this.openDialogs.length) {\n      this._hideNonDialogContentFromAssistiveTechnology();\n    }\n\n    this.openDialogs.push(dialogRef);\n    dialogRef.afterClosed().subscribe(() => this._removeOpenDialog(dialogRef));\n    this.afterOpened.next(dialogRef);\n\n    return dialogRef;\n  }\n\n  /**\n   * Closes all of the currently-open dialogs.\n   */\n  closeAll(): void {\n    this._closeDialogs(this.openDialogs);\n  }\n\n  /**\n   * Finds an open dialog by its id.\n   * @param id ID to use when looking up the dialog.\n   */\n  getDialogById(id: string): MatDialogRef<any> | undefined {\n    return this.openDialogs.find(dialog => dialog.id === id);\n  }\n\n  ngOnDestroy() {\n    // Only close the dialogs at this level on destroy\n    // since the parent service may still be active.\n    this._closeDialogs(this._openDialogsAtThisLevel);\n    this._afterAllClosedAtThisLevel.complete();\n    this._afterOpenedAtThisLevel.complete();\n  }\n\n  /**\n   * Creates the overlay into which the dialog will be loaded.\n   * @param config The dialog configuration.\n   * @returns A promise resolving to the OverlayRef for the created overlay.\n   */\n  private _createOverlay(config: MatDialogConfig): OverlayRef {\n    const overlayConfig = this._getOverlayConfig(config);\n    return this._overlay.create(overlayConfig);\n  }\n\n  /**\n   * Creates an overlay config from a dialog config.\n   * @param dialogConfig The dialog configuration.\n   * @returns The overlay configuration.\n   */\n  private _getOverlayConfig(dialogConfig: MatDialogConfig): OverlayConfig {\n    const state = new OverlayConfig({\n      positionStrategy: this._overlay.position().global(),\n      scrollStrategy: dialogConfig.scrollStrategy || this._scrollStrategy(),\n      panelClass: dialogConfig.panelClass,\n      hasBackdrop: dialogConfig.hasBackdrop,\n      direction: dialogConfig.direction,\n      minWidth: dialogConfig.minWidth,\n      minHeight: dialogConfig.minHeight,\n      maxWidth: dialogConfig.maxWidth,\n      maxHeight: dialogConfig.maxHeight,\n      disposeOnNavigation: dialogConfig.closeOnNavigation\n    });\n\n    if (dialogConfig.backdropClass) {\n      state.backdropClass = dialogConfig.backdropClass;\n    }\n\n    return state;\n  }\n\n  /**\n   * Attaches an MatDialogContainer to a dialog's already-created overlay.\n   * @param overlay Reference to the dialog's underlying overlay.\n   * @param config The dialog configuration.\n   * @returns A promise resolving to a ComponentRef for the attached container.\n   */\n  private _attachDialogContainer(overlay: OverlayRef, config: MatDialogConfig): MatDialogContainer {\n    const userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;\n    const injector = new PortalInjector(userInjector || this._injector, new WeakMap([\n      [MatDialogConfig, config]\n    ]));\n    const containerPortal = new ComponentPortal(MatDialogContainer,\n        config.viewContainerRef, injector, config.componentFactoryResolver);\n    const containerRef = overlay.attach<MatDialogContainer>(containerPortal);\n\n    return containerRef.instance;\n  }\n\n  /**\n   * Attaches the user-provided component to the already-created MatDialogContainer.\n   * @param componentOrTemplateRef The type of component being loaded into the dialog,\n   *     or a TemplateRef to instantiate as the content.\n   * @param dialogContainer Reference to the wrapping MatDialogContainer.\n   * @param overlayRef Reference to the overlay in which the dialog resides.\n   * @param config The dialog configuration.\n   * @returns A promise resolving to the MatDialogRef that should be returned to the user.\n   */\n  private _attachDialogContent<T, R>(\n      componentOrTemplateRef: ComponentType<T> | TemplateRef<T>,\n      dialogContainer: MatDialogContainer,\n      overlayRef: OverlayRef,\n      config: MatDialogConfig): MatDialogRef<T, R> {\n\n    // Create a reference to the dialog we're creating in order to give the user a handle\n    // to modify and close it.\n    const dialogRef =\n        new MatDialogRef<T, R>(overlayRef, dialogContainer, config.id);\n\n    // When the dialog backdrop is clicked, we want to close it.\n    if (config.hasBackdrop) {\n      overlayRef.backdropClick().subscribe(() => {\n        if (!dialogRef.disableClose) {\n          dialogRef.close();\n        }\n      });\n    }\n\n    if (componentOrTemplateRef instanceof TemplateRef) {\n      dialogContainer.attachTemplatePortal(\n        new TemplatePortal<T>(componentOrTemplateRef, null!,\n          <any>{$implicit: config.data, dialogRef}));\n    } else {\n      const injector = this._createInjector<T>(config, dialogRef, dialogContainer);\n      const contentRef = dialogContainer.attachComponentPortal<T>(\n          new ComponentPortal(componentOrTemplateRef, config.viewContainerRef, injector));\n      dialogRef.componentInstance = contentRef.instance;\n    }\n\n    dialogRef\n      .updateSize(config.width, config.height)\n      .updatePosition(config.position);\n\n    return dialogRef;\n  }\n\n  /**\n   * Creates a custom injector to be used inside the dialog. This allows a component loaded inside\n   * of a dialog to close itself and, optionally, to return a value.\n   * @param config Config object that is used to construct the dialog.\n   * @param dialogRef Reference to the dialog.\n   * @param container Dialog container element that wraps all of the contents.\n   * @returns The custom injector that can be used inside the dialog.\n   */\n  private _createInjector<T>(\n      config: MatDialogConfig,\n      dialogRef: MatDialogRef<T>,\n      dialogContainer: MatDialogContainer): PortalInjector {\n\n    const userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;\n\n    // The MatDialogContainer is injected in the portal as the MatDialogContainer and the dialog's\n    // content are created out of the same ViewContainerRef and as such, are siblings for injector\n    // purposes. To allow the hierarchy that is expected, the MatDialogContainer is explicitly\n    // added to the injection tokens.\n    const injectionTokens = new WeakMap<any, any>([\n      [MatDialogContainer, dialogContainer],\n      [MAT_DIALOG_DATA, config.data],\n      [MatDialogRef, dialogRef]\n    ]);\n\n    if (config.direction &&\n        (!userInjector || !userInjector.get<Directionality | null>(Directionality, null))) {\n      injectionTokens.set(Directionality, {\n        value: config.direction,\n        change: observableOf()\n      });\n    }\n\n    return new PortalInjector(userInjector || this._injector, injectionTokens);\n  }\n\n  /**\n   * Removes a dialog from the array of open dialogs.\n   * @param dialogRef Dialog to be removed.\n   */\n  private _removeOpenDialog(dialogRef: MatDialogRef<any>) {\n    const index = this.openDialogs.indexOf(dialogRef);\n\n    if (index > -1) {\n      this.openDialogs.splice(index, 1);\n\n      // If all the dialogs were closed, remove/restore the `aria-hidden`\n      // to a the siblings and emit to the `afterAllClosed` stream.\n      if (!this.openDialogs.length) {\n        this._ariaHiddenElements.forEach((previousValue, element) => {\n          if (previousValue) {\n            element.setAttribute('aria-hidden', previousValue);\n          } else {\n            element.removeAttribute('aria-hidden');\n          }\n        });\n\n        this._ariaHiddenElements.clear();\n        this._afterAllClosed.next();\n      }\n    }\n  }\n\n  /**\n   * Hides all of the content that isn't an overlay from assistive technology.\n   */\n  private _hideNonDialogContentFromAssistiveTechnology() {\n    const overlayContainer = this._overlayContainer.getContainerElement();\n\n    // Ensure that the overlay container is attached to the DOM.\n    if (overlayContainer.parentElement) {\n      const siblings = overlayContainer.parentElement.children;\n\n      for (let i = siblings.length - 1; i > -1; i--) {\n        let sibling = siblings[i];\n\n        if (sibling !== overlayContainer &&\n          sibling.nodeName !== 'SCRIPT' &&\n          sibling.nodeName !== 'STYLE' &&\n          !sibling.hasAttribute('aria-live')) {\n\n          this._ariaHiddenElements.set(sibling, sibling.getAttribute('aria-hidden'));\n          sibling.setAttribute('aria-hidden', 'true');\n        }\n      }\n    }\n  }\n\n  /** Closes all of the dialogs in an array. */\n  private _closeDialogs(dialogs: MatDialogRef<any>[]) {\n    let i = dialogs.length;\n\n    while (i--) {\n      // The `_openDialogs` property isn't updated after close until the rxjs subscription\n      // runs on the next microtask, in addition to modifying the array as we're going\n      // through it. We loop through all of them and call close without assuming that\n      // they'll be removed from the list instantaneously.\n      dialogs[i].close();\n    }\n  }\n\n}\n\n/**\n * Applies default options to the dialog config.\n * @param config Config to be modified.\n * @param defaultOptions Default options provided.\n * @returns The new configuration object.\n */\nfunction _applyConfigDefaults(\n    config?: MatDialogConfig, defaultOptions?: MatDialogConfig): MatDialogConfig {\n  return {...defaultOptions, ...config};\n}\n"]}