source: trip-planner-front/node_modules/@angular/material/esm2015/dialog/dialog-ref.js

Last change on this file was e29cc2e, checked in by Ema <ema_spirova@…>, 3 years ago

primeNG components

  • Property mode set to 100644
File size: 25.1 KB
Line 
1/**
2 * @license
3 * Copyright Google LLC All Rights Reserved.
4 *
5 * Use of this source code is governed by an MIT-style license that can be
6 * found in the LICENSE file at https://angular.io/license
7 */
8import { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';
9import { Subject } from 'rxjs';
10import { filter, take } from 'rxjs/operators';
11// TODO(jelbourn): resizing
12// Counter for unique dialog ids.
13let uniqueId = 0;
14/**
15 * Reference to a dialog opened via the MatDialog service.
16 */
17export class MatDialogRef {
18 constructor(_overlayRef, _containerInstance,
19 /** Id of the dialog. */
20 id = `mat-dialog-${uniqueId++}`) {
21 this._overlayRef = _overlayRef;
22 this._containerInstance = _containerInstance;
23 this.id = id;
24 /** Whether the user is allowed to close the dialog. */
25 this.disableClose = this._containerInstance._config.disableClose;
26 /** Subject for notifying the user that the dialog has finished opening. */
27 this._afterOpened = new Subject();
28 /** Subject for notifying the user that the dialog has finished closing. */
29 this._afterClosed = new Subject();
30 /** Subject for notifying the user that the dialog has started closing. */
31 this._beforeClosed = new Subject();
32 /** Current state of the dialog. */
33 this._state = 0 /* OPEN */;
34 // Pass the id along to the container.
35 _containerInstance._id = id;
36 // Emit when opening animation completes
37 _containerInstance._animationStateChanged.pipe(filter(event => event.state === 'opened'), take(1))
38 .subscribe(() => {
39 this._afterOpened.next();
40 this._afterOpened.complete();
41 });
42 // Dispose overlay when closing animation is complete
43 _containerInstance._animationStateChanged.pipe(filter(event => event.state === 'closed'), take(1)).subscribe(() => {
44 clearTimeout(this._closeFallbackTimeout);
45 this._finishDialogClose();
46 });
47 _overlayRef.detachments().subscribe(() => {
48 this._beforeClosed.next(this._result);
49 this._beforeClosed.complete();
50 this._afterClosed.next(this._result);
51 this._afterClosed.complete();
52 this.componentInstance = null;
53 this._overlayRef.dispose();
54 });
55 _overlayRef.keydownEvents()
56 .pipe(filter(event => {
57 return event.keyCode === ESCAPE && !this.disableClose && !hasModifierKey(event);
58 }))
59 .subscribe(event => {
60 event.preventDefault();
61 _closeDialogVia(this, 'keyboard');
62 });
63 _overlayRef.backdropClick().subscribe(() => {
64 if (this.disableClose) {
65 this._containerInstance._recaptureFocus();
66 }
67 else {
68 _closeDialogVia(this, 'mouse');
69 }
70 });
71 }
72 /**
73 * Close the dialog.
74 * @param dialogResult Optional result to return to the dialog opener.
75 */
76 close(dialogResult) {
77 this._result = dialogResult;
78 // Transition the backdrop in parallel to the dialog.
79 this._containerInstance._animationStateChanged.pipe(filter(event => event.state === 'closing'), take(1))
80 .subscribe(event => {
81 this._beforeClosed.next(dialogResult);
82 this._beforeClosed.complete();
83 this._overlayRef.detachBackdrop();
84 // The logic that disposes of the overlay depends on the exit animation completing, however
85 // it isn't guaranteed if the parent view is destroyed while it's running. Add a fallback
86 // timeout which will clean everything up if the animation hasn't fired within the specified
87 // amount of time plus 100ms. We don't need to run this outside the NgZone, because for the
88 // vast majority of cases the timeout will have been cleared before it has the chance to fire.
89 this._closeFallbackTimeout = setTimeout(() => this._finishDialogClose(), event.totalTime + 100);
90 });
91 this._state = 1 /* CLOSING */;
92 this._containerInstance._startExitAnimation();
93 }
94 /**
95 * Gets an observable that is notified when the dialog is finished opening.
96 */
97 afterOpened() {
98 return this._afterOpened;
99 }
100 /**
101 * Gets an observable that is notified when the dialog is finished closing.
102 */
103 afterClosed() {
104 return this._afterClosed;
105 }
106 /**
107 * Gets an observable that is notified when the dialog has started closing.
108 */
109 beforeClosed() {
110 return this._beforeClosed;
111 }
112 /**
113 * Gets an observable that emits when the overlay's backdrop has been clicked.
114 */
115 backdropClick() {
116 return this._overlayRef.backdropClick();
117 }
118 /**
119 * Gets an observable that emits when keydown events are targeted on the overlay.
120 */
121 keydownEvents() {
122 return this._overlayRef.keydownEvents();
123 }
124 /**
125 * Updates the dialog's position.
126 * @param position New dialog position.
127 */
128 updatePosition(position) {
129 let strategy = this._getPositionStrategy();
130 if (position && (position.left || position.right)) {
131 position.left ? strategy.left(position.left) : strategy.right(position.right);
132 }
133 else {
134 strategy.centerHorizontally();
135 }
136 if (position && (position.top || position.bottom)) {
137 position.top ? strategy.top(position.top) : strategy.bottom(position.bottom);
138 }
139 else {
140 strategy.centerVertically();
141 }
142 this._overlayRef.updatePosition();
143 return this;
144 }
145 /**
146 * Updates the dialog's width and height.
147 * @param width New width of the dialog.
148 * @param height New height of the dialog.
149 */
150 updateSize(width = '', height = '') {
151 this._overlayRef.updateSize({ width, height });
152 this._overlayRef.updatePosition();
153 return this;
154 }
155 /** Add a CSS class or an array of classes to the overlay pane. */
156 addPanelClass(classes) {
157 this._overlayRef.addPanelClass(classes);
158 return this;
159 }
160 /** Remove a CSS class or an array of classes from the overlay pane. */
161 removePanelClass(classes) {
162 this._overlayRef.removePanelClass(classes);
163 return this;
164 }
165 /** Gets the current state of the dialog's lifecycle. */
166 getState() {
167 return this._state;
168 }
169 /**
170 * Finishes the dialog close by updating the state of the dialog
171 * and disposing the overlay.
172 */
173 _finishDialogClose() {
174 this._state = 2 /* CLOSED */;
175 this._overlayRef.dispose();
176 }
177 /** Fetches the position strategy object from the overlay ref. */
178 _getPositionStrategy() {
179 return this._overlayRef.getConfig().positionStrategy;
180 }
181}
182/**
183 * Closes the dialog with the specified interaction type. This is currently not part of
184 * `MatDialogRef` as that would conflict with custom dialog ref mocks provided in tests.
185 * More details. See: https://github.com/angular/components/pull/9257#issuecomment-651342226.
186 */
187// TODO: TODO: Move this back into `MatDialogRef` when we provide an official mock dialog ref.
188export function _closeDialogVia(ref, interactionType, result) {
189 // Some mock dialog ref instances in tests do not have the `_containerInstance` property.
190 // For those, we keep the behavior as is and do not deal with the interaction type.
191 if (ref._containerInstance !== undefined) {
192 ref._containerInstance._closeInteractionType = interactionType;
193 }
194 return ref.close(result);
195}
196//# 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\nimport {FocusOrigin} from '@angular/cdk/a11y';\nimport {ESCAPE, hasModifierKey} from '@angular/cdk/keycodes';\nimport {GlobalPositionStrategy, OverlayRef} from '@angular/cdk/overlay';\nimport {Observable, Subject} from 'rxjs';\nimport {filter, take} from 'rxjs/operators';\nimport {DialogPosition} from './dialog-config';\nimport {_MatDialogContainerBase} from './dialog-container';\n\n\n// TODO(jelbourn): resizing\n\n// Counter for unique dialog ids.\nlet uniqueId = 0;\n\n/** Possible states of the lifecycle of a dialog. */\nexport const enum MatDialogState {OPEN, CLOSING, CLOSED}\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  /** Whether the user is allowed to close the dialog. */\n  disableClose: boolean | undefined = this._containerInstance._config.disableClose;\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 finished closing. */\n  private readonly _afterClosed = new Subject<R | undefined>();\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  constructor(\n    private _overlayRef: OverlayRef,\n    public _containerInstance: _MatDialogContainerBase,\n    /** Id of the dialog. */\n    readonly id: string = `mat-dialog-${uniqueId++}`) {\n\n    // Pass the id along to the container.\n    _containerInstance._id = id;\n\n    // Emit when opening animation completes\n    _containerInstance._animationStateChanged.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.pipe(\n      filter(event => event.state === 'closed'),\n      take(1)\n    ).subscribe(() => {\n      clearTimeout(this._closeFallbackTimeout);\n      this._finishDialogClose();\n    });\n\n    _overlayRef.detachments().subscribe(() => {\n      this._beforeClosed.next(this._result);\n      this._beforeClosed.complete();\n      this._afterClosed.next(this._result);\n      this._afterClosed.complete();\n      this.componentInstance = null!;\n      this._overlayRef.dispose();\n    });\n\n    _overlayRef.keydownEvents()\n      .pipe(filter(event => {\n        return event.keyCode === ESCAPE && !this.disableClose && !hasModifierKey(event);\n      }))\n      .subscribe(event => {\n        event.preventDefault();\n        _closeDialogVia(this, 'keyboard');\n      });\n\n    _overlayRef.backdropClick().subscribe(() => {\n      if (this.disableClose) {\n        this._containerInstance._recaptureFocus();\n      } else {\n        _closeDialogVia(this, '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.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._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(() => this._finishDialogClose(),\n          event.totalTime + 100);\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._afterClosed;\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._overlayRef.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._overlayRef.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._getPositionStrategy();\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._overlayRef.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._overlayRef.updateSize({width, height});\n    this._overlayRef.updatePosition();\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._overlayRef.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._overlayRef.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._overlayRef.dispose();\n  }\n\n  /** Fetches the position strategy object from the overlay ref. */\n  private _getPositionStrategy(): GlobalPositionStrategy {\n    return this._overlayRef.getConfig().positionStrategy as GlobalPositionStrategy;\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: 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  // Some mock dialog ref instances in tests do not have the `_containerInstance` property.\n  // For those, we keep the behavior as is and do not deal with the interaction type.\n  if (ref._containerInstance !== undefined) {\n    ref._containerInstance._closeInteractionType = interactionType;\n  }\n  return ref.close(result);\n}\n"]}
Note: See TracBrowser for help on using the repository browser.