@angular/material
Version:
Angular Material
212 lines • 29.5 kB
JavaScript
/**
* @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 { Overlay, OverlayContainer } from '@angular/cdk/overlay';
import { Location } from '@angular/common';
import { ANIMATION_MODULE_TYPE, Inject, Injectable, InjectionToken, Injector, Optional, SkipSelf, inject, } from '@angular/core';
import { MatDialogConfig } from './dialog-config';
import { MatDialogContainer } from './dialog-container';
import { MatDialogRef } from './dialog-ref';
import { defer, Subject } from 'rxjs';
import { Dialog, DialogConfig } from '@angular/cdk/dialog';
import { startWith } from 'rxjs/operators';
import * as i0 from "@angular/core";
import * as i1 from "@angular/cdk/overlay";
import * as i2 from "@angular/common";
import * as i3 from "./dialog-config";
/** Injection token that can be used to access the data that was passed in to a dialog. */
export const MAT_DIALOG_DATA = new InjectionToken('MatMdcDialogData');
/** Injection token that can be used to specify default dialog options. */
export const MAT_DIALOG_DEFAULT_OPTIONS = new InjectionToken('mat-mdc-dialog-default-options');
/** Injection token that determines the scroll handling while the dialog is open. */
export const MAT_DIALOG_SCROLL_STRATEGY = new InjectionToken('mat-mdc-dialog-scroll-strategy', {
providedIn: 'root',
factory: () => {
const overlay = inject(Overlay);
return () => overlay.scrollStrategies.block();
},
});
/**
* @docs-private
* @deprecated No longer used. To be removed.
* @breaking-change 19.0.0
*/
export function MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {
return () => overlay.scrollStrategies.block();
}
/**
* @docs-private
* @deprecated No longer used. To be removed.
* @breaking-change 19.0.0
*/
export 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;
/**
* Service to open Material Design modal dialogs.
*/
export class MatDialog {
/** 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;
}
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) {
this._overlay = _overlay;
this._defaultOptions = _defaultOptions;
this._scrollStrategy = _scrollStrategy;
this._parentDialog = _parentDialog;
this._openDialogsAtThisLevel = [];
this._afterAllClosedAtThisLevel = new Subject();
this._afterOpenedAtThisLevel = new Subject();
this.dialogConfigClass = MatDialogConfig;
/**
* 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._dialog = injector.get(Dialog);
this._dialogRefConstructor = MatDialogRef;
this._dialogContainerType = MatDialogContainer;
this._dialogDataToken = MAT_DIALOG_DATA;
}
open(componentOrTemplateRef, config) {
let dialogRef;
config = { ...(this._defaultOptions || new MatDialogConfig()), ...config };
config.id = config.id || `mat-mdc-dialog-${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,
// Disable closing on detachments so that we can sync up the animation.
// The Material dialog ref handles this manually.
closeOnOverlayDetachments: 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: this.dialogConfigClass, 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.componentRef = cdkRef.componentRef;
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();
}
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: MatDialog, deps: [{ token: i1.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.OverlayContainer }, { token: ANIMATION_MODULE_TYPE, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: MatDialog, providedIn: 'root' }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: MatDialog, decorators: [{
type: Injectable,
args: [{ providedIn: 'root' }]
}], ctorParameters: () => [{ type: i1.Overlay }, { type: i0.Injector }, { type: i2.Location, decorators: [{
type: Optional
}] }, { type: i3.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.OverlayContainer }, { type: undefined, decorators: [{
type: Optional
}, {
type: Inject,
args: [ANIMATION_MODULE_TYPE]
}] }] });
//# 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 {ComponentType, Overlay, OverlayContainer, ScrollStrategy} from '@angular/cdk/overlay';\nimport {Location} from '@angular/common';\nimport {\n  ANIMATION_MODULE_TYPE,\n  ComponentRef,\n  Inject,\n  Injectable,\n  InjectionToken,\n  Injector,\n  OnDestroy,\n  Optional,\n  SkipSelf,\n  TemplateRef,\n  Type,\n  inject,\n} from '@angular/core';\nimport {MatDialogConfig} from './dialog-config';\nimport {MatDialogContainer} from './dialog-container';\nimport {MatDialogRef} from './dialog-ref';\nimport {defer, Observable, Subject} from 'rxjs';\nimport {Dialog, DialogConfig} from '@angular/cdk/dialog';\nimport {startWith} from 'rxjs/operators';\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>('MatMdcDialogData');\n\n/** Injection token that can be used to specify default dialog options. */\nexport const MAT_DIALOG_DEFAULT_OPTIONS = new InjectionToken<MatDialogConfig>(\n  'mat-mdc-dialog-default-options',\n);\n\n/** Injection token that determines the scroll handling while the dialog is open. */\nexport const MAT_DIALOG_SCROLL_STRATEGY = new InjectionToken<() => ScrollStrategy>(\n  'mat-mdc-dialog-scroll-strategy',\n  {\n    providedIn: 'root',\n    factory: () => {\n      const overlay = inject(Overlay);\n      return () => overlay.scrollStrategies.block();\n    },\n  },\n);\n\n/**\n * @docs-private\n * @deprecated No longer used. To be removed.\n * @breaking-change 19.0.0\n */\nexport function MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY(\n  overlay: Overlay,\n): () => ScrollStrategy {\n  return () => overlay.scrollStrategies.block();\n}\n\n/**\n * @docs-private\n * @deprecated No longer used. To be removed.\n * @breaking-change 19.0.0\n */\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// Counter for unique dialog ids.\nlet uniqueId = 0;\n\n/**\n * Service to open Material Design modal dialogs.\n */\n@Injectable({providedIn: 'root'})\nexport class MatDialog implements OnDestroy {\n  private readonly _openDialogsAtThisLevel: MatDialogRef<any>[] = [];\n  private readonly _afterAllClosedAtThisLevel = new Subject<void>();\n  private readonly _afterOpenedAtThisLevel = new Subject<MatDialogRef<any>>();\n  protected _dialog: Dialog;\n  protected dialogConfigClass = MatDialogConfig;\n\n  private readonly _dialogRefConstructor: Type<MatDialogRef<any>>;\n  private readonly _dialogContainerType: Type<MatDialogContainer>;\n  private readonly _dialogDataToken: InjectionToken<any>;\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  private _getAfterAllClosed(): Subject<void> {\n    const parent = this._parentDialog;\n    return parent ? parent._getAfterAllClosed() : this._afterAllClosedAtThisLevel;\n  }\n\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(() =>\n    this.openDialogs.length\n      ? this._getAfterAllClosed()\n      : this._getAfterAllClosed().pipe(startWith(undefined)),\n  ) as Observable<any>;\n\n  constructor(\n    private _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) private _defaultOptions: MatDialogConfig,\n    @Inject(MAT_DIALOG_SCROLL_STRATEGY) private _scrollStrategy: any,\n    @Optional() @SkipSelf() private _parentDialog: MatDialog,\n    /**\n     * @deprecated No longer used. To be removed.\n     * @breaking-change 15.0.0\n     */\n    _overlayContainer: OverlayContainer,\n    /**\n     * @deprecated No longer used. To be removed.\n     * @breaking-change 14.0.0\n     */\n    @Optional()\n    @Inject(ANIMATION_MODULE_TYPE)\n    _animationMode?: 'NoopAnimations' | 'BrowserAnimations',\n  ) {\n    this._dialog = injector.get(Dialog);\n\n    this._dialogRefConstructor = MatDialogRef;\n    this._dialogContainerType = MatDialogContainer;\n    this._dialogDataToken = MAT_DIALOG_DATA;\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>(\n    component: ComponentType<T>,\n    config?: MatDialogConfig<D>,\n  ): 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>(\n    template: TemplateRef<T>,\n    config?: MatDialogConfig<D>,\n  ): MatDialogRef<T, R>;\n\n  open<T, D = any, R = any>(\n    template: ComponentType<T> | TemplateRef<T>,\n    config?: MatDialogConfig<D>,\n  ): MatDialogRef<T, R>;\n\n  open<T, D = any, R = any>(\n    componentOrTemplateRef: ComponentType<T> | TemplateRef<T>,\n    config?: MatDialogConfig<D>,\n  ): MatDialogRef<T, R> {\n    let dialogRef: MatDialogRef<T, R>;\n    config = {...(this._defaultOptions || new MatDialogConfig()), ...config};\n    config.id = config.id || `mat-mdc-dialog-${uniqueId++}`;\n    config.scrollStrategy = config.scrollStrategy || this._scrollStrategy();\n\n    const cdkRef = this._dialog.open<R, D, T>(componentOrTemplateRef, {\n      ...config,\n      positionStrategy: this._overlay.position().global().centerHorizontally().centerVertically(),\n      // Disable closing since we need to sync it up to the animation ourselves.\n      disableClose: true,\n      // Disable closing on destroy, because this service cleans up its open dialogs as well.\n      // We want to do the cleanup here, rather than the CDK service, because the CDK destroys\n      // the dialogs immediately whereas we want it to wait for the animations to finish.\n      closeOnDestroy: false,\n      // Disable closing on detachments so that we can sync up the animation.\n      // The Material dialog ref handles this manually.\n      closeOnOverlayDetachments: false,\n      container: {\n        type: this._dialogContainerType,\n        providers: () => [\n          // Provide our config as the CDK config as well since it has the same interface as the\n          // CDK one, but it contains the actual values passed in by the user for things like\n          // `disableClose` which we disable for the CDK dialog since we handle it ourselves.\n          {provide: this.dialogConfigClass, useValue: config},\n          {provide: DialogConfig, useValue: config},\n        ],\n      },\n      templateContext: () => ({dialogRef}),\n      providers: (ref, cdkConfig, dialogContainer) => {\n        dialogRef = new this._dialogRefConstructor(ref, config, dialogContainer);\n        dialogRef.updatePosition(config?.position);\n        return [\n          {provide: this._dialogContainerType, useValue: dialogContainer},\n          {provide: this._dialogDataToken, useValue: cdkConfig.data},\n          {provide: this._dialogRefConstructor, useValue: dialogRef},\n        ];\n      },\n    });\n\n    // This can't be assigned in the `providers` callback, because\n    // the instance hasn't been assigned to the CDK ref yet.\n    (dialogRef! as {componentRef: ComponentRef<T>}).componentRef = cdkRef.componentRef!;\n    dialogRef!.componentInstance = cdkRef.componentInstance!;\n\n    this.openDialogs.push(dialogRef!);\n    this.afterOpened.next(dialogRef!);\n\n    dialogRef!.afterClosed().subscribe(() => {\n      const index = this.openDialogs.indexOf(dialogRef);\n\n      if (index > -1) {\n        this.openDialogs.splice(index, 1);\n\n        if (!this.openDialogs.length) {\n          this._getAfterAllClosed().next();\n        }\n      }\n    });\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  private _closeDialogs(dialogs: MatDialogRef<any>[]) {\n    let i = dialogs.length;\n\n    while (i--) {\n      dialogs[i].close();\n    }\n  }\n}\n"]}