@angular/material
Version:
Angular Material
177 lines • 24.7 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 { merge, Subject } from 'rxjs';
import { filter, take } from 'rxjs/operators';
import { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';
export var MatDialogState;
(function (MatDialogState) {
MatDialogState[MatDialogState["OPEN"] = 0] = "OPEN";
MatDialogState[MatDialogState["CLOSING"] = 1] = "CLOSING";
MatDialogState[MatDialogState["CLOSED"] = 2] = "CLOSED";
})(MatDialogState || (MatDialogState = {}));
/**
* Reference to a dialog opened via the MatDialog service.
*/
export 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 = MatDialogState.OPEN;
this.disableClose = config.disableClose;
this.id = _ref.id;
// Used to target panels specifically tied to dialogs.
_ref.addPanelClass('mat-mdc-dialog-panel');
// 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 = 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 = 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.
export function _closeDialogVia(ref, interactionType, result) {
ref._closeInteractionType = interactionType;
return ref.close(result);
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog-ref.js","sourceRoot":"","sources":["../../../../../../src/material/dialog/dialog-ref.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/** Possible states of the lifecycle of a dialog. */\nimport {FocusOrigin} from '@angular/cdk/a11y';\nimport {merge, Observable, Subject} from 'rxjs';\nimport {DialogRef} from '@angular/cdk/dialog';\nimport {DialogPosition, MatDialogConfig} from './dialog-config';\nimport {MatDialogContainer} from './dialog-container';\nimport {filter, take} from 'rxjs/operators';\nimport {ESCAPE, hasModifierKey} from '@angular/cdk/keycodes';\nimport {GlobalPositionStrategy} from '@angular/cdk/overlay';\nimport {ComponentRef} from '@angular/core';\n\nexport enum MatDialogState {\n  OPEN,\n  CLOSING,\n  CLOSED,\n}\n\n/**\n * Reference to a dialog opened via the MatDialog service.\n */\nexport class MatDialogRef<T, R = any> {\n  /** The instance of component opened into the dialog. */\n  componentInstance: T;\n\n  /**\n   * `ComponentRef` of the component opened into the dialog. Will be\n   * null when the dialog is opened using a `TemplateRef`.\n   */\n  readonly componentRef: ComponentRef<T> | null;\n\n  /** Whether the user is allowed to close the dialog. */\n  disableClose: boolean | undefined;\n\n  /** Unique ID for the dialog. */\n  id: string;\n\n  /** Subject for notifying the user that the dialog has finished opening. */\n  private readonly _afterOpened = new Subject<void>();\n\n  /** Subject for notifying the user that the dialog has started closing. */\n  private readonly _beforeClosed = new Subject<R | undefined>();\n\n  /** Result to be passed to afterClosed. */\n  private _result: R | undefined;\n\n  /** Handle to the timeout that's running as a fallback in case the exit animation doesn't fire. */\n  private _closeFallbackTimeout: number;\n\n  /** Current state of the dialog. */\n  private _state = MatDialogState.OPEN;\n\n  // TODO(crisbeto): we shouldn't have to declare this property, because `DialogRef.close`\n  // already has a second `options` parameter that we can use. The problem is that internal tests\n  // have assertions like `expect(MatDialogRef.close).toHaveBeenCalledWith(foo)` which will break,\n  // because it'll be called with two arguments by things like `MatDialogClose`.\n  /** Interaction that caused the dialog to close. */\n  private _closeInteractionType: FocusOrigin | undefined;\n\n  constructor(\n    private _ref: DialogRef<R, T>,\n    config: MatDialogConfig,\n    public _containerInstance: MatDialogContainer,\n  ) {\n    this.disableClose = config.disableClose;\n    this.id = _ref.id;\n\n    // Used to target panels specifically tied to dialogs.\n    _ref.addPanelClass('mat-mdc-dialog-panel');\n\n    // Emit when opening animation completes\n    _containerInstance._animationStateChanged\n      .pipe(\n        filter(event => event.state === 'opened'),\n        take(1),\n      )\n      .subscribe(() => {\n        this._afterOpened.next();\n        this._afterOpened.complete();\n      });\n\n    // Dispose overlay when closing animation is complete\n    _containerInstance._animationStateChanged\n      .pipe(\n        filter(event => event.state === 'closed'),\n        take(1),\n      )\n      .subscribe(() => {\n        clearTimeout(this._closeFallbackTimeout);\n        this._finishDialogClose();\n      });\n\n    _ref.overlayRef.detachments().subscribe(() => {\n      this._beforeClosed.next(this._result);\n      this._beforeClosed.complete();\n      this._finishDialogClose();\n    });\n\n    merge(\n      this.backdropClick(),\n      this.keydownEvents().pipe(\n        filter(event => event.keyCode === ESCAPE && !this.disableClose && !hasModifierKey(event)),\n      ),\n    ).subscribe(event => {\n      if (!this.disableClose) {\n        event.preventDefault();\n        _closeDialogVia(this, event.type === 'keydown' ? 'keyboard' : 'mouse');\n      }\n    });\n  }\n\n  /**\n   * Close the dialog.\n   * @param dialogResult Optional result to return to the dialog opener.\n   */\n  close(dialogResult?: R): void {\n    this._result = dialogResult;\n\n    // Transition the backdrop in parallel to the dialog.\n    this._containerInstance._animationStateChanged\n      .pipe(\n        filter(event => event.state === 'closing'),\n        take(1),\n      )\n      .subscribe(event => {\n        this._beforeClosed.next(dialogResult);\n        this._beforeClosed.complete();\n        this._ref.overlayRef.detachBackdrop();\n\n        // The logic that disposes of the overlay depends on the exit animation completing, however\n        // it isn't guaranteed if the parent view is destroyed while it's running. Add a fallback\n        // timeout which will clean everything up if the animation hasn't fired within the specified\n        // amount of time plus 100ms. We don't need to run this outside the NgZone, because for the\n        // vast majority of cases the timeout will have been cleared before it has the chance to fire.\n        this._closeFallbackTimeout = setTimeout(\n          () => this._finishDialogClose(),\n          event.totalTime + 100,\n        );\n      });\n\n    this._state = MatDialogState.CLOSING;\n    this._containerInstance._startExitAnimation();\n  }\n\n  /**\n   * Gets an observable that is notified when the dialog is finished opening.\n   */\n  afterOpened(): Observable<void> {\n    return this._afterOpened;\n  }\n\n  /**\n   * Gets an observable that is notified when the dialog is finished closing.\n   */\n  afterClosed(): Observable<R | undefined> {\n    return this._ref.closed;\n  }\n\n  /**\n   * Gets an observable that is notified when the dialog has started closing.\n   */\n  beforeClosed(): Observable<R | undefined> {\n    return this._beforeClosed;\n  }\n\n  /**\n   * Gets an observable that emits when the overlay's backdrop has been clicked.\n   */\n  backdropClick(): Observable<MouseEvent> {\n    return this._ref.backdropClick;\n  }\n\n  /**\n   * Gets an observable that emits when keydown events are targeted on the overlay.\n   */\n  keydownEvents(): Observable<KeyboardEvent> {\n    return this._ref.keydownEvents;\n  }\n\n  /**\n   * Updates the dialog's position.\n   * @param position New dialog position.\n   */\n  updatePosition(position?: DialogPosition): this {\n    let strategy = this._ref.config.positionStrategy as GlobalPositionStrategy;\n\n    if (position && (position.left || position.right)) {\n      position.left ? strategy.left(position.left) : strategy.right(position.right);\n    } else {\n      strategy.centerHorizontally();\n    }\n\n    if (position && (position.top || position.bottom)) {\n      position.top ? strategy.top(position.top) : strategy.bottom(position.bottom);\n    } else {\n      strategy.centerVertically();\n    }\n\n    this._ref.updatePosition();\n\n    return this;\n  }\n\n  /**\n   * Updates the dialog's width and height.\n   * @param width New width of the dialog.\n   * @param height New height of the dialog.\n   */\n  updateSize(width: string = '', height: string = ''): this {\n    this._ref.updateSize(width, height);\n    return this;\n  }\n\n  /** Add a CSS class or an array of classes to the overlay pane. */\n  addPanelClass(classes: string | string[]): this {\n    this._ref.addPanelClass(classes);\n    return this;\n  }\n\n  /** Remove a CSS class or an array of classes from the overlay pane. */\n  removePanelClass(classes: string | string[]): this {\n    this._ref.removePanelClass(classes);\n    return this;\n  }\n\n  /** Gets the current state of the dialog's lifecycle. */\n  getState(): MatDialogState {\n    return this._state;\n  }\n\n  /**\n   * Finishes the dialog close by updating the state of the dialog\n   * and disposing the overlay.\n   */\n  private _finishDialogClose() {\n    this._state = MatDialogState.CLOSED;\n    this._ref.close(this._result, {focusOrigin: this._closeInteractionType});\n    this.componentInstance = null!;\n  }\n}\n\n/**\n * Closes the dialog with the specified interaction type. This is currently not part of\n * `MatDialogRef` as that would conflict with custom dialog ref mocks provided in tests.\n * More details. See: https://github.com/angular/components/pull/9257#issuecomment-651342226.\n */\n// TODO: Move this back into `MatDialogRef` when we provide an official mock dialog ref.\nexport function _closeDialogVia<R>(ref: MatDialogRef<R>, interactionType: FocusOrigin, result?: R) {\n  (ref as unknown as {_closeInteractionType: FocusOrigin})._closeInteractionType = interactionType;\n  return ref.close(result);\n}\n"]}