@angular/material
Version:
Angular Material
849 lines (837 loc) • 44.3 kB
JavaScript
import { CdkDialogContainer, Dialog, DialogConfig, DialogModule } from '@angular/cdk/dialog';
import * as i1$1 from '@angular/cdk/overlay';
import { Overlay, OverlayModule } from '@angular/cdk/overlay';
import * as i4 from '@angular/cdk/portal';
import { PortalModule } from '@angular/cdk/portal';
import * as i0 from '@angular/core';
import { EventEmitter, Component, Optional, Inject, ViewEncapsulation, ChangeDetectionStrategy, InjectionToken, Injectable, SkipSelf, Directive, Input, NgModule } from '@angular/core';
import { MatCommonModule } from '@angular/material/core';
import * as i2 from '@angular/common';
import { DOCUMENT } from '@angular/common';
import { Subject, merge, defer } from 'rxjs';
import { filter, take, startWith } from 'rxjs/operators';
import { trigger, state, style, transition, group, animate, query, animateChild } from '@angular/animations';
import * as i1 from '@angular/cdk/a11y';
import { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';
import { ANIMATION_MODULE_TYPE } from '@angular/platform-browser/animations';
/**
* @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
*/
/**
* Default parameters for the animation for backwards compatibility.
* @docs-private
*/
const defaultParams = {
params: { enterAnimationDuration: '150ms', exitAnimationDuration: '75ms' },
};
/**
* Animations used by MatDialog.
* @docs-private
*/
const matDialogAnimations = {
/** Animation that is applied on the dialog container by default. */
dialogContainer: trigger('dialogContainer', [
// Note: The `enter` animation transitions to `transform: none`, because for some reason
// specifying the transform explicitly, causes IE both to blur the dialog content and
// decimate the animation performance. Leaving it as `none` solves both issues.
state('void, exit', style({ opacity: 0, transform: 'scale(0.7)' })),
state('enter', style({ transform: 'none' })),
transition('* => enter', group([
animate('{{enterAnimationDuration}} cubic-bezier(0, 0, 0.2, 1)', style({ transform: 'none', opacity: 1 })),
query('@*', animateChild(), { optional: true }),
]), defaultParams),
transition('* => void, * => exit', group([
animate('{{exitAnimationDuration}} cubic-bezier(0.4, 0.0, 0.2, 1)', style({ opacity: 0 })),
query('@*', animateChild(), { optional: true }),
]), defaultParams),
]),
};
/**
* @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
*/
/**
* Configuration for opening a modal dialog with the MatDialog service.
*/
class MatDialogConfig {
constructor() {
/** The ARIA role of the dialog element. */
this.role = 'dialog';
/** Custom class for the overlay pane. */
this.panelClass = '';
/** Whether the dialog has a backdrop. */
this.hasBackdrop = true;
/** Custom class for the backdrop. */
this.backdropClass = '';
/** Whether the user can use escape or clicking on the backdrop to close the modal. */
this.disableClose = false;
/** Width of the dialog. */
this.width = '';
/** Height of the dialog. */
this.height = '';
/** Max-width of the dialog. If a number is provided, assumes pixel units. Defaults to 80vw. */
this.maxWidth = '80vw';
/** Data being injected into the child component. */
this.data = null;
/** ID of the element that describes the dialog. */
this.ariaDescribedBy = null;
/** ID of the element that labels the dialog. */
this.ariaLabelledBy = null;
/** Aria label to assign to the dialog element. */
this.ariaLabel = null;
/**
* Where the dialog should focus on open.
* @breaking-change 14.0.0 Remove boolean option from autoFocus. Use string or
* AutoFocusTarget instead.
*/
this.autoFocus = 'first-tabbable';
/**
* Whether the dialog should restore focus to the
* previously-focused element, after it's closed.
*/
this.restoreFocus = true;
/** Whether to wait for the opening animation to finish before trapping focus. */
this.delayFocusTrap = true;
/**
* Whether the dialog should close when the user goes backwards/forwards in history.
* Note that this usually doesn't include clicking on links (unless the user is using
* the `HashLocationStrategy`).
*/
this.closeOnNavigation = true;
/** Duration of the enter animation. Has to be a valid CSS value (e.g. 100ms). */
this.enterAnimationDuration = defaultParams.params.enterAnimationDuration;
/** Duration of the exit animation. Has to be a valid CSS value (e.g. 50ms). */
this.exitAnimationDuration = defaultParams.params.exitAnimationDuration;
// TODO(jelbourn): add configuration for lifecycle hooks, ARIA labelling.
}
}
/**
* Base class for the `MatDialogContainer`. The base class does not implement
* animations as these are left to implementers of the dialog container.
*/
// tslint:disable-next-line:validate-decorators
class _MatDialogContainerBase extends CdkDialogContainer {
constructor(elementRef, focusTrapFactory, _document, dialogConfig, interactivityChecker, ngZone, overlayRef, focusMonitor) {
super(elementRef, focusTrapFactory, _document, dialogConfig, interactivityChecker, ngZone, overlayRef, focusMonitor);
/** Emits when an animation state changes. */
this._animationStateChanged = new EventEmitter();
}
_captureInitialFocus() {
if (!this._config.delayFocusTrap) {
this._trapFocus();
}
}
/**
* Callback for when the open dialog animation has finished. Intended to
* be called by sub-classes that use different animation implementations.
*/
_openAnimationDone(totalTime) {
if (this._config.delayFocusTrap) {
this._trapFocus();
}
this._animationStateChanged.next({ state: 'opened', totalTime });
}
}
_MatDialogContainerBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: _MatDialogContainerBase, deps: [{ token: i0.ElementRef }, { token: i1.FocusTrapFactory }, { token: DOCUMENT, optional: true }, { token: MatDialogConfig }, { token: i1.InteractivityChecker }, { token: i0.NgZone }, { token: i1$1.OverlayRef }, { token: i1.FocusMonitor }], target: i0.ɵɵFactoryTarget.Component });
_MatDialogContainerBase.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.0.1", type: _MatDialogContainerBase, selector: "ng-component", usesInheritance: true, ngImport: i0, template: '', isInline: true });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: _MatDialogContainerBase, decorators: [{
type: Component,
args: [{ template: '' }]
}], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.FocusTrapFactory }, { type: undefined, decorators: [{
type: Optional
}, {
type: Inject,
args: [DOCUMENT]
}] }, { type: MatDialogConfig }, { type: i1.InteractivityChecker }, { type: i0.NgZone }, { type: i1$1.OverlayRef }, { type: i1.FocusMonitor }]; } });
/**
* Internal component that wraps user-provided dialog content.
* Animation is based on https://material.io/guidelines/motion/choreography.html.
* @docs-private
*/
class MatDialogContainer extends _MatDialogContainerBase {
constructor(elementRef, focusTrapFactory, document, dialogConfig, checker, ngZone, overlayRef, _changeDetectorRef, focusMonitor) {
super(elementRef, focusTrapFactory, document, dialogConfig, checker, ngZone, overlayRef, focusMonitor);
this._changeDetectorRef = _changeDetectorRef;
/** State of the dialog animation. */
this._state = 'enter';
}
/** Callback, invoked whenever an animation on the host completes. */
_onAnimationDone({ toState, totalTime }) {
if (toState === 'enter') {
this._openAnimationDone(totalTime);
}
else if (toState === 'exit') {
this._animationStateChanged.next({ state: 'closed', totalTime });
}
}
/** Callback, invoked when an animation on the host starts. */
_onAnimationStart({ toState, totalTime }) {
if (toState === 'enter') {
this._animationStateChanged.next({ state: 'opening', totalTime });
}
else if (toState === 'exit' || toState === 'void') {
this._animationStateChanged.next({ state: 'closing', totalTime });
}
}
/** Starts the dialog exit animation. */
_startExitAnimation() {
this._state = 'exit';
// Mark the container for check so it can react if the
// view container is using OnPush change detection.
this._changeDetectorRef.markForCheck();
}
_getAnimationState() {
return {
value: this._state,
params: {
'enterAnimationDuration': this._config.enterAnimationDuration || defaultParams.params.enterAnimationDuration,
'exitAnimationDuration': this._config.exitAnimationDuration || defaultParams.params.exitAnimationDuration,
},
};
}
}
MatDialogContainer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: MatDialogContainer, deps: [{ token: i0.ElementRef }, { token: i1.FocusTrapFactory }, { token: DOCUMENT, optional: true }, { token: MatDialogConfig }, { token: i1.InteractivityChecker }, { token: i0.NgZone }, { token: i1$1.OverlayRef }, { token: i0.ChangeDetectorRef }, { token: i1.FocusMonitor }], target: i0.ɵɵFactoryTarget.Component });
MatDialogContainer.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.0.1", type: MatDialogContainer, selector: "mat-dialog-container", host: { attributes: { "tabindex": "-1" }, listeners: { "@dialogContainer.start": "_onAnimationStart($event)", "@dialogContainer.done": "_onAnimationDone($event)" }, properties: { "attr.aria-modal": "_config.ariaModal", "id": "_config.id", "attr.role": "_config.role", "attr.aria-labelledby": "_config.ariaLabel ? null : _ariaLabelledBy", "attr.aria-label": "_config.ariaLabel", "attr.aria-describedby": "_config.ariaDescribedBy || null", "@dialogContainer": "_getAnimationState()" }, classAttribute: "mat-dialog-container" }, usesInheritance: true, ngImport: i0, template: "<ng-template cdkPortalOutlet></ng-template>\n", styles: [".mat-dialog-container{display:block;padding:24px;border-radius:4px;box-sizing:border-box;overflow:auto;outline:0;width:100%;height:100%;min-height:inherit;max-height:inherit}.cdk-high-contrast-active .mat-dialog-container{outline:solid 1px}.mat-dialog-content{display:block;margin:0 -24px;padding:0 24px;max-height:65vh;overflow:auto;-webkit-overflow-scrolling:touch}.mat-dialog-title{margin:0 0 20px;display:block}.mat-dialog-actions{padding:8px 0;display:flex;flex-wrap:wrap;min-height:52px;align-items:center;box-sizing:content-box;margin-bottom:-24px}.mat-dialog-actions.mat-dialog-actions-align-center,.mat-dialog-actions[align=center]{justify-content:center}.mat-dialog-actions.mat-dialog-actions-align-end,.mat-dialog-actions[align=end]{justify-content:flex-end}.mat-dialog-actions .mat-button-base+.mat-button-base,.mat-dialog-actions .mat-mdc-button-base+.mat-mdc-button-base{margin-left:8px}[dir=rtl] .mat-dialog-actions .mat-button-base+.mat-button-base,[dir=rtl] .mat-dialog-actions .mat-mdc-button-base+.mat-mdc-button-base{margin-left:0;margin-right:8px}"], dependencies: [{ kind: "directive", type: i4.CdkPortalOutlet, selector: "[cdkPortalOutlet]", inputs: ["cdkPortalOutlet"], outputs: ["attached"], exportAs: ["cdkPortalOutlet"] }], animations: [matDialogAnimations.dialogContainer], changeDetection: i0.ChangeDetectionStrategy.Default, encapsulation: i0.ViewEncapsulation.None });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: MatDialogContainer, decorators: [{
type: Component,
args: [{ selector: 'mat-dialog-container', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.Default, animations: [matDialogAnimations.dialogContainer], host: {
'class': 'mat-dialog-container',
'tabindex': '-1',
'[attr.aria-modal]': '_config.ariaModal',
'[id]': '_config.id',
'[attr.role]': '_config.role',
'[attr.aria-labelledby]': '_config.ariaLabel ? null : _ariaLabelledBy',
'[attr.aria-label]': '_config.ariaLabel',
'[attr.aria-describedby]': '_config.ariaDescribedBy || null',
'[@dialogContainer]': `_getAnimationState()`,
'(@dialogContainer.start)': '_onAnimationStart($event)',
'(@dialogContainer.done)': '_onAnimationDone($event)',
}, template: "<ng-template cdkPortalOutlet></ng-template>\n", styles: [".mat-dialog-container{display:block;padding:24px;border-radius:4px;box-sizing:border-box;overflow:auto;outline:0;width:100%;height:100%;min-height:inherit;max-height:inherit}.cdk-high-contrast-active .mat-dialog-container{outline:solid 1px}.mat-dialog-content{display:block;margin:0 -24px;padding:0 24px;max-height:65vh;overflow:auto;-webkit-overflow-scrolling:touch}.mat-dialog-title{margin:0 0 20px;display:block}.mat-dialog-actions{padding:8px 0;display:flex;flex-wrap:wrap;min-height:52px;align-items:center;box-sizing:content-box;margin-bottom:-24px}.mat-dialog-actions.mat-dialog-actions-align-center,.mat-dialog-actions[align=center]{justify-content:center}.mat-dialog-actions.mat-dialog-actions-align-end,.mat-dialog-actions[align=end]{justify-content:flex-end}.mat-dialog-actions .mat-button-base+.mat-button-base,.mat-dialog-actions .mat-mdc-button-base+.mat-mdc-button-base{margin-left:8px}[dir=rtl] .mat-dialog-actions .mat-button-base+.mat-button-base,[dir=rtl] .mat-dialog-actions .mat-mdc-button-base+.mat-mdc-button-base{margin-left:0;margin-right:8px}"] }]
}], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.FocusTrapFactory }, { type: undefined, decorators: [{
type: Optional
}, {
type: Inject,
args: [DOCUMENT]
}] }, { type: MatDialogConfig }, { type: i1.InteractivityChecker }, { type: i0.NgZone }, { type: i1$1.OverlayRef }, { type: i0.ChangeDetectorRef }, { type: i1.FocusMonitor }]; } });
/**
* @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
*/
/**
* Reference to a dialog opened via the MatDialog service.
*/
class MatDialogRef {
constructor(_ref, config, _containerInstance) {
this._ref = _ref;
this._containerInstance = _containerInstance;
/** Subject for notifying the user that the dialog has finished opening. */
this._afterOpened = new Subject();
/** Subject for notifying the user that the dialog has started closing. */
this._beforeClosed = new Subject();
/** Current state of the dialog. */
this._state = 0 /* MatDialogState.OPEN */;
this.disableClose = config.disableClose;
this.id = _ref.id;
// Emit when opening animation completes
_containerInstance._animationStateChanged
.pipe(filter(event => event.state === 'opened'), take(1))
.subscribe(() => {
this._afterOpened.next();
this._afterOpened.complete();
});
// Dispose overlay when closing animation is complete
_containerInstance._animationStateChanged
.pipe(filter(event => event.state === 'closed'), take(1))
.subscribe(() => {
clearTimeout(this._closeFallbackTimeout);
this._finishDialogClose();
});
_ref.overlayRef.detachments().subscribe(() => {
this._beforeClosed.next(this._result);
this._beforeClosed.complete();
this._finishDialogClose();
});
merge(this.backdropClick(), this.keydownEvents().pipe(filter(event => event.keyCode === ESCAPE && !this.disableClose && !hasModifierKey(event)))).subscribe(event => {
if (!this.disableClose) {
event.preventDefault();
_closeDialogVia(this, event.type === 'keydown' ? 'keyboard' : 'mouse');
}
});
}
/**
* Close the dialog.
* @param dialogResult Optional result to return to the dialog opener.
*/
close(dialogResult) {
this._result = dialogResult;
// Transition the backdrop in parallel to the dialog.
this._containerInstance._animationStateChanged
.pipe(filter(event => event.state === 'closing'), take(1))
.subscribe(event => {
this._beforeClosed.next(dialogResult);
this._beforeClosed.complete();
this._ref.overlayRef.detachBackdrop();
// The logic that disposes of the overlay depends on the exit animation completing, however
// it isn't guaranteed if the parent view is destroyed while it's running. Add a fallback
// timeout which will clean everything up if the animation hasn't fired within the specified
// amount of time plus 100ms. We don't need to run this outside the NgZone, because for the
// vast majority of cases the timeout will have been cleared before it has the chance to fire.
this._closeFallbackTimeout = setTimeout(() => this._finishDialogClose(), event.totalTime + 100);
});
this._state = 1 /* MatDialogState.CLOSING */;
this._containerInstance._startExitAnimation();
}
/**
* Gets an observable that is notified when the dialog is finished opening.
*/
afterOpened() {
return this._afterOpened;
}
/**
* Gets an observable that is notified when the dialog is finished closing.
*/
afterClosed() {
return this._ref.closed;
}
/**
* Gets an observable that is notified when the dialog has started closing.
*/
beforeClosed() {
return this._beforeClosed;
}
/**
* Gets an observable that emits when the overlay's backdrop has been clicked.
*/
backdropClick() {
return this._ref.backdropClick;
}
/**
* Gets an observable that emits when keydown events are targeted on the overlay.
*/
keydownEvents() {
return this._ref.keydownEvents;
}
/**
* Updates the dialog's position.
* @param position New dialog position.
*/
updatePosition(position) {
let strategy = this._ref.config.positionStrategy;
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._ref.updatePosition();
return this;
}
/**
* Updates the dialog's width and height.
* @param width New width of the dialog.
* @param height New height of the dialog.
*/
updateSize(width = '', height = '') {
this._ref.updateSize(width, height);
return this;
}
/** Add a CSS class or an array of classes to the overlay pane. */
addPanelClass(classes) {
this._ref.addPanelClass(classes);
return this;
}
/** Remove a CSS class or an array of classes from the overlay pane. */
removePanelClass(classes) {
this._ref.removePanelClass(classes);
return this;
}
/** Gets the current state of the dialog's lifecycle. */
getState() {
return this._state;
}
/**
* Finishes the dialog close by updating the state of the dialog
* and disposing the overlay.
*/
_finishDialogClose() {
this._state = 2 /* MatDialogState.CLOSED */;
this._ref.close(this._result, { focusOrigin: this._closeInteractionType });
this.componentInstance = null;
}
}
/**
* Closes the dialog with the specified interaction type. This is currently not part of
* `MatDialogRef` as that would conflict with custom dialog ref mocks provided in tests.
* More details. See: https://github.com/angular/components/pull/9257#issuecomment-651342226.
*/
// TODO: Move this back into `MatDialogRef` when we provide an official mock dialog ref.
function _closeDialogVia(ref, interactionType, result) {
ref._closeInteractionType = interactionType;
return ref.close(result);
}
/**
* @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
*/
/** Injection token that can be used to access the data that was passed in to a dialog. */
const MAT_DIALOG_DATA = new InjectionToken('MatDialogData');
/** Injection token that can be used to specify default dialog options. */
const MAT_DIALOG_DEFAULT_OPTIONS = new InjectionToken('mat-dialog-default-options');
/** Injection token that determines the scroll handling while the dialog is open. */
const MAT_DIALOG_SCROLL_STRATEGY = new InjectionToken('mat-dialog-scroll-strategy');
/** @docs-private */
function MAT_DIALOG_SCROLL_STRATEGY_FACTORY(overlay) {
return () => overlay.scrollStrategies.block();
}
/** @docs-private */
function MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {
return () => overlay.scrollStrategies.block();
}
/** @docs-private */
const MAT_DIALOG_SCROLL_STRATEGY_PROVIDER = {
provide: MAT_DIALOG_SCROLL_STRATEGY,
deps: [Overlay],
useFactory: MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY,
};
// Counter for unique dialog ids.
let uniqueId = 0;
/**
* Base class for dialog services. The base dialog service allows
* for arbitrary dialog refs and dialog container components.
*/
class _MatDialogBase {
constructor(_overlay, injector, _defaultOptions, _parentDialog,
/**
* @deprecated No longer used. To be removed.
* @breaking-change 15.0.0
*/
_overlayContainer, scrollStrategy, _dialogRefConstructor, _dialogContainerType, _dialogDataToken,
/**
* @deprecated No longer used. To be removed.
* @breaking-change 14.0.0
*/
_animationMode) {
this._overlay = _overlay;
this._defaultOptions = _defaultOptions;
this._parentDialog = _parentDialog;
this._dialogRefConstructor = _dialogRefConstructor;
this._dialogContainerType = _dialogContainerType;
this._dialogDataToken = _dialogDataToken;
this._openDialogsAtThisLevel = [];
this._afterAllClosedAtThisLevel = new Subject();
this._afterOpenedAtThisLevel = new Subject();
this._idPrefix = 'mat-dialog-';
/**
* 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;
this._dialog = injector.get(Dialog);
}
/** 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) {
let dialogRef;
config = { ...(this._defaultOptions || new MatDialogConfig()), ...config };
config.id = config.id || `${this._idPrefix}${uniqueId++}`;
config.scrollStrategy = config.scrollStrategy || this._scrollStrategy();
const cdkRef = this._dialog.open(componentOrTemplateRef, {
...config,
positionStrategy: this._overlay.position().global().centerHorizontally().centerVertically(),
// Disable closing since we need to sync it up to the animation ourselves.
disableClose: true,
// Disable closing on destroy, because this service cleans up its open dialogs as well.
// We want to do the cleanup here, rather than the CDK service, because the CDK destroys
// the dialogs immediately whereas we want it to wait for the animations to finish.
closeOnDestroy: false,
container: {
type: this._dialogContainerType,
providers: () => [
// Provide our config as the CDK config as well since it has the same interface as the
// CDK one, but it contains the actual values passed in by the user for things like
// `disableClose` which we disable for the CDK dialog since we handle it ourselves.
{ provide: MatDialogConfig, useValue: config },
{ provide: DialogConfig, useValue: config },
],
},
templateContext: () => ({ dialogRef }),
providers: (ref, cdkConfig, dialogContainer) => {
dialogRef = new this._dialogRefConstructor(ref, config, dialogContainer);
dialogRef.updatePosition(config?.position);
return [
{ provide: this._dialogContainerType, useValue: dialogContainer },
{ provide: this._dialogDataToken, useValue: cdkConfig.data },
{ provide: this._dialogRefConstructor, useValue: dialogRef },
];
},
});
// This can't be assigned in the `providers` callback, because
// the instance hasn't been assigned to the CDK ref yet.
dialogRef.componentInstance = cdkRef.componentInstance;
this.openDialogs.push(dialogRef);
this.afterOpened.next(dialogRef);
dialogRef.afterClosed().subscribe(() => {
const index = this.openDialogs.indexOf(dialogRef);
if (index > -1) {
this.openDialogs.splice(index, 1);
if (!this.openDialogs.length) {
this._getAfterAllClosed().next();
}
}
});
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();
}
_closeDialogs(dialogs) {
let i = dialogs.length;
while (i--) {
dialogs[i].close();
}
}
}
_MatDialogBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: _MatDialogBase, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
_MatDialogBase.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: _MatDialogBase });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: _MatDialogBase, decorators: [{
type: Injectable
}], ctorParameters: function () { return [{ type: i1$1.Overlay }, { type: i0.Injector }, { type: undefined }, { type: undefined }, { type: i1$1.OverlayContainer }, { type: undefined }, { type: i0.Type }, { type: i0.Type }, { type: i0.InjectionToken }, { type: undefined }]; } });
/**
* Service to open Material Design modal dialogs.
*/
class MatDialog extends _MatDialogBase {
constructor(overlay, injector,
/**
* @deprecated `_location` parameter to be removed.
* @breaking-change 10.0.0
*/
_location, defaultOptions, scrollStrategy, parentDialog,
/**
* @deprecated No longer used. To be removed.
* @breaking-change 15.0.0
*/
overlayContainer,
/**
* @deprecated No longer used. To be removed.
* @breaking-change 14.0.0
*/
animationMode) {
super(overlay, injector, defaultOptions, parentDialog, overlayContainer, scrollStrategy, MatDialogRef, MatDialogContainer, MAT_DIALOG_DATA, animationMode);
}
}
MatDialog.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: MatDialog, deps: [{ token: i1$1.Overlay }, { token: i0.Injector }, { token: i2.Location, optional: true }, { token: MAT_DIALOG_DEFAULT_OPTIONS, optional: true }, { token: MAT_DIALOG_SCROLL_STRATEGY }, { token: MatDialog, optional: true, skipSelf: true }, { token: i1$1.OverlayContainer }, { token: ANIMATION_MODULE_TYPE, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
MatDialog.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: MatDialog });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: MatDialog, decorators: [{
type: Injectable
}], ctorParameters: function () { return [{ type: i1$1.Overlay }, { type: i0.Injector }, { type: i2.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: i1$1.OverlayContainer }, { type: undefined, decorators: [{
type: Optional
}, {
type: Inject,
args: [ANIMATION_MODULE_TYPE]
}] }]; } });
/**
* @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
*/
/** Counter used to generate unique IDs for dialog elements. */
let dialogElementUid = 0;
/**
* Button that will close the current dialog.
*/
class MatDialogClose {
constructor(
/**
* Reference to the containing dialog.
* @deprecated `dialogRef` property to become private.
* @breaking-change 13.0.0
*/
// The dialog title directive is always used in combination with a `MatDialogRef`.
// tslint:disable-next-line: lightweight-tokens
dialogRef, _elementRef, _dialog) {
this.dialogRef = dialogRef;
this._elementRef = _elementRef;
this._dialog = _dialog;
/** Default to "button" to prevents accidental form submits. */
this.type = 'button';
}
ngOnInit() {
if (!this.dialogRef) {
// When this directive is included in a dialog via TemplateRef (rather than being
// in a Component), the DialogRef isn't available via injection because embedded
// views cannot be given a custom injector. Instead, we look up the DialogRef by
// ID. This must occur in `onInit`, as the ID binding for the dialog container won't
// be resolved at constructor time.
this.dialogRef = getClosestDialog(this._elementRef, this._dialog.openDialogs);
}
}
ngOnChanges(changes) {
const proxiedChange = changes['_matDialogClose'] || changes['_matDialogCloseResult'];
if (proxiedChange) {
this.dialogResult = proxiedChange.currentValue;
}
}
_onButtonClick(event) {
// Determinate the focus origin using the click event, because using the FocusMonitor will
// result in incorrect origins. Most of the time, close buttons will be auto focused in the
// dialog, and therefore clicking the button won't result in a focus change. This means that
// the FocusMonitor won't detect any origin change, and will always output `program`.
_closeDialogVia(this.dialogRef, event.screenX === 0 && event.screenY === 0 ? 'keyboard' : 'mouse', this.dialogResult);
}
}
MatDialogClose.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: MatDialogClose, deps: [{ token: MatDialogRef, optional: true }, { token: i0.ElementRef }, { token: MatDialog }], target: i0.ɵɵFactoryTarget.Directive });
MatDialogClose.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.0.1", type: MatDialogClose, selector: "[mat-dialog-close], [matDialogClose]", inputs: { ariaLabel: ["aria-label", "ariaLabel"], type: "type", dialogResult: ["mat-dialog-close", "dialogResult"], _matDialogClose: ["matDialogClose", "_matDialogClose"] }, host: { listeners: { "click": "_onButtonClick($event)" }, properties: { "attr.aria-label": "ariaLabel || null", "attr.type": "type" } }, exportAs: ["matDialogClose"], usesOnChanges: true, ngImport: i0 });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: MatDialogClose, decorators: [{
type: Directive,
args: [{
selector: '[mat-dialog-close], [matDialogClose]',
exportAs: 'matDialogClose',
host: {
'(click)': '_onButtonClick($event)',
'[attr.aria-label]': 'ariaLabel || null',
'[attr.type]': 'type',
},
}]
}], ctorParameters: function () { return [{ type: MatDialogRef, decorators: [{
type: Optional
}] }, { type: i0.ElementRef }, { type: MatDialog }]; }, propDecorators: { ariaLabel: [{
type: Input,
args: ['aria-label']
}], type: [{
type: Input
}], dialogResult: [{
type: Input,
args: ['mat-dialog-close']
}], _matDialogClose: [{
type: Input,
args: ['matDialogClose']
}] } });
/**
* Title of a dialog element. Stays fixed to the top of the dialog when scrolling.
*/
class MatDialogTitle {
constructor(
// The dialog title directive is always used in combination with a `MatDialogRef`.
// tslint:disable-next-line: lightweight-tokens
_dialogRef, _elementRef, _dialog) {
this._dialogRef = _dialogRef;
this._elementRef = _elementRef;
this._dialog = _dialog;
/** Unique id for the dialog title. If none is supplied, it will be auto-generated. */
this.id = `mat-dialog-title-${dialogElementUid++}`;
}
ngOnInit() {
if (!this._dialogRef) {
this._dialogRef = getClosestDialog(this._elementRef, this._dialog.openDialogs);
}
if (this._dialogRef) {
Promise.resolve().then(() => {
const container = this._dialogRef._containerInstance;
if (container && !container._ariaLabelledBy) {
container._ariaLabelledBy = this.id;
}
});
}
}
}
MatDialogTitle.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: MatDialogTitle, deps: [{ token: MatDialogRef, optional: true }, { token: i0.ElementRef }, { token: MatDialog }], target: i0.ɵɵFactoryTarget.Directive });
MatDialogTitle.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.0.1", type: MatDialogTitle, selector: "[mat-dialog-title], [matDialogTitle]", inputs: { id: "id" }, host: { properties: { "id": "id" }, classAttribute: "mat-dialog-title" }, exportAs: ["matDialogTitle"], ngImport: i0 });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: MatDialogTitle, decorators: [{
type: Directive,
args: [{
selector: '[mat-dialog-title], [matDialogTitle]',
exportAs: 'matDialogTitle',
host: {
'class': 'mat-dialog-title',
'[id]': 'id',
},
}]
}], ctorParameters: function () { return [{ type: MatDialogRef, decorators: [{
type: Optional
}] }, { type: i0.ElementRef }, { type: MatDialog }]; }, propDecorators: { id: [{
type: Input
}] } });
/**
* Scrollable content container of a dialog.
*/
class MatDialogContent {
}
MatDialogContent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: MatDialogContent, deps: [], target: i0.ɵɵFactoryTarget.Directive });
MatDialogContent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.0.1", type: MatDialogContent, selector: "[mat-dialog-content], mat-dialog-content, [matDialogContent]", host: { classAttribute: "mat-dialog-content" }, ngImport: i0 });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: MatDialogContent, decorators: [{
type: Directive,
args: [{
selector: `[mat-dialog-content], mat-dialog-content, [matDialogContent]`,
host: { 'class': 'mat-dialog-content' },
}]
}] });
/**
* Container for the bottom action buttons in a dialog.
* Stays fixed to the bottom when scrolling.
*/
class MatDialogActions {
constructor() {
/**
* Horizontal alignment of action buttons.
*/
this.align = 'start';
}
}
MatDialogActions.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: MatDialogActions, deps: [], target: i0.ɵɵFactoryTarget.Directive });
MatDialogActions.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.0.1", type: MatDialogActions, selector: "[mat-dialog-actions], mat-dialog-actions, [matDialogActions]", inputs: { align: "align" }, host: { properties: { "class.mat-dialog-actions-align-center": "align === \"center\"", "class.mat-dialog-actions-align-end": "align === \"end\"" }, classAttribute: "mat-dialog-actions" }, ngImport: i0 });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: MatDialogActions, decorators: [{
type: Directive,
args: [{
selector: `[mat-dialog-actions], mat-dialog-actions, [matDialogActions]`,
host: {
'class': 'mat-dialog-actions',
'[class.mat-dialog-actions-align-center]': 'align === "center"',
'[class.mat-dialog-actions-align-end]': 'align === "end"',
},
}]
}], propDecorators: { align: [{
type: Input
}] } });
// TODO(crisbeto): this utility shouldn't be necessary anymore, because the dialog ref is provided
// both to component and template dialogs through DI. We need to keep it around, because there are
// some internal wrappers around `MatDialog` that happened to work by accident, because we had this
// fallback logic in place.
/**
* Finds the closest MatDialogRef to an element by looking at the DOM.
* @param element Element relative to which to look for a dialog.
* @param openDialogs References to the currently-open dialogs.
*/
function getClosestDialog(element, openDialogs) {
let parent = element.nativeElement.parentElement;
while (parent && !parent.classList.contains('mat-dialog-container')) {
parent = parent.parentElement;
}
return parent ? openDialogs.find(dialog => dialog.id === parent.id) : null;
}
/**
* @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
*/
class MatDialogModule {
}
MatDialogModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: MatDialogModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
MatDialogModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.0.1", ngImport: i0, type: MatDialogModule, declarations: [MatDialogContainer,
MatDialogClose,
MatDialogTitle,
MatDialogActions,
MatDialogContent], imports: [DialogModule, OverlayModule, PortalModule, MatCommonModule], exports: [MatDialogContainer,
MatDialogClose,
MatDialogTitle,
MatDialogContent,
MatDialogActions,
MatCommonModule] });
MatDialogModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: MatDialogModule, providers: [MatDialog, MAT_DIALOG_SCROLL_STRATEGY_PROVIDER], imports: [DialogModule, OverlayModule, PortalModule, MatCommonModule, MatCommonModule] });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: MatDialogModule, decorators: [{
type: NgModule,
args: [{
imports: [DialogModule, OverlayModule, PortalModule, MatCommonModule],
exports: [
MatDialogContainer,
MatDialogClose,
MatDialogTitle,
MatDialogContent,
MatDialogActions,
MatCommonModule,
],
declarations: [
MatDialogContainer,
MatDialogClose,
MatDialogTitle,
MatDialogActions,
MatDialogContent,
],
providers: [MatDialog, MAT_DIALOG_SCROLL_STRATEGY_PROVIDER],
}]
}] });
/**
* @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
*/
/**
* @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
*/
/**
* Generated bundle index. Do not edit.
*/
export { MAT_DIALOG_DATA, MAT_DIALOG_DEFAULT_OPTIONS, MAT_DIALOG_SCROLL_STRATEGY, MAT_DIALOG_SCROLL_STRATEGY_FACTORY, MAT_DIALOG_SCROLL_STRATEGY_PROVIDER, MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY, MatDialog, MatDialogActions, MatDialogClose, MatDialogConfig, MatDialogContainer, MatDialogContent, MatDialogModule, MatDialogRef, MatDialogTitle, _MatDialogBase, _MatDialogContainerBase, _closeDialogVia, matDialogAnimations };
//# sourceMappingURL=dialog.mjs.map