You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
347 lines
51 KiB
347 lines
51 KiB
/**
|
|
* @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, TemplatePortal } from '@angular/cdk/portal';
|
|
import { Location } from '@angular/common';
|
|
import { Directive, Inject, Injectable, InjectFlags, InjectionToken, Injector, Optional, SkipSelf, TemplateRef, Type, } 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. */
|
|
import * as ɵngcc0 from '@angular/core';
|
|
import * as ɵngcc1 from '@angular/cdk/overlay';
|
|
import * as ɵngcc2 from '@angular/common';
|
|
import * as ɵngcc3 from './dialog-config';
|
|
export const MAT_DIALOG_DATA = new InjectionToken('MatDialogData');
|
|
/** Injection token that can be used to specify default dialog options. */
|
|
export const MAT_DIALOG_DEFAULT_OPTIONS = new InjectionToken('mat-dialog-default-options');
|
|
/** Injection token that determines the scroll handling while the dialog is open. */
|
|
export const MAT_DIALOG_SCROLL_STRATEGY = new InjectionToken('mat-dialog-scroll-strategy');
|
|
/** @docs-private */
|
|
export function MAT_DIALOG_SCROLL_STRATEGY_FACTORY(overlay) {
|
|
return () => overlay.scrollStrategies.block();
|
|
}
|
|
/** @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: MAT_DIALOG_SCROLL_STRATEGY,
|
|
deps: [Overlay],
|
|
useFactory: MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY,
|
|
};
|
|
/**
|
|
* Base class for dialog services. The base dialog service allows
|
|
* for arbitrary dialog refs and dialog container components.
|
|
*/
|
|
export class _MatDialogBase {
|
|
constructor(_overlay, _injector, _defaultOptions, _parentDialog, _overlayContainer, scrollStrategy, _dialogRefConstructor, _dialogContainerType, _dialogDataToken) {
|
|
this._overlay = _overlay;
|
|
this._injector = _injector;
|
|
this._defaultOptions = _defaultOptions;
|
|
this._parentDialog = _parentDialog;
|
|
this._overlayContainer = _overlayContainer;
|
|
this._dialogRefConstructor = _dialogRefConstructor;
|
|
this._dialogContainerType = _dialogContainerType;
|
|
this._dialogDataToken = _dialogDataToken;
|
|
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 = defer(() => this.openDialogs.length ?
|
|
this._getAfterAllClosed() :
|
|
this._getAfterAllClosed().pipe(startWith(undefined)));
|
|
this._scrollStrategy = scrollStrategy;
|
|
}
|
|
/** Keeps track of the currently-open dialogs. */
|
|
get openDialogs() {
|
|
return this._parentDialog ? this._parentDialog.openDialogs : this._openDialogsAtThisLevel;
|
|
}
|
|
/** Stream that emits when a dialog has been opened. */
|
|
get afterOpened() {
|
|
return this._parentDialog ? this._parentDialog.afterOpened : this._afterOpenedAtThisLevel;
|
|
}
|
|
_getAfterAllClosed() {
|
|
const parent = this._parentDialog;
|
|
return parent ? parent._getAfterAllClosed() : this._afterAllClosedAtThisLevel;
|
|
}
|
|
open(componentOrTemplateRef, config) {
|
|
config = _applyConfigDefaults(config, this._defaultOptions || new MatDialogConfig());
|
|
if (config.id && this.getDialogById(config.id) &&
|
|
(typeof ngDevMode === 'undefined' || ngDevMode)) {
|
|
throw Error(`Dialog with id "${config.id}" exists already. The dialog id must be unique.`);
|
|
}
|
|
const overlayRef = this._createOverlay(config);
|
|
const dialogContainer = this._attachDialogContainer(overlayRef, config);
|
|
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(() => this._removeOpenDialog(dialogRef));
|
|
this.afterOpened.next(dialogRef);
|
|
// Notify the dialog container that the content has been attached.
|
|
dialogContainer._initializeWithAttachedContent();
|
|
return dialogRef;
|
|
}
|
|
/**
|
|
* Closes all of the currently-open dialogs.
|
|
*/
|
|
closeAll() {
|
|
this._closeDialogs(this.openDialogs);
|
|
}
|
|
/**
|
|
* Finds an open dialog by its id.
|
|
* @param id ID to use when looking up the dialog.
|
|
*/
|
|
getDialogById(id) {
|
|
return this.openDialogs.find(dialog => dialog.id === id);
|
|
}
|
|
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.
|
|
* @param config The dialog configuration.
|
|
* @returns A promise resolving to the OverlayRef for the created overlay.
|
|
*/
|
|
_createOverlay(config) {
|
|
const overlayConfig = this._getOverlayConfig(config);
|
|
return this._overlay.create(overlayConfig);
|
|
}
|
|
/**
|
|
* Creates an overlay config from a dialog config.
|
|
* @param dialogConfig The dialog configuration.
|
|
* @returns The overlay configuration.
|
|
*/
|
|
_getOverlayConfig(dialogConfig) {
|
|
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 a dialog container to a dialog's already-created overlay.
|
|
* @param overlay Reference to the dialog's underlying overlay.
|
|
* @param config The dialog configuration.
|
|
* @returns A promise resolving to a ComponentRef for the attached container.
|
|
*/
|
|
_attachDialogContainer(overlay, config) {
|
|
const userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;
|
|
const injector = Injector.create({
|
|
parent: userInjector || this._injector,
|
|
providers: [{ provide: MatDialogConfig, useValue: config }]
|
|
});
|
|
const containerPortal = new ComponentPortal(this._dialogContainerType, config.viewContainerRef, injector, config.componentFactoryResolver);
|
|
const containerRef = overlay.attach(containerPortal);
|
|
return containerRef.instance;
|
|
}
|
|
/**
|
|
* Attaches the user-provided component to the already-created dialog container.
|
|
* @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 dialog container.
|
|
* @param overlayRef Reference to the overlay in which the dialog resides.
|
|
* @param config The dialog configuration.
|
|
* @returns 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.
|
|
const dialogRef = new this._dialogRefConstructor(overlayRef, dialogContainer, config.id);
|
|
if (componentOrTemplateRef instanceof TemplateRef) {
|
|
dialogContainer.attachTemplatePortal(new TemplatePortal(componentOrTemplateRef, null, { $implicit: config.data, dialogRef }));
|
|
}
|
|
else {
|
|
const injector = this._createInjector(config, dialogRef, dialogContainer);
|
|
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.
|
|
* @param config Config object that is used to construct the dialog.
|
|
* @param dialogRef Reference to the dialog.
|
|
* @param dialogContainer Dialog container element that wraps all of the contents.
|
|
* @returns The custom injector that can be used inside the dialog.
|
|
*/
|
|
_createInjector(config, dialogRef, dialogContainer) {
|
|
const userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;
|
|
// The dialog container should be provided as the dialog container 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 dialog
|
|
// container is explicitly provided in the injector.
|
|
const providers = [
|
|
{ provide: this._dialogContainerType, useValue: dialogContainer },
|
|
{ provide: this._dialogDataToken, useValue: config.data },
|
|
{ provide: this._dialogRefConstructor, useValue: dialogRef }
|
|
];
|
|
if (config.direction && (!userInjector ||
|
|
!userInjector.get(Directionality, null, InjectFlags.Optional))) {
|
|
providers.push({
|
|
provide: Directionality,
|
|
useValue: { value: config.direction, change: observableOf() }
|
|
});
|
|
}
|
|
return Injector.create({ parent: userInjector || this._injector, providers });
|
|
}
|
|
/**
|
|
* Removes a dialog from the array of open dialogs.
|
|
* @param dialogRef Dialog to be removed.
|
|
*/
|
|
_removeOpenDialog(dialogRef) {
|
|
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((previousValue, element) => {
|
|
if (previousValue) {
|
|
element.setAttribute('aria-hidden', previousValue);
|
|
}
|
|
else {
|
|
element.removeAttribute('aria-hidden');
|
|
}
|
|
});
|
|
this._ariaHiddenElements.clear();
|
|
this._getAfterAllClosed().next();
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Hides all of the content that isn't an overlay from assistive technology.
|
|
*/
|
|
_hideNonDialogContentFromAssistiveTechnology() {
|
|
const overlayContainer = this._overlayContainer.getContainerElement();
|
|
// Ensure that the overlay container is attached to the DOM.
|
|
if (overlayContainer.parentElement) {
|
|
const siblings = overlayContainer.parentElement.children;
|
|
for (let i = siblings.length - 1; i > -1; i--) {
|
|
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. */
|
|
_closeDialogs(dialogs) {
|
|
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();
|
|
}
|
|
}
|
|
}
|
|
_MatDialogBase.ɵfac = function _MatDialogBase_Factory(t) { return new (t || _MatDialogBase)(ɵngcc0.ɵɵdirectiveInject(ɵngcc1.Overlay), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.Injector), ɵngcc0.ɵɵdirectiveInject(undefined), ɵngcc0.ɵɵdirectiveInject(undefined), ɵngcc0.ɵɵdirectiveInject(ɵngcc1.OverlayContainer), ɵngcc0.ɵɵdirectiveInject(undefined), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.Type), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.Type), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.InjectionToken)); };
|
|
_MatDialogBase.ɵdir = /*@__PURE__*/ ɵngcc0.ɵɵdefineDirective({ type: _MatDialogBase });
|
|
_MatDialogBase.ctorParameters = () => [
|
|
{ type: Overlay },
|
|
{ type: Injector },
|
|
{ type: undefined },
|
|
{ type: undefined },
|
|
{ type: OverlayContainer },
|
|
{ type: undefined },
|
|
{ type: Type },
|
|
{ type: Type },
|
|
{ type: InjectionToken }
|
|
];
|
|
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(_MatDialogBase, [{
|
|
type: Directive
|
|
}], function () { return [{ type: ɵngcc1.Overlay }, { type: ɵngcc0.Injector }, { type: undefined }, { type: undefined }, { type: ɵngcc1.OverlayContainer }, { type: undefined }, { type: ɵngcc0.Type }, { type: ɵngcc0.Type }, { type: ɵngcc0.InjectionToken }]; }, null); })();
|
|
/**
|
|
* Service to open Material Design modal dialogs.
|
|
*/
|
|
export class MatDialog extends _MatDialogBase {
|
|
constructor(overlay, injector,
|
|
/**
|
|
* @deprecated `_location` parameter to be removed.
|
|
* @breaking-change 10.0.0
|
|
*/
|
|
location, defaultOptions, scrollStrategy, parentDialog, overlayContainer) {
|
|
super(overlay, injector, defaultOptions, parentDialog, overlayContainer, scrollStrategy, MatDialogRef, MatDialogContainer, MAT_DIALOG_DATA);
|
|
}
|
|
}
|
|
MatDialog.ɵfac = function MatDialog_Factory(t) { return new (t || MatDialog)(ɵngcc0.ɵɵinject(ɵngcc1.Overlay), ɵngcc0.ɵɵinject(ɵngcc0.Injector), ɵngcc0.ɵɵinject(ɵngcc2.Location, 8), ɵngcc0.ɵɵinject(MAT_DIALOG_DEFAULT_OPTIONS, 8), ɵngcc0.ɵɵinject(MAT_DIALOG_SCROLL_STRATEGY), ɵngcc0.ɵɵinject(MatDialog, 12), ɵngcc0.ɵɵinject(ɵngcc1.OverlayContainer)); };
|
|
MatDialog.ɵprov = /*@__PURE__*/ ɵngcc0.ɵɵdefineInjectable({ token: MatDialog, factory: MatDialog.ɵfac });
|
|
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 }
|
|
];
|
|
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(MatDialog, [{
|
|
type: Injectable
|
|
}], function () { return [{ type: ɵngcc1.Overlay }, { type: ɵngcc0.Injector }, { type: ɵngcc2.Location, decorators: [{
|
|
type: Optional
|
|
}] }, { type: ɵngcc3.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: ɵngcc1.OverlayContainer }]; }, null); })();
|
|
/**
|
|
* Applies default options to the dialog config.
|
|
* @param config Config to be modified.
|
|
* @param defaultOptions Default options provided.
|
|
* @returns The new configuration object.
|
|
*/
|
|
function _applyConfigDefaults(config, defaultOptions) {
|
|
return Object.assign(Object.assign({}, defaultOptions), config);
|
|
}
|
|
|
|
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"dialog.js","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, TemplatePortal} from '@angular/cdk/portal';\nimport {Location} from '@angular/common';\nimport {\n  Directive,\n  Inject,\n  Injectable,\n  InjectFlags,\n  InjectionToken,\n  Injector,\n  OnDestroy,\n  Optional,\n  SkipSelf,\n  StaticProvider,\n  TemplateRef,\n  Type,\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, _MatDialogContainerBase} 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 * Base class for dialog services. The base dialog service allows\n * for arbitrary dialog refs and dialog container components.\n */\n@Directive()\nexport abstract class _MatDialogBase<C extends _MatDialogContainerBase> 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  _getAfterAllClosed(): Subject<void> {\n    const parent = this._parentDialog;\n    return parent ? parent._getAfterAllClosed() : 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._getAfterAllClosed() :\n      this._getAfterAllClosed().pipe(startWith(undefined))) as Observable<any>;\n\n  constructor(\n      private _overlay: Overlay,\n      private _injector: Injector,\n      private _defaultOptions: MatDialogConfig|undefined,\n      private _parentDialog: _MatDialogBase<C>|undefined,\n      private _overlayContainer: OverlayContainer,\n      scrollStrategy: any,\n      private _dialogRefConstructor: Type<MatDialogRef<any>>,\n      private _dialogContainerType: Type<C>,\n      private _dialogDataToken: InjectionToken<any>) {\n    this._scrollStrategy = scrollStrategy;\n  }\n\n  /**\n   * Opens a modal dialog containing the given component.\n   * @param component Type of the component to load into the dialog.\n   * @param config Extra configuration options.\n   * @returns Reference to the newly-opened dialog.\n   */\n  open<T, D = any, R = any>(component: ComponentType<T>,\n                            config?: MatDialogConfig<D>): MatDialogRef<T, R>;\n\n  /**\n   * Opens a modal dialog containing the given template.\n   * @param template 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>(template: TemplateRef<T>,\n                            config?: MatDialogConfig<D>): MatDialogRef<T, R>;\n\n  open<T, D = any, R = any>(template: ComponentType<T> | TemplateRef<T>,\n                            config?: MatDialogConfig<D>): MatDialogRef<T, R>;\n\n  open<T, D = any, R = any>(componentOrTemplateRef: ComponentType<T> | TemplateRef<T>,\n                            config?: MatDialogConfig<D>): MatDialogRef<T, R> {\n    config = _applyConfigDefaults(config, this._defaultOptions || new MatDialogConfig());\n\n    if (config.id && this.getDialogById(config.id) &&\n      (typeof ngDevMode === 'undefined' || ngDevMode)) {\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    // Notify the dialog container that the content has been attached.\n    dialogContainer._initializeWithAttachedContent();\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 a dialog container 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): C {\n    const userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;\n    const injector = Injector.create({\n      parent: userInjector || this._injector,\n      providers: [{provide: MatDialogConfig, useValue: config}]\n    });\n\n    const containerPortal = new ComponentPortal(this._dialogContainerType,\n        config.viewContainerRef, injector, config.componentFactoryResolver);\n    const containerRef = overlay.attach<C>(containerPortal);\n\n    return containerRef.instance;\n  }\n\n  /**\n   * Attaches the user-provided component to the already-created dialog container.\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 dialog container.\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: C,\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 = new this._dialogRefConstructor(overlayRef, dialogContainer, config.id);\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 dialogContainer 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: C): Injector {\n\n    const userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;\n\n    // The dialog container should be provided as the dialog container and the dialog's\n    // content are created out of the same `ViewContainerRef` and as such, are siblings\n    // for injector purposes. To allow the hierarchy that is expected, the dialog\n    // container is explicitly provided in the injector.\n    const providers: StaticProvider[] = [\n      {provide: this._dialogContainerType, useValue: dialogContainer},\n      {provide: this._dialogDataToken, useValue: config.data},\n      {provide: this._dialogRefConstructor, useValue: dialogRef}\n    ];\n\n    if (config.direction && (!userInjector ||\n        !userInjector.get<Directionality | null>(Directionality, null, InjectFlags.Optional))) {\n      providers.push({\n        provide: Directionality,\n        useValue: {value: config.direction, change: observableOf()}\n      });\n    }\n\n    return Injector.create({parent: userInjector || this._injector, providers});\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._getAfterAllClosed().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 * Service to open Material Design modal dialogs.\n */\n@Injectable()\nexport class MatDialog extends _MatDialogBase<MatDialogContainer> {\n  constructor(\n      overlay: Overlay,\n      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) defaultOptions: MatDialogConfig,\n      @Inject(MAT_DIALOG_SCROLL_STRATEGY) scrollStrategy: any,\n      @Optional() @SkipSelf() parentDialog: MatDialog,\n      overlayContainer: OverlayContainer) {\n    super(overlay, injector, defaultOptions, parentDialog, overlayContainer, scrollStrategy,\n        MatDialogRef, MatDialogContainer, MAT_DIALOG_DATA);\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"]}
|