source: trip-planner-front/node_modules/@angular/cdk/esm2015/overlay/overlay-ref.js@ eed0bf8

Last change on this file since eed0bf8 was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit
  • Property mode set to 100644
File size: 55.7 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 { Subject, merge, Subscription } from 'rxjs';
9import { take, takeUntil } from 'rxjs/operators';
10import { coerceCssPixelValue, coerceArray } from '@angular/cdk/coercion';
11/**
12 * Reference to an overlay that has been created with the Overlay service.
13 * Used to manipulate or dispose of said overlay.
14 */
15export class OverlayRef {
16 constructor(_portalOutlet, _host, _pane, _config, _ngZone, _keyboardDispatcher, _document, _location, _outsideClickDispatcher) {
17 this._portalOutlet = _portalOutlet;
18 this._host = _host;
19 this._pane = _pane;
20 this._config = _config;
21 this._ngZone = _ngZone;
22 this._keyboardDispatcher = _keyboardDispatcher;
23 this._document = _document;
24 this._location = _location;
25 this._outsideClickDispatcher = _outsideClickDispatcher;
26 this._backdropElement = null;
27 this._backdropClick = new Subject();
28 this._attachments = new Subject();
29 this._detachments = new Subject();
30 this._locationChanges = Subscription.EMPTY;
31 this._backdropClickHandler = (event) => this._backdropClick.next(event);
32 /** Stream of keydown events dispatched to this overlay. */
33 this._keydownEvents = new Subject();
34 /** Stream of mouse outside events dispatched to this overlay. */
35 this._outsidePointerEvents = new Subject();
36 if (_config.scrollStrategy) {
37 this._scrollStrategy = _config.scrollStrategy;
38 this._scrollStrategy.attach(this);
39 }
40 this._positionStrategy = _config.positionStrategy;
41 }
42 /** The overlay's HTML element */
43 get overlayElement() {
44 return this._pane;
45 }
46 /** The overlay's backdrop HTML element. */
47 get backdropElement() {
48 return this._backdropElement;
49 }
50 /**
51 * Wrapper around the panel element. Can be used for advanced
52 * positioning where a wrapper with specific styling is
53 * required around the overlay pane.
54 */
55 get hostElement() {
56 return this._host;
57 }
58 /**
59 * Attaches content, given via a Portal, to the overlay.
60 * If the overlay is configured to have a backdrop, it will be created.
61 *
62 * @param portal Portal instance to which to attach the overlay.
63 * @returns The portal attachment result.
64 */
65 attach(portal) {
66 let attachResult = this._portalOutlet.attach(portal);
67 // Update the pane element with the given configuration.
68 if (!this._host.parentElement && this._previousHostParent) {
69 this._previousHostParent.appendChild(this._host);
70 }
71 if (this._positionStrategy) {
72 this._positionStrategy.attach(this);
73 }
74 this._updateStackingOrder();
75 this._updateElementSize();
76 this._updateElementDirection();
77 if (this._scrollStrategy) {
78 this._scrollStrategy.enable();
79 }
80 // Update the position once the zone is stable so that the overlay will be fully rendered
81 // before attempting to position it, as the position may depend on the size of the rendered
82 // content.
83 this._ngZone.onStable
84 .pipe(take(1))
85 .subscribe(() => {
86 // The overlay could've been detached before the zone has stabilized.
87 if (this.hasAttached()) {
88 this.updatePosition();
89 }
90 });
91 // Enable pointer events for the overlay pane element.
92 this._togglePointerEvents(true);
93 if (this._config.hasBackdrop) {
94 this._attachBackdrop();
95 }
96 if (this._config.panelClass) {
97 this._toggleClasses(this._pane, this._config.panelClass, true);
98 }
99 // Only emit the `attachments` event once all other setup is done.
100 this._attachments.next();
101 // Track this overlay by the keyboard dispatcher
102 this._keyboardDispatcher.add(this);
103 if (this._config.disposeOnNavigation) {
104 this._locationChanges = this._location.subscribe(() => this.dispose());
105 }
106 this._outsideClickDispatcher.add(this);
107 return attachResult;
108 }
109 /**
110 * Detaches an overlay from a portal.
111 * @returns The portal detachment result.
112 */
113 detach() {
114 if (!this.hasAttached()) {
115 return;
116 }
117 this.detachBackdrop();
118 // When the overlay is detached, the pane element should disable pointer events.
119 // This is necessary because otherwise the pane element will cover the page and disable
120 // pointer events therefore. Depends on the position strategy and the applied pane boundaries.
121 this._togglePointerEvents(false);
122 if (this._positionStrategy && this._positionStrategy.detach) {
123 this._positionStrategy.detach();
124 }
125 if (this._scrollStrategy) {
126 this._scrollStrategy.disable();
127 }
128 const detachmentResult = this._portalOutlet.detach();
129 // Only emit after everything is detached.
130 this._detachments.next();
131 // Remove this overlay from keyboard dispatcher tracking.
132 this._keyboardDispatcher.remove(this);
133 // Keeping the host element in the DOM can cause scroll jank, because it still gets
134 // rendered, even though it's transparent and unclickable which is why we remove it.
135 this._detachContentWhenStable();
136 this._locationChanges.unsubscribe();
137 this._outsideClickDispatcher.remove(this);
138 return detachmentResult;
139 }
140 /** Cleans up the overlay from the DOM. */
141 dispose() {
142 const isAttached = this.hasAttached();
143 if (this._positionStrategy) {
144 this._positionStrategy.dispose();
145 }
146 this._disposeScrollStrategy();
147 this._disposeBackdrop(this._backdropElement);
148 this._locationChanges.unsubscribe();
149 this._keyboardDispatcher.remove(this);
150 this._portalOutlet.dispose();
151 this._attachments.complete();
152 this._backdropClick.complete();
153 this._keydownEvents.complete();
154 this._outsidePointerEvents.complete();
155 this._outsideClickDispatcher.remove(this);
156 if (this._host && this._host.parentNode) {
157 this._host.parentNode.removeChild(this._host);
158 this._host = null;
159 }
160 this._previousHostParent = this._pane = null;
161 if (isAttached) {
162 this._detachments.next();
163 }
164 this._detachments.complete();
165 }
166 /** Whether the overlay has attached content. */
167 hasAttached() {
168 return this._portalOutlet.hasAttached();
169 }
170 /** Gets an observable that emits when the backdrop has been clicked. */
171 backdropClick() {
172 return this._backdropClick;
173 }
174 /** Gets an observable that emits when the overlay has been attached. */
175 attachments() {
176 return this._attachments;
177 }
178 /** Gets an observable that emits when the overlay has been detached. */
179 detachments() {
180 return this._detachments;
181 }
182 /** Gets an observable of keydown events targeted to this overlay. */
183 keydownEvents() {
184 return this._keydownEvents;
185 }
186 /** Gets an observable of pointer events targeted outside this overlay. */
187 outsidePointerEvents() {
188 return this._outsidePointerEvents;
189 }
190 /** Gets the current overlay configuration, which is immutable. */
191 getConfig() {
192 return this._config;
193 }
194 /** Updates the position of the overlay based on the position strategy. */
195 updatePosition() {
196 if (this._positionStrategy) {
197 this._positionStrategy.apply();
198 }
199 }
200 /** Switches to a new position strategy and updates the overlay position. */
201 updatePositionStrategy(strategy) {
202 if (strategy === this._positionStrategy) {
203 return;
204 }
205 if (this._positionStrategy) {
206 this._positionStrategy.dispose();
207 }
208 this._positionStrategy = strategy;
209 if (this.hasAttached()) {
210 strategy.attach(this);
211 this.updatePosition();
212 }
213 }
214 /** Update the size properties of the overlay. */
215 updateSize(sizeConfig) {
216 this._config = Object.assign(Object.assign({}, this._config), sizeConfig);
217 this._updateElementSize();
218 }
219 /** Sets the LTR/RTL direction for the overlay. */
220 setDirection(dir) {
221 this._config = Object.assign(Object.assign({}, this._config), { direction: dir });
222 this._updateElementDirection();
223 }
224 /** Add a CSS class or an array of classes to the overlay pane. */
225 addPanelClass(classes) {
226 if (this._pane) {
227 this._toggleClasses(this._pane, classes, true);
228 }
229 }
230 /** Remove a CSS class or an array of classes from the overlay pane. */
231 removePanelClass(classes) {
232 if (this._pane) {
233 this._toggleClasses(this._pane, classes, false);
234 }
235 }
236 /**
237 * Returns the layout direction of the overlay panel.
238 */
239 getDirection() {
240 const direction = this._config.direction;
241 if (!direction) {
242 return 'ltr';
243 }
244 return typeof direction === 'string' ? direction : direction.value;
245 }
246 /** Switches to a new scroll strategy. */
247 updateScrollStrategy(strategy) {
248 if (strategy === this._scrollStrategy) {
249 return;
250 }
251 this._disposeScrollStrategy();
252 this._scrollStrategy = strategy;
253 if (this.hasAttached()) {
254 strategy.attach(this);
255 strategy.enable();
256 }
257 }
258 /** Updates the text direction of the overlay panel. */
259 _updateElementDirection() {
260 this._host.setAttribute('dir', this.getDirection());
261 }
262 /** Updates the size of the overlay element based on the overlay config. */
263 _updateElementSize() {
264 if (!this._pane) {
265 return;
266 }
267 const style = this._pane.style;
268 style.width = coerceCssPixelValue(this._config.width);
269 style.height = coerceCssPixelValue(this._config.height);
270 style.minWidth = coerceCssPixelValue(this._config.minWidth);
271 style.minHeight = coerceCssPixelValue(this._config.minHeight);
272 style.maxWidth = coerceCssPixelValue(this._config.maxWidth);
273 style.maxHeight = coerceCssPixelValue(this._config.maxHeight);
274 }
275 /** Toggles the pointer events for the overlay pane element. */
276 _togglePointerEvents(enablePointer) {
277 this._pane.style.pointerEvents = enablePointer ? '' : 'none';
278 }
279 /** Attaches a backdrop for this overlay. */
280 _attachBackdrop() {
281 const showingClass = 'cdk-overlay-backdrop-showing';
282 this._backdropElement = this._document.createElement('div');
283 this._backdropElement.classList.add('cdk-overlay-backdrop');
284 if (this._config.backdropClass) {
285 this._toggleClasses(this._backdropElement, this._config.backdropClass, true);
286 }
287 // Insert the backdrop before the pane in the DOM order,
288 // in order to handle stacked overlays properly.
289 this._host.parentElement.insertBefore(this._backdropElement, this._host);
290 // Forward backdrop clicks such that the consumer of the overlay can perform whatever
291 // action desired when such a click occurs (usually closing the overlay).
292 this._backdropElement.addEventListener('click', this._backdropClickHandler);
293 // Add class to fade-in the backdrop after one frame.
294 if (typeof requestAnimationFrame !== 'undefined') {
295 this._ngZone.runOutsideAngular(() => {
296 requestAnimationFrame(() => {
297 if (this._backdropElement) {
298 this._backdropElement.classList.add(showingClass);
299 }
300 });
301 });
302 }
303 else {
304 this._backdropElement.classList.add(showingClass);
305 }
306 }
307 /**
308 * Updates the stacking order of the element, moving it to the top if necessary.
309 * This is required in cases where one overlay was detached, while another one,
310 * that should be behind it, was destroyed. The next time both of them are opened,
311 * the stacking will be wrong, because the detached element's pane will still be
312 * in its original DOM position.
313 */
314 _updateStackingOrder() {
315 if (this._host.nextSibling) {
316 this._host.parentNode.appendChild(this._host);
317 }
318 }
319 /** Detaches the backdrop (if any) associated with the overlay. */
320 detachBackdrop() {
321 const backdropToDetach = this._backdropElement;
322 if (!backdropToDetach) {
323 return;
324 }
325 let timeoutId;
326 const finishDetach = () => {
327 // It may not be attached to anything in certain cases (e.g. unit tests).
328 if (backdropToDetach) {
329 backdropToDetach.removeEventListener('click', this._backdropClickHandler);
330 backdropToDetach.removeEventListener('transitionend', finishDetach);
331 this._disposeBackdrop(backdropToDetach);
332 }
333 if (this._config.backdropClass) {
334 this._toggleClasses(backdropToDetach, this._config.backdropClass, false);
335 }
336 clearTimeout(timeoutId);
337 };
338 backdropToDetach.classList.remove('cdk-overlay-backdrop-showing');
339 this._ngZone.runOutsideAngular(() => {
340 backdropToDetach.addEventListener('transitionend', finishDetach);
341 });
342 // If the backdrop doesn't have a transition, the `transitionend` event won't fire.
343 // In this case we make it unclickable and we try to remove it after a delay.
344 backdropToDetach.style.pointerEvents = 'none';
345 // Run this outside the Angular zone because there's nothing that Angular cares about.
346 // If it were to run inside the Angular zone, every test that used Overlay would have to be
347 // either async or fakeAsync.
348 timeoutId = this._ngZone.runOutsideAngular(() => setTimeout(finishDetach, 500));
349 }
350 /** Toggles a single CSS class or an array of classes on an element. */
351 _toggleClasses(element, cssClasses, isAdd) {
352 const classList = element.classList;
353 coerceArray(cssClasses).forEach(cssClass => {
354 // We can't do a spread here, because IE doesn't support setting multiple classes.
355 // Also trying to add an empty string to a DOMTokenList will throw.
356 if (cssClass) {
357 isAdd ? classList.add(cssClass) : classList.remove(cssClass);
358 }
359 });
360 }
361 /** Detaches the overlay content next time the zone stabilizes. */
362 _detachContentWhenStable() {
363 // Normally we wouldn't have to explicitly run this outside the `NgZone`, however
364 // if the consumer is using `zone-patch-rxjs`, the `Subscription.unsubscribe` call will
365 // be patched to run inside the zone, which will throw us into an infinite loop.
366 this._ngZone.runOutsideAngular(() => {
367 // We can't remove the host here immediately, because the overlay pane's content
368 // might still be animating. This stream helps us avoid interrupting the animation
369 // by waiting for the pane to become empty.
370 const subscription = this._ngZone.onStable
371 .pipe(takeUntil(merge(this._attachments, this._detachments)))
372 .subscribe(() => {
373 // Needs a couple of checks for the pane and host, because
374 // they may have been removed by the time the zone stabilizes.
375 if (!this._pane || !this._host || this._pane.children.length === 0) {
376 if (this._pane && this._config.panelClass) {
377 this._toggleClasses(this._pane, this._config.panelClass, false);
378 }
379 if (this._host && this._host.parentElement) {
380 this._previousHostParent = this._host.parentElement;
381 this._previousHostParent.removeChild(this._host);
382 }
383 subscription.unsubscribe();
384 }
385 });
386 });
387 }
388 /** Disposes of a scroll strategy. */
389 _disposeScrollStrategy() {
390 const scrollStrategy = this._scrollStrategy;
391 if (scrollStrategy) {
392 scrollStrategy.disable();
393 if (scrollStrategy.detach) {
394 scrollStrategy.detach();
395 }
396 }
397 }
398 /** Removes a backdrop element from the DOM. */
399 _disposeBackdrop(backdrop) {
400 if (backdrop) {
401 if (backdrop.parentNode) {
402 backdrop.parentNode.removeChild(backdrop);
403 }
404 // It is possible that a new portal has been attached to this overlay since we started
405 // removing the backdrop. If that is the case, only clear the backdrop reference if it
406 // is still the same instance that we started to remove.
407 if (this._backdropElement === backdrop) {
408 this._backdropElement = null;
409 }
410 }
411 }
412}
413//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay-ref.js","sourceRoot":"","sources":["../../../../../../src/cdk/overlay/overlay-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 {Direction, Directionality} from '@angular/cdk/bidi';\nimport {ComponentPortal, Portal, PortalOutlet, TemplatePortal} from '@angular/cdk/portal';\nimport {ComponentRef, EmbeddedViewRef, NgZone} from '@angular/core';\nimport {Location} from '@angular/common';\nimport {Observable, Subject, merge, SubscriptionLike, Subscription} from 'rxjs';\nimport {take, takeUntil} from 'rxjs/operators';\nimport {OverlayKeyboardDispatcher} from './dispatchers/overlay-keyboard-dispatcher';\nimport {OverlayOutsideClickDispatcher} from './dispatchers/overlay-outside-click-dispatcher';\nimport {OverlayConfig} from './overlay-config';\nimport {coerceCssPixelValue, coerceArray} from '@angular/cdk/coercion';\nimport {OverlayReference} from './overlay-reference';\nimport {PositionStrategy} from './position/position-strategy';\nimport {ScrollStrategy} from './scroll';\n\n\n/** An object where all of its properties cannot be written. */\nexport type ImmutableObject<T> = {\n  readonly [P in keyof T]: T[P];\n};\n\n/**\n * Reference to an overlay that has been created with the Overlay service.\n * Used to manipulate or dispose of said overlay.\n */\nexport class OverlayRef implements PortalOutlet, OverlayReference {\n  private _backdropElement: HTMLElement | null = null;\n  private readonly _backdropClick = new Subject<MouseEvent>();\n  private readonly _attachments = new Subject<void>();\n  private readonly _detachments = new Subject<void>();\n  private _positionStrategy: PositionStrategy | undefined;\n  private _scrollStrategy: ScrollStrategy | undefined;\n  private _locationChanges: SubscriptionLike = Subscription.EMPTY;\n  private _backdropClickHandler = (event: MouseEvent) => this._backdropClick.next(event);\n\n  /**\n   * Reference to the parent of the `_host` at the time it was detached. Used to restore\n   * the `_host` to its original position in the DOM when it gets re-attached.\n   */\n  private _previousHostParent: HTMLElement;\n\n  /** Stream of keydown events dispatched to this overlay. */\n  readonly _keydownEvents = new Subject<KeyboardEvent>();\n\n  /** Stream of mouse outside events dispatched to this overlay. */\n  readonly _outsidePointerEvents = new Subject<MouseEvent>();\n\n  constructor(\n      private _portalOutlet: PortalOutlet,\n      private _host: HTMLElement,\n      private _pane: HTMLElement,\n      private _config: ImmutableObject<OverlayConfig>,\n      private _ngZone: NgZone,\n      private _keyboardDispatcher: OverlayKeyboardDispatcher,\n      private _document: Document,\n      private _location: Location,\n      private _outsideClickDispatcher: OverlayOutsideClickDispatcher) {\n\n    if (_config.scrollStrategy) {\n      this._scrollStrategy = _config.scrollStrategy;\n      this._scrollStrategy.attach(this);\n    }\n\n    this._positionStrategy = _config.positionStrategy;\n  }\n\n  /** The overlay's HTML element */\n  get overlayElement(): HTMLElement {\n    return this._pane;\n  }\n\n  /** The overlay's backdrop HTML element. */\n  get backdropElement(): HTMLElement | null {\n    return this._backdropElement;\n  }\n\n  /**\n   * Wrapper around the panel element. Can be used for advanced\n   * positioning where a wrapper with specific styling is\n   * required around the overlay pane.\n   */\n  get hostElement(): HTMLElement {\n    return this._host;\n  }\n\n  attach<T>(portal: ComponentPortal<T>): ComponentRef<T>;\n  attach<T>(portal: TemplatePortal<T>): EmbeddedViewRef<T>;\n  attach(portal: any): any;\n\n  /**\n   * Attaches content, given via a Portal, to the overlay.\n   * If the overlay is configured to have a backdrop, it will be created.\n   *\n   * @param portal Portal instance to which to attach the overlay.\n   * @returns The portal attachment result.\n   */\n  attach(portal: Portal<any>): any {\n    let attachResult = this._portalOutlet.attach(portal);\n\n    // Update the pane element with the given configuration.\n    if (!this._host.parentElement && this._previousHostParent) {\n      this._previousHostParent.appendChild(this._host);\n    }\n\n    if (this._positionStrategy) {\n      this._positionStrategy.attach(this);\n    }\n\n    this._updateStackingOrder();\n    this._updateElementSize();\n    this._updateElementDirection();\n\n    if (this._scrollStrategy) {\n      this._scrollStrategy.enable();\n    }\n\n    // Update the position once the zone is stable so that the overlay will be fully rendered\n    // before attempting to position it, as the position may depend on the size of the rendered\n    // content.\n    this._ngZone.onStable\n      .pipe(take(1))\n      .subscribe(() => {\n        // The overlay could've been detached before the zone has stabilized.\n        if (this.hasAttached()) {\n          this.updatePosition();\n        }\n      });\n\n    // Enable pointer events for the overlay pane element.\n    this._togglePointerEvents(true);\n\n    if (this._config.hasBackdrop) {\n      this._attachBackdrop();\n    }\n\n    if (this._config.panelClass) {\n      this._toggleClasses(this._pane, this._config.panelClass, true);\n    }\n\n    // Only emit the `attachments` event once all other setup is done.\n    this._attachments.next();\n\n    // Track this overlay by the keyboard dispatcher\n    this._keyboardDispatcher.add(this);\n\n    if (this._config.disposeOnNavigation) {\n      this._locationChanges = this._location.subscribe(() => this.dispose());\n    }\n\n    this._outsideClickDispatcher.add(this);\n    return attachResult;\n  }\n\n  /**\n   * Detaches an overlay from a portal.\n   * @returns The portal detachment result.\n   */\n  detach(): any {\n    if (!this.hasAttached()) {\n      return;\n    }\n\n    this.detachBackdrop();\n\n    // When the overlay is detached, the pane element should disable pointer events.\n    // This is necessary because otherwise the pane element will cover the page and disable\n    // pointer events therefore. Depends on the position strategy and the applied pane boundaries.\n    this._togglePointerEvents(false);\n\n    if (this._positionStrategy && this._positionStrategy.detach) {\n      this._positionStrategy.detach();\n    }\n\n    if (this._scrollStrategy) {\n      this._scrollStrategy.disable();\n    }\n\n    const detachmentResult = this._portalOutlet.detach();\n\n    // Only emit after everything is detached.\n    this._detachments.next();\n\n    // Remove this overlay from keyboard dispatcher tracking.\n    this._keyboardDispatcher.remove(this);\n\n    // Keeping the host element in the DOM can cause scroll jank, because it still gets\n    // rendered, even though it's transparent and unclickable which is why we remove it.\n    this._detachContentWhenStable();\n    this._locationChanges.unsubscribe();\n    this._outsideClickDispatcher.remove(this);\n    return detachmentResult;\n  }\n\n  /** Cleans up the overlay from the DOM. */\n  dispose(): void {\n    const isAttached = this.hasAttached();\n\n    if (this._positionStrategy) {\n      this._positionStrategy.dispose();\n    }\n\n    this._disposeScrollStrategy();\n    this._disposeBackdrop(this._backdropElement);\n    this._locationChanges.unsubscribe();\n    this._keyboardDispatcher.remove(this);\n    this._portalOutlet.dispose();\n    this._attachments.complete();\n    this._backdropClick.complete();\n    this._keydownEvents.complete();\n    this._outsidePointerEvents.complete();\n    this._outsideClickDispatcher.remove(this);\n\n    if (this._host && this._host.parentNode) {\n      this._host.parentNode.removeChild(this._host);\n      this._host = null!;\n    }\n\n    this._previousHostParent = this._pane = null!;\n\n    if (isAttached) {\n      this._detachments.next();\n    }\n\n    this._detachments.complete();\n  }\n\n  /** Whether the overlay has attached content. */\n  hasAttached(): boolean {\n    return this._portalOutlet.hasAttached();\n  }\n\n  /** Gets an observable that emits when the backdrop has been clicked. */\n  backdropClick(): Observable<MouseEvent> {\n    return this._backdropClick;\n  }\n\n  /** Gets an observable that emits when the overlay has been attached. */\n  attachments(): Observable<void> {\n    return this._attachments;\n  }\n\n  /** Gets an observable that emits when the overlay has been detached. */\n  detachments(): Observable<void> {\n    return this._detachments;\n  }\n\n  /** Gets an observable of keydown events targeted to this overlay. */\n  keydownEvents(): Observable<KeyboardEvent> {\n    return this._keydownEvents;\n  }\n\n  /** Gets an observable of pointer events targeted outside this overlay. */\n  outsidePointerEvents(): Observable<MouseEvent> {\n    return this._outsidePointerEvents;\n  }\n\n  /** Gets the current overlay configuration, which is immutable. */\n  getConfig(): OverlayConfig {\n    return this._config;\n  }\n\n  /** Updates the position of the overlay based on the position strategy. */\n  updatePosition(): void {\n    if (this._positionStrategy) {\n      this._positionStrategy.apply();\n    }\n  }\n\n  /** Switches to a new position strategy and updates the overlay position. */\n  updatePositionStrategy(strategy: PositionStrategy): void {\n    if (strategy === this._positionStrategy) {\n      return;\n    }\n\n    if (this._positionStrategy) {\n      this._positionStrategy.dispose();\n    }\n\n    this._positionStrategy = strategy;\n\n    if (this.hasAttached()) {\n      strategy.attach(this);\n      this.updatePosition();\n    }\n  }\n\n  /** Update the size properties of the overlay. */\n  updateSize(sizeConfig: OverlaySizeConfig): void {\n    this._config = {...this._config, ...sizeConfig};\n    this._updateElementSize();\n  }\n\n  /** Sets the LTR/RTL direction for the overlay. */\n  setDirection(dir: Direction | Directionality): void {\n    this._config = {...this._config, direction: dir};\n    this._updateElementDirection();\n  }\n\n  /** Add a CSS class or an array of classes to the overlay pane. */\n  addPanelClass(classes: string | string[]): void {\n    if (this._pane) {\n      this._toggleClasses(this._pane, classes, true);\n    }\n  }\n\n  /** Remove a CSS class or an array of classes from the overlay pane. */\n  removePanelClass(classes: string | string[]): void {\n    if (this._pane) {\n      this._toggleClasses(this._pane, classes, false);\n    }\n  }\n\n  /**\n   * Returns the layout direction of the overlay panel.\n   */\n  getDirection(): Direction {\n    const direction = this._config.direction;\n\n    if (!direction) {\n      return 'ltr';\n    }\n\n    return typeof direction === 'string' ? direction : direction.value;\n  }\n\n  /** Switches to a new scroll strategy. */\n  updateScrollStrategy(strategy: ScrollStrategy): void {\n    if (strategy === this._scrollStrategy) {\n      return;\n    }\n\n    this._disposeScrollStrategy();\n    this._scrollStrategy = strategy;\n\n    if (this.hasAttached()) {\n      strategy.attach(this);\n      strategy.enable();\n    }\n  }\n\n  /** Updates the text direction of the overlay panel. */\n  private _updateElementDirection() {\n    this._host.setAttribute('dir', this.getDirection());\n  }\n\n  /** Updates the size of the overlay element based on the overlay config. */\n  private _updateElementSize() {\n    if (!this._pane) {\n      return;\n    }\n\n    const style = this._pane.style;\n\n    style.width = coerceCssPixelValue(this._config.width);\n    style.height = coerceCssPixelValue(this._config.height);\n    style.minWidth = coerceCssPixelValue(this._config.minWidth);\n    style.minHeight = coerceCssPixelValue(this._config.minHeight);\n    style.maxWidth = coerceCssPixelValue(this._config.maxWidth);\n    style.maxHeight = coerceCssPixelValue(this._config.maxHeight);\n  }\n\n  /** Toggles the pointer events for the overlay pane element. */\n  private _togglePointerEvents(enablePointer: boolean) {\n    this._pane.style.pointerEvents = enablePointer ? '' : 'none';\n  }\n\n  /** Attaches a backdrop for this overlay. */\n  private _attachBackdrop() {\n    const showingClass = 'cdk-overlay-backdrop-showing';\n\n    this._backdropElement = this._document.createElement('div');\n    this._backdropElement.classList.add('cdk-overlay-backdrop');\n\n    if (this._config.backdropClass) {\n      this._toggleClasses(this._backdropElement, this._config.backdropClass, true);\n    }\n\n    // Insert the backdrop before the pane in the DOM order,\n    // in order to handle stacked overlays properly.\n    this._host.parentElement!.insertBefore(this._backdropElement, this._host);\n\n    // Forward backdrop clicks such that the consumer of the overlay can perform whatever\n    // action desired when such a click occurs (usually closing the overlay).\n    this._backdropElement.addEventListener('click', this._backdropClickHandler);\n\n    // Add class to fade-in the backdrop after one frame.\n    if (typeof requestAnimationFrame !== 'undefined') {\n      this._ngZone.runOutsideAngular(() => {\n        requestAnimationFrame(() => {\n          if (this._backdropElement) {\n            this._backdropElement.classList.add(showingClass);\n          }\n        });\n      });\n    } else {\n      this._backdropElement.classList.add(showingClass);\n    }\n  }\n\n  /**\n   * Updates the stacking order of the element, moving it to the top if necessary.\n   * This is required in cases where one overlay was detached, while another one,\n   * that should be behind it, was destroyed. The next time both of them are opened,\n   * the stacking will be wrong, because the detached element's pane will still be\n   * in its original DOM position.\n   */\n  private _updateStackingOrder() {\n    if (this._host.nextSibling) {\n      this._host.parentNode!.appendChild(this._host);\n    }\n  }\n\n  /** Detaches the backdrop (if any) associated with the overlay. */\n  detachBackdrop(): void {\n    const backdropToDetach = this._backdropElement;\n\n    if (!backdropToDetach) {\n      return;\n    }\n\n    let timeoutId: any;\n    const finishDetach = () => {\n      // It may not be attached to anything in certain cases (e.g. unit tests).\n      if (backdropToDetach) {\n        backdropToDetach.removeEventListener('click', this._backdropClickHandler);\n        backdropToDetach.removeEventListener('transitionend', finishDetach);\n        this._disposeBackdrop(backdropToDetach);\n      }\n\n      if (this._config.backdropClass) {\n        this._toggleClasses(backdropToDetach!, this._config.backdropClass, false);\n      }\n\n      clearTimeout(timeoutId);\n    };\n\n    backdropToDetach.classList.remove('cdk-overlay-backdrop-showing');\n\n    this._ngZone.runOutsideAngular(() => {\n      backdropToDetach!.addEventListener('transitionend', finishDetach);\n    });\n\n    // If the backdrop doesn't have a transition, the `transitionend` event won't fire.\n    // In this case we make it unclickable and we try to remove it after a delay.\n    backdropToDetach.style.pointerEvents = 'none';\n\n    // Run this outside the Angular zone because there's nothing that Angular cares about.\n    // If it were to run inside the Angular zone, every test that used Overlay would have to be\n    // either async or fakeAsync.\n    timeoutId = this._ngZone.runOutsideAngular(() => setTimeout(finishDetach, 500));\n  }\n\n  /** Toggles a single CSS class or an array of classes on an element. */\n  private _toggleClasses(element: HTMLElement, cssClasses: string | string[], isAdd: boolean) {\n    const classList = element.classList;\n\n    coerceArray(cssClasses).forEach(cssClass => {\n      // We can't do a spread here, because IE doesn't support setting multiple classes.\n      // Also trying to add an empty string to a DOMTokenList will throw.\n      if (cssClass) {\n        isAdd ? classList.add(cssClass) : classList.remove(cssClass);\n      }\n    });\n  }\n\n  /** Detaches the overlay content next time the zone stabilizes. */\n  private _detachContentWhenStable() {\n    // Normally we wouldn't have to explicitly run this outside the `NgZone`, however\n    // if the consumer is using `zone-patch-rxjs`, the `Subscription.unsubscribe` call will\n    // be patched to run inside the zone, which will throw us into an infinite loop.\n    this._ngZone.runOutsideAngular(() => {\n      // We can't remove the host here immediately, because the overlay pane's content\n      // might still be animating. This stream helps us avoid interrupting the animation\n      // by waiting for the pane to become empty.\n      const subscription = this._ngZone.onStable\n        .pipe(takeUntil(merge(this._attachments, this._detachments)))\n        .subscribe(() => {\n          // Needs a couple of checks for the pane and host, because\n          // they may have been removed by the time the zone stabilizes.\n          if (!this._pane || !this._host || this._pane.children.length === 0) {\n            if (this._pane && this._config.panelClass) {\n              this._toggleClasses(this._pane, this._config.panelClass, false);\n            }\n\n            if (this._host && this._host.parentElement) {\n              this._previousHostParent = this._host.parentElement;\n              this._previousHostParent.removeChild(this._host);\n            }\n\n            subscription.unsubscribe();\n          }\n        });\n    });\n  }\n\n  /** Disposes of a scroll strategy. */\n  private _disposeScrollStrategy() {\n    const scrollStrategy = this._scrollStrategy;\n\n    if (scrollStrategy) {\n      scrollStrategy.disable();\n\n      if (scrollStrategy.detach) {\n        scrollStrategy.detach();\n      }\n    }\n  }\n\n  /** Removes a backdrop element from the DOM. */\n  private _disposeBackdrop(backdrop: HTMLElement | null) {\n    if (backdrop) {\n      if (backdrop.parentNode) {\n        backdrop.parentNode.removeChild(backdrop);\n      }\n\n      // It is possible that a new portal has been attached to this overlay since we started\n      // removing the backdrop. If that is the case, only clear the backdrop reference if it\n      // is still the same instance that we started to remove.\n      if (this._backdropElement === backdrop) {\n        this._backdropElement = null;\n      }\n    }\n  }\n}\n\n\n/** Size properties for an overlay. */\nexport interface OverlaySizeConfig {\n  width?: number | string;\n  height?: number | string;\n  minWidth?: number | string;\n  minHeight?: number | string;\n  maxWidth?: number | string;\n  maxHeight?: number | string;\n}\n"]}
Note: See TracBrowser for help on using the repository browser.