@ethlete/cdk 3.10.0 → 3.11.0

package/esm2022/lib/components/overlay/components/overlay/services/overlay.service.mjs

@@ -5,7 +5,7 @@ import { ViewportService, createDestroy, equal } from '@ethlete/core';
 import { Subject, combineLatest, defer, map, of, pairwise, startWith, takeUntil, tap } from 'rxjs';
 import { OverlayContainerComponent } from '../components';
 import { OVERLAY_CONFIG, OVERLAY_DATA, OVERLAY_DEFAULT_OPTIONS, OVERLAY_SCROLL_STRATEGY } from '../constants';
-import { OverlayPositionBuilder, OverlayRef, createOverlayConfig } from '../utils';
+import { ET_OVERLAY_BOTTOM_SHEET_CLASS, ET_OVERLAY_LEFT_SHEET_CLASS, ET_OVERLAY_RIGHT_SHEET_CLASS, ET_OVERLAY_TOP_SHEET_CLASS, OverlayPositionBuilder, OverlayRef, createOverlayConfig, } from '../utils';
 import * as i0 from "@angular/core";
 let uniqueId = 0;
 const ID_PREFIX = 'et-overlay-';
@@ -71,6 +71,7 @@ export class OverlayService {
             ...composedConfig,
             disableClose: true,
             closeOnDestroy: false,
+            panelClass: 'et-overlay-pane',
             container: {
                 type: OverlayContainerComponent,
                 providers: () => [
@@ -85,6 +86,7 @@ export class OverlayService {
                     { provide: OverlayContainerComponent, useValue: overlayContainer },
                     { provide: OVERLAY_DATA, useValue: cdkConfig.data },
                     { provide: OverlayRef, useValue: overlayRef },
+                    ...(composedConfig.providers ?? []),
                 ];
             },
         });
@@ -92,59 +94,119 @@ export class OverlayService {
         overlayRef.componentRef = cdkRef.componentRef;
         overlayRef.componentInstance = cdkRef.componentInstance;
         cdkRef.containerInstance.overlayRef = overlayRef;
-        if (composedConfig.positions?.length) {
-            combineLatest(composedConfig.positions.map((breakpoint) => (breakpoint.breakpoint ? this._viewportService.observe({ min: breakpoint.breakpoint }) : of(true)).pipe(map((isActive) => ({
-                isActive,
-                config: breakpoint.config,
-                size: typeof breakpoint.breakpoint === 'number'
-                    ? breakpoint.breakpoint
-                    : breakpoint.breakpoint === undefined
-                        ? 0
-                        : this._viewportService.getBreakpointSize(breakpoint.breakpoint, 'min'),
-            })))))
-                .pipe(takeUntil(overlayRef.afterClosed()), takeUntil(this._destroy$), map((entries) => {
-                const activeBreakpoints = entries.filter((entry) => entry.isActive);
-                const highestBreakpoint = activeBreakpoints.reduce((prev, curr) => (prev.size > curr.size ? prev : curr));
-                return highestBreakpoint.config;
-            }), startWith(null), pairwise(), tap(([prevConfig, currConfig]) => {
-                if (!currConfig)
-                    return;
-                const overlayPaneEl = cdkRef.overlayRef.overlayElement;
-                const containerEl = overlayRef._containerInstance.elementRef.nativeElement;
-                const backdropEl = cdkRef.overlayRef.backdropElement;
-                const overlayWrapper = cdkRef.overlayRef.hostElement;
-                setStyle(overlayPaneEl, 'min-width', currConfig.minWidth);
-                setStyle(overlayPaneEl, 'min-height', currConfig.minHeight);
+        combineLatest(composedConfig.positions.map((breakpoint) => (breakpoint.breakpoint ? this._viewportService.observe({ min: breakpoint.breakpoint }) : of(true)).pipe(map((isActive) => ({
+            isActive,
+            config: breakpoint.config,
+            size: typeof breakpoint.breakpoint === 'number'
+                ? breakpoint.breakpoint
+                : breakpoint.breakpoint === undefined
+                    ? 0
+                    : this._viewportService.getBreakpointSize(breakpoint.breakpoint, 'min'),
+        })))))
+            .pipe(takeUntil(overlayRef.afterClosed()), takeUntil(this._destroy$), map((entries) => {
+            const activeBreakpoints = entries.filter((entry) => entry.isActive);
+            const highestBreakpoint = activeBreakpoints.reduce((prev, curr) => (prev.size > curr.size ? prev : curr));
+            return highestBreakpoint.config;
+        }), startWith(null), pairwise(), tap(([prevConfig, currConfig]) => {
+            if (!currConfig)
+                return;
+            const overlayPaneEl = cdkRef.overlayRef.overlayElement;
+            const containerEl = overlayRef._containerInstance.elementRef.nativeElement;
+            const backdropEl = cdkRef.overlayRef.backdropElement;
+            const overlayWrapper = cdkRef.overlayRef.hostElement;
+            const defaultAnimationBuffer = 50; // 50px since the default animation uses spring physics and thus will overshoot.
+            const useDefaultAnimation = composedConfig.customAnimated !== true;
+            const containerClass = currConfig.containerClass;
+            const applyDefaultMaxWidths = () => {
                 setStyle(overlayPaneEl, 'max-width', currConfig.maxWidth);
                 setStyle(overlayPaneEl, 'max-height', currConfig.maxHeight);
-                setStyle(overlayPaneEl, 'width', currConfig.width);
-                setStyle(overlayPaneEl, 'height', currConfig.height);
-                setClass(containerEl, prevConfig?.containerClass, currConfig?.containerClass);
-                setClass(overlayPaneEl, prevConfig?.paneClass, currConfig?.paneClass);
-                setClass(overlayWrapper, prevConfig?.overlayClass, currConfig?.overlayClass);
-                if (backdropEl) {
-                    setClass(backdropEl, prevConfig?.backdropClass, currConfig?.backdropClass);
-                }
-                if (!equal(prevConfig?.position, currConfig?.position)) {
-                    overlayRef.updatePosition(currConfig.position);
+            };
+            const combineOrMakeCalc = (value, append) => {
+                if (!value)
+                    return append;
+                if (typeof value === 'number') {
+                    return `calc(${value}px + ${append})`;
                 }
-                if (currConfig.positionStrategy) {
-                    cdkRef.overlayRef.updatePositionStrategy(currConfig.positionStrategy);
+                else if (value.startsWith('calc(')) {
+                    return `${value.slice(0, value.length - 1)} + ${append})`;
                 }
-                else {
-                    cdkRef.overlayRef.updatePosition();
+                return `calc(${value} + ${append})`;
+            };
+            if (useDefaultAnimation && containerClass?.length) {
+                if (containerClass?.includes(ET_OVERLAY_LEFT_SHEET_CLASS) ||
+                    containerClass?.includes(ET_OVERLAY_RIGHT_SHEET_CLASS)) {
+                    setStyle(overlayPaneEl, 'max-width', combineOrMakeCalc(currConfig.maxWidth, `${defaultAnimationBuffer}px`));
+                    setStyle(overlayPaneEl, 'max-height', currConfig.maxHeight);
                 }
-                if (currConfig.dragToDismiss) {
-                    overlayRef._containerInstance._enableDragToDismiss(currConfig.dragToDismiss);
+                else if (containerClass?.includes(ET_OVERLAY_TOP_SHEET_CLASS) ||
+                    containerClass?.includes(ET_OVERLAY_BOTTOM_SHEET_CLASS)) {
+                    setStyle(overlayPaneEl, 'max-height', combineOrMakeCalc(currConfig.maxHeight, `${defaultAnimationBuffer}px`));
+                    setStyle(overlayPaneEl, 'max-width', currConfig.maxWidth);
                 }
                 else {
-                    overlayRef._containerInstance._disableDragToDismiss();
+                    applyDefaultMaxWidths();
                 }
-            }))
-                .subscribe();
-        }
+            }
+            else {
+                applyDefaultMaxWidths();
+            }
+            setStyle(overlayPaneEl, 'min-width', currConfig.minWidth);
+            setStyle(overlayPaneEl, 'min-height', currConfig.minHeight);
+            setStyle(overlayPaneEl, 'width', currConfig.width);
+            setStyle(overlayPaneEl, 'height', currConfig.height);
+            setClass(containerEl, prevConfig?.containerClass, currConfig?.containerClass);
+            setClass(overlayPaneEl, prevConfig?.paneClass, currConfig?.paneClass);
+            setClass(overlayWrapper, prevConfig?.overlayClass, currConfig?.overlayClass);
+            // FIXME: These classes should only be removed if no open overlays require them inside their config.
+            setClass(document.documentElement, prevConfig?.documentClass, currConfig?.documentClass);
+            setClass(document.body, prevConfig?.bodyClass, currConfig?.bodyClass);
+            if (backdropEl) {
+                setClass(backdropEl, prevConfig?.backdropClass, currConfig?.backdropClass);
+            }
+            if (!equal(prevConfig?.position, currConfig?.position)) {
+                overlayRef.updatePosition(currConfig.position);
+            }
+            if (currConfig.positionStrategy) {
+                cdkRef.overlayRef.updatePositionStrategy(currConfig.positionStrategy);
+            }
+            else {
+                cdkRef.overlayRef.updatePosition();
+            }
+            if (currConfig.dragToDismiss) {
+                overlayRef._containerInstance._enableDragToDismiss(currConfig.dragToDismiss);
+            }
+            else {
+                overlayRef._containerInstance._disableDragToDismiss();
+            }
+        }))
+            .subscribe();
         this.openOverlays.push(overlayRef);
         this.afterOpened.next(overlayRef);
+        overlayRef.beforeClosed().subscribe(() => {
+            // FIXME: These classes should only be removed if no open overlays require them inside their config.
+            const documentClasses = composedConfig.positions.map((position) => position.config.documentClass);
+            for (const klass of documentClasses) {
+                if (!klass)
+                    continue;
+                if (Array.isArray(klass)) {
+                    document.documentElement.classList.remove(...klass);
+                }
+                else {
+                    document.documentElement.classList.remove(klass);
+                }
+            }
+            const bodyClasses = composedConfig.positions.map((position) => position.config.bodyClass);
+            for (const klass of bodyClasses) {
+                if (!klass)
+                    continue;
+                if (Array.isArray(klass)) {
+                    document.body.classList.remove(...klass);
+                }
+                else {
+                    document.body.classList.remove(klass);
+                }
+            }
+        });
         overlayRef.afterClosed().subscribe(() => {
             const index = this.openOverlays.indexOf(overlayRef);
             if (index === -1)
@@ -173,10 +235,10 @@ export class OverlayService {
         const parent = this._parentOverlayService;
         return parent ? parent._getAfterAllClosed() : this._afterAllClosedAtThisLevel;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.4", ngImport: i0, type: OverlayService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.4", ngImport: i0, type: OverlayService }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: OverlayService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: OverlayService }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.4", ngImport: i0, type: OverlayService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: OverlayService, decorators: [{
             type: Injectable
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay.service.js","sourceRoot":"","sources":["../../../../../../../../../../libs/cdk/src/lib/components/overlay/components/overlay/services/overlay.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { coerceCssPixelValue } from '@angular/cdk/coercion';\nimport { Dialog as CdkDialog, DialogConfig as CdkDialogConfig } from '@angular/cdk/dialog';\nimport { ComponentType } from '@angular/cdk/overlay';\nimport { ComponentRef, Injectable, OnDestroy, TemplateRef, inject } from '@angular/core';\nimport { ViewportService, createDestroy, equal } from '@ethlete/core';\nimport { Observable, Subject, combineLatest, defer, map, of, pairwise, startWith, takeUntil, tap } from 'rxjs';\nimport { OverlayContainerComponent } from '../components';\nimport { OVERLAY_CONFIG, OVERLAY_DATA, OVERLAY_DEFAULT_OPTIONS, OVERLAY_SCROLL_STRATEGY } from '../constants';\nimport { OverlayConfig } from '../types';\nimport { OverlayPositionBuilder, OverlayRef, createOverlayConfig } from '../utils';\n\nlet uniqueId = 0;\nconst ID_PREFIX = 'et-overlay-';\n\nconst setStyle = (el: HTMLElement, style: string, value: string | number | null | undefined) => {\n  if (value === null || value === undefined) {\n    el.style.removeProperty(style);\n  } else {\n    el.style.setProperty(style, coerceCssPixelValue(value));\n  }\n};\n\nconst setClass = (el: HTMLElement, prevClass?: string | string[], currClass?: string | string[]) => {\n  if (!equal(prevClass, currClass)) {\n    if (prevClass) {\n      if (Array.isArray(prevClass)) {\n        el.classList.remove(...prevClass);\n      } else {\n        el.classList.remove(prevClass);\n      }\n    }\n\n    if (currClass) {\n      if (Array.isArray(currClass)) {\n        el.classList.add(...currClass);\n      } else {\n        el.classList.add(currClass);\n      }\n    }\n  }\n};\n\n@Injectable()\nexport class OverlayService implements OnDestroy {\n  private readonly _destroy$ = createDestroy();\n  private readonly _defaultOptions = inject(OVERLAY_DEFAULT_OPTIONS, { optional: true });\n  private readonly _scrollStrategy = inject(OVERLAY_SCROLL_STRATEGY);\n  private readonly _parentOverlayService = inject(OverlayService, { optional: true, skipSelf: true });\n  private readonly _dialog = inject(CdkDialog);\n  private readonly _viewportService = inject(ViewportService);\n\n  private readonly _openOverlaysAtThisLevel: OverlayRef[] = [];\n  private readonly _afterAllClosedAtThisLevel = new Subject<void>();\n  private readonly _afterOpenedAtThisLevel = new Subject<OverlayRef>();\n\n  readonly positions = new OverlayPositionBuilder();\n\n  readonly afterAllClosed = defer(() =>\n    this.openOverlays.length ? this._getAfterAllClosed() : this._getAfterAllClosed().pipe(startWith(undefined)),\n  ) as Observable<void>;\n\n  get openOverlays(): OverlayRef[] {\n    return this._parentOverlayService ? this._parentOverlayService.openOverlays : this._openOverlaysAtThisLevel;\n  }\n\n  get afterOpened(): Subject<OverlayRef> {\n    return this._parentOverlayService ? this._parentOverlayService.afterOpened : this._afterOpenedAtThisLevel;\n  }\n\n  ngOnDestroy() {\n    this._closeOverlays(this._openOverlaysAtThisLevel);\n    this._afterAllClosedAtThisLevel.complete();\n    this._afterOpenedAtThisLevel.complete();\n  }\n\n  open<T, D = unknown, R = unknown>(component: ComponentType<T>, config: OverlayConfig<D>): OverlayRef<T, R>;\n  open<T, D = unknown, R = unknown>(template: TemplateRef<T>, config: OverlayConfig<D>): OverlayRef<T, R>;\n  open<T, D = unknown, R = unknown>(\n    template: ComponentType<T> | TemplateRef<T>,\n    config: OverlayConfig<D>,\n  ): OverlayRef<T, R>;\n  open<T, D = unknown, R = unknown>(\n    componentOrTemplateRef: ComponentType<T> | TemplateRef<T>,\n    config: OverlayConfig<D>,\n  ): OverlayRef<T, R> {\n    let overlayRef: OverlayRef<T, R>;\n\n    const composedConfig = createOverlayConfig<D>(this._defaultOptions as OverlayConfig<D>, config);\n    composedConfig.id = composedConfig.id || `${ID_PREFIX}${uniqueId++}`;\n    composedConfig.scrollStrategy = composedConfig.scrollStrategy || this._scrollStrategy();\n\n    const cdkRef = this._dialog.open<R, D, T>(componentOrTemplateRef, {\n      ...composedConfig,\n      disableClose: true,\n      closeOnDestroy: false,\n      container: {\n        type: OverlayContainerComponent,\n        providers: () => [\n          { provide: OVERLAY_CONFIG, useValue: composedConfig },\n          { provide: CdkDialogConfig, useValue: composedConfig },\n        ],\n      },\n      templateContext: () => ({ dialogRef: overlayRef }),\n      providers: (ref, cdkConfig, overlayContainer) => {\n        overlayRef = new OverlayRef(ref, composedConfig, overlayContainer as OverlayContainerComponent);\n\n        return [\n          { provide: OverlayContainerComponent, useValue: overlayContainer },\n          { provide: OVERLAY_DATA, useValue: cdkConfig.data },\n          { provide: OverlayRef, useValue: overlayRef },\n        ];\n      },\n    });\n\n    /* eslint-disable @typescript-eslint/no-non-null-assertion*/\n    (overlayRef! as { componentRef: ComponentRef<T> }).componentRef = cdkRef.componentRef!;\n    overlayRef!.componentInstance = cdkRef.componentInstance!;\n\n    (cdkRef.containerInstance as OverlayContainerComponent).overlayRef = overlayRef!;\n\n    if (composedConfig.positions?.length) {\n      combineLatest(\n        composedConfig.positions.map((breakpoint) =>\n          (breakpoint.breakpoint ? this._viewportService.observe({ min: breakpoint.breakpoint }) : of(true)).pipe(\n            map((isActive) => ({\n              isActive,\n              config: breakpoint.config,\n              size:\n                typeof breakpoint.breakpoint === 'number'\n                  ? breakpoint.breakpoint\n                  : breakpoint.breakpoint === undefined\n                  ? 0\n                  : this._viewportService.getBreakpointSize(breakpoint.breakpoint, 'min'),\n            })),\n          ),\n        ),\n      )\n        .pipe(\n          takeUntil(overlayRef!.afterClosed()),\n          takeUntil(this._destroy$),\n          map((entries) => {\n            const activeBreakpoints = entries.filter((entry) => entry.isActive);\n            const highestBreakpoint = activeBreakpoints.reduce((prev, curr) => (prev.size > curr.size ? prev : curr));\n\n            return highestBreakpoint.config;\n          }),\n          startWith(null),\n          pairwise(),\n          tap(([prevConfig, currConfig]) => {\n            if (!currConfig) return;\n\n            const overlayPaneEl = cdkRef.overlayRef.overlayElement;\n            const containerEl = overlayRef._containerInstance.elementRef.nativeElement;\n            const backdropEl = cdkRef.overlayRef.backdropElement;\n            const overlayWrapper = cdkRef.overlayRef.hostElement;\n\n            setStyle(overlayPaneEl, 'min-width', currConfig.minWidth);\n            setStyle(overlayPaneEl, 'min-height', currConfig.minHeight);\n            setStyle(overlayPaneEl, 'max-width', currConfig.maxWidth);\n            setStyle(overlayPaneEl, 'max-height', currConfig.maxHeight);\n            setStyle(overlayPaneEl, 'width', currConfig.width);\n            setStyle(overlayPaneEl, 'height', currConfig.height);\n\n            setClass(containerEl, prevConfig?.containerClass, currConfig?.containerClass);\n            setClass(overlayPaneEl, prevConfig?.paneClass, currConfig?.paneClass);\n            setClass(overlayWrapper, prevConfig?.overlayClass, currConfig?.overlayClass);\n\n            if (backdropEl) {\n              setClass(backdropEl, prevConfig?.backdropClass, currConfig?.backdropClass);\n            }\n\n            if (!equal(prevConfig?.position, currConfig?.position)) {\n              overlayRef.updatePosition(currConfig.position);\n            }\n\n            if (currConfig.positionStrategy) {\n              cdkRef.overlayRef.updatePositionStrategy(currConfig.positionStrategy);\n            } else {\n              cdkRef.overlayRef.updatePosition();\n            }\n\n            if (currConfig.dragToDismiss) {\n              overlayRef._containerInstance._enableDragToDismiss(currConfig.dragToDismiss);\n            } else {\n              overlayRef._containerInstance._disableDragToDismiss();\n            }\n          }),\n        )\n        .subscribe();\n    }\n\n    this.openOverlays.push(overlayRef!);\n    this.afterOpened.next(overlayRef!);\n\n    overlayRef!.afterClosed().subscribe(() => {\n      const index = this.openOverlays.indexOf(overlayRef);\n\n      if (index === -1) return;\n\n      this.openOverlays.splice(index, 1);\n\n      if (!this.openOverlays.length) {\n        this._getAfterAllClosed().next();\n      }\n    });\n\n    return overlayRef!;\n\n    /* eslint-enable @typescript-eslint/no-non-null-assertion*/\n  }\n\n  closeAll(): void {\n    this._closeOverlays(this.openOverlays);\n  }\n\n  getOverlayById(id: string): OverlayRef | undefined {\n    return this.openOverlays.find((overlay) => overlay.id === id);\n  }\n\n  private _closeOverlays(overlays: OverlayRef[]) {\n    let i = overlays.length;\n\n    while (i--) {\n      overlays[i].close();\n    }\n  }\n\n  private _getAfterAllClosed(): Subject<void> {\n    const parent = this._parentOverlayService;\n    return parent ? parent._getAfterAllClosed() : this._afterAllClosedAtThisLevel;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay.service.js","sourceRoot":"","sources":["../../../../../../../../../../libs/cdk/src/lib/components/overlay/components/overlay/services/overlay.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { coerceCssPixelValue } from '@angular/cdk/coercion';\nimport { Dialog as CdkDialog, DialogConfig as CdkDialogConfig } from '@angular/cdk/dialog';\nimport { ComponentType } from '@angular/cdk/overlay';\nimport { ComponentRef, Injectable, OnDestroy, TemplateRef, inject } from '@angular/core';\nimport { ViewportService, createDestroy, equal } from '@ethlete/core';\nimport { Observable, Subject, combineLatest, defer, map, of, pairwise, startWith, takeUntil, tap } from 'rxjs';\nimport { OverlayContainerComponent } from '../components';\nimport { OVERLAY_CONFIG, OVERLAY_DATA, OVERLAY_DEFAULT_OPTIONS, OVERLAY_SCROLL_STRATEGY } from '../constants';\nimport { OverlayConfig } from '../types';\nimport {\n  ET_OVERLAY_BOTTOM_SHEET_CLASS,\n  ET_OVERLAY_LEFT_SHEET_CLASS,\n  ET_OVERLAY_RIGHT_SHEET_CLASS,\n  ET_OVERLAY_TOP_SHEET_CLASS,\n  OverlayPositionBuilder,\n  OverlayRef,\n  createOverlayConfig,\n} from '../utils';\n\nlet uniqueId = 0;\nconst ID_PREFIX = 'et-overlay-';\n\nconst setStyle = (el: HTMLElement, style: string, value: string | number | null | undefined) => {\n  if (value === null || value === undefined) {\n    el.style.removeProperty(style);\n  } else {\n    el.style.setProperty(style, coerceCssPixelValue(value));\n  }\n};\n\nconst setClass = (el: HTMLElement, prevClass?: string | string[], currClass?: string | string[]) => {\n  if (!equal(prevClass, currClass)) {\n    if (prevClass) {\n      if (Array.isArray(prevClass)) {\n        el.classList.remove(...prevClass);\n      } else {\n        el.classList.remove(prevClass);\n      }\n    }\n\n    if (currClass) {\n      if (Array.isArray(currClass)) {\n        el.classList.add(...currClass);\n      } else {\n        el.classList.add(currClass);\n      }\n    }\n  }\n};\n\n@Injectable()\nexport class OverlayService implements OnDestroy {\n  private readonly _destroy$ = createDestroy();\n  private readonly _defaultOptions = inject(OVERLAY_DEFAULT_OPTIONS, { optional: true });\n  private readonly _scrollStrategy = inject(OVERLAY_SCROLL_STRATEGY);\n  private readonly _parentOverlayService = inject(OverlayService, { optional: true, skipSelf: true });\n  private readonly _dialog = inject(CdkDialog);\n  private readonly _viewportService = inject(ViewportService);\n\n  private readonly _openOverlaysAtThisLevel: OverlayRef[] = [];\n  private readonly _afterAllClosedAtThisLevel = new Subject<void>();\n  private readonly _afterOpenedAtThisLevel = new Subject<OverlayRef>();\n\n  readonly positions = new OverlayPositionBuilder();\n\n  readonly afterAllClosed = defer(() =>\n    this.openOverlays.length ? this._getAfterAllClosed() : this._getAfterAllClosed().pipe(startWith(undefined)),\n  ) as Observable<void>;\n\n  get openOverlays(): OverlayRef[] {\n    return this._parentOverlayService ? this._parentOverlayService.openOverlays : this._openOverlaysAtThisLevel;\n  }\n\n  get afterOpened(): Subject<OverlayRef> {\n    return this._parentOverlayService ? this._parentOverlayService.afterOpened : this._afterOpenedAtThisLevel;\n  }\n\n  ngOnDestroy() {\n    this._closeOverlays(this._openOverlaysAtThisLevel);\n    this._afterAllClosedAtThisLevel.complete();\n    this._afterOpenedAtThisLevel.complete();\n  }\n\n  open<T, D = unknown, R = unknown>(component: ComponentType<T>, config: OverlayConfig<D>): OverlayRef<T, R>;\n  open<T, D = unknown, R = unknown>(template: TemplateRef<T>, config: OverlayConfig<D>): OverlayRef<T, R>;\n  open<T, D = unknown, R = unknown>(\n    template: ComponentType<T> | TemplateRef<T>,\n    config: OverlayConfig<D>,\n  ): OverlayRef<T, R>;\n  open<T, D = unknown, R = unknown>(\n    componentOrTemplateRef: ComponentType<T> | TemplateRef<T>,\n    config: OverlayConfig<D>,\n  ): OverlayRef<T, R> {\n    let overlayRef: OverlayRef<T, R>;\n\n    const composedConfig = createOverlayConfig<D>(this._defaultOptions as OverlayConfig<D>, config);\n    composedConfig.id = composedConfig.id || `${ID_PREFIX}${uniqueId++}`;\n    composedConfig.scrollStrategy = composedConfig.scrollStrategy || this._scrollStrategy();\n\n    const cdkRef = this._dialog.open<R, D, T>(componentOrTemplateRef, {\n      ...composedConfig,\n      disableClose: true,\n      closeOnDestroy: false,\n      panelClass: 'et-overlay-pane',\n      container: {\n        type: OverlayContainerComponent,\n        providers: () => [\n          { provide: OVERLAY_CONFIG, useValue: composedConfig },\n          { provide: CdkDialogConfig, useValue: composedConfig },\n        ],\n      },\n      templateContext: () => ({ dialogRef: overlayRef }),\n      providers: (ref, cdkConfig, overlayContainer) => {\n        overlayRef = new OverlayRef(ref, composedConfig, overlayContainer as OverlayContainerComponent);\n\n        return [\n          { provide: OverlayContainerComponent, useValue: overlayContainer },\n          { provide: OVERLAY_DATA, useValue: cdkConfig.data },\n          { provide: OverlayRef, useValue: overlayRef },\n          ...(composedConfig.providers ?? []),\n        ];\n      },\n    });\n\n    /* eslint-disable @typescript-eslint/no-non-null-assertion*/\n    (overlayRef! as { componentRef: ComponentRef<T> }).componentRef = cdkRef.componentRef!;\n    overlayRef!.componentInstance = cdkRef.componentInstance!;\n\n    (cdkRef.containerInstance as OverlayContainerComponent).overlayRef = overlayRef!;\n\n    combineLatest(\n      composedConfig.positions.map((breakpoint) =>\n        (breakpoint.breakpoint ? this._viewportService.observe({ min: breakpoint.breakpoint }) : of(true)).pipe(\n          map((isActive) => ({\n            isActive,\n            config: breakpoint.config,\n            size:\n              typeof breakpoint.breakpoint === 'number'\n                ? breakpoint.breakpoint\n                : breakpoint.breakpoint === undefined\n                ? 0\n                : this._viewportService.getBreakpointSize(breakpoint.breakpoint, 'min'),\n          })),\n        ),\n      ),\n    )\n      .pipe(\n        takeUntil(overlayRef!.afterClosed()),\n        takeUntil(this._destroy$),\n        map((entries) => {\n          const activeBreakpoints = entries.filter((entry) => entry.isActive);\n          const highestBreakpoint = activeBreakpoints.reduce((prev, curr) => (prev.size > curr.size ? prev : curr));\n\n          return highestBreakpoint.config;\n        }),\n        startWith(null),\n        pairwise(),\n        tap(([prevConfig, currConfig]) => {\n          if (!currConfig) return;\n\n          const overlayPaneEl = cdkRef.overlayRef.overlayElement;\n          const containerEl = overlayRef._containerInstance.elementRef.nativeElement;\n          const backdropEl = cdkRef.overlayRef.backdropElement;\n          const overlayWrapper = cdkRef.overlayRef.hostElement;\n          const defaultAnimationBuffer = 50; // 50px since the default animation uses spring physics and thus will overshoot.\n          const useDefaultAnimation = composedConfig.customAnimated !== true;\n          const containerClass = currConfig.containerClass;\n\n          const applyDefaultMaxWidths = () => {\n            setStyle(overlayPaneEl, 'max-width', currConfig.maxWidth);\n            setStyle(overlayPaneEl, 'max-height', currConfig.maxHeight);\n          };\n\n          const combineOrMakeCalc = (value: string | number | null | undefined, append: string) => {\n            if (!value) return append;\n\n            if (typeof value === 'number') {\n              return `calc(${value}px + ${append})`;\n            } else if (value.startsWith('calc(')) {\n              return `${value.slice(0, value.length - 1)} + ${append})`;\n            }\n\n            return `calc(${value} + ${append})`;\n          };\n\n          if (useDefaultAnimation && containerClass?.length) {\n            if (\n              containerClass?.includes(ET_OVERLAY_LEFT_SHEET_CLASS) ||\n              containerClass?.includes(ET_OVERLAY_RIGHT_SHEET_CLASS)\n            ) {\n              setStyle(\n                overlayPaneEl,\n                'max-width',\n                combineOrMakeCalc(currConfig.maxWidth, `${defaultAnimationBuffer}px`),\n              );\n              setStyle(overlayPaneEl, 'max-height', currConfig.maxHeight);\n            } else if (\n              containerClass?.includes(ET_OVERLAY_TOP_SHEET_CLASS) ||\n              containerClass?.includes(ET_OVERLAY_BOTTOM_SHEET_CLASS)\n            ) {\n              setStyle(\n                overlayPaneEl,\n                'max-height',\n                combineOrMakeCalc(currConfig.maxHeight, `${defaultAnimationBuffer}px`),\n              );\n\n              setStyle(overlayPaneEl, 'max-width', currConfig.maxWidth);\n            } else {\n              applyDefaultMaxWidths();\n            }\n          } else {\n            applyDefaultMaxWidths();\n          }\n\n          setStyle(overlayPaneEl, 'min-width', currConfig.minWidth);\n          setStyle(overlayPaneEl, 'min-height', currConfig.minHeight);\n\n          setStyle(overlayPaneEl, 'width', currConfig.width);\n          setStyle(overlayPaneEl, 'height', currConfig.height);\n\n          setClass(containerEl, prevConfig?.containerClass, currConfig?.containerClass);\n          setClass(overlayPaneEl, prevConfig?.paneClass, currConfig?.paneClass);\n          setClass(overlayWrapper, prevConfig?.overlayClass, currConfig?.overlayClass);\n\n          // FIXME: These classes should only be removed if no open overlays require them inside their config.\n          setClass(document.documentElement, prevConfig?.documentClass, currConfig?.documentClass);\n          setClass(document.body, prevConfig?.bodyClass, currConfig?.bodyClass);\n\n          if (backdropEl) {\n            setClass(backdropEl, prevConfig?.backdropClass, currConfig?.backdropClass);\n          }\n\n          if (!equal(prevConfig?.position, currConfig?.position)) {\n            overlayRef.updatePosition(currConfig.position);\n          }\n\n          if (currConfig.positionStrategy) {\n            cdkRef.overlayRef.updatePositionStrategy(currConfig.positionStrategy);\n          } else {\n            cdkRef.overlayRef.updatePosition();\n          }\n\n          if (currConfig.dragToDismiss) {\n            overlayRef._containerInstance._enableDragToDismiss(currConfig.dragToDismiss);\n          } else {\n            overlayRef._containerInstance._disableDragToDismiss();\n          }\n        }),\n      )\n      .subscribe();\n\n    this.openOverlays.push(overlayRef!);\n    this.afterOpened.next(overlayRef!);\n\n    overlayRef!.beforeClosed().subscribe(() => {\n      // FIXME: These classes should only be removed if no open overlays require them inside their config.\n      const documentClasses = composedConfig.positions.map((position) => position.config.documentClass);\n\n      for (const klass of documentClasses) {\n        if (!klass) continue;\n\n        if (Array.isArray(klass)) {\n          document.documentElement.classList.remove(...klass);\n        } else {\n          document.documentElement.classList.remove(klass);\n        }\n      }\n\n      const bodyClasses = composedConfig.positions.map((position) => position.config.bodyClass);\n\n      for (const klass of bodyClasses) {\n        if (!klass) continue;\n\n        if (Array.isArray(klass)) {\n          document.body.classList.remove(...klass);\n        } else {\n          document.body.classList.remove(klass);\n        }\n      }\n    });\n\n    overlayRef!.afterClosed().subscribe(() => {\n      const index = this.openOverlays.indexOf(overlayRef);\n\n      if (index === -1) return;\n\n      this.openOverlays.splice(index, 1);\n\n      if (!this.openOverlays.length) {\n        this._getAfterAllClosed().next();\n      }\n    });\n\n    return overlayRef!;\n\n    /* eslint-enable @typescript-eslint/no-non-null-assertion*/\n  }\n\n  closeAll(): void {\n    this._closeOverlays(this.openOverlays);\n  }\n\n  getOverlayById(id: string): OverlayRef | undefined {\n    return this.openOverlays.find((overlay) => overlay.id === id);\n  }\n\n  private _closeOverlays(overlays: OverlayRef[]) {\n    let i = overlays.length;\n\n    while (i--) {\n      overlays[i].close();\n    }\n  }\n\n  private _getAfterAllClosed(): Subject<void> {\n    const parent = this._parentOverlayService;\n    return parent ? parent._getAfterAllClosed() : this._afterAllClosedAtThisLevel;\n  }\n}\n"]}

package/esm2022/lib/components/overlay/components/overlay/types/overlay.types.mjs

@@ -3,4 +3,4 @@ export const OVERLAY_STATE = {
     CLOSING: 'closing',
     CLOSED: 'closed',
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay.types.js","sourceRoot":"","sources":["../../../../../../../../../../libs/cdk/src/lib/components/overlay/components/overlay/types/overlay.types.ts"],"names":[],"mappings":"AA0BA,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,IAAI,EAAE,MAAM;IACZ,OAAO,EAAE,SAAS;IAClB,MAAM,EAAE,QAAQ;CACR,CAAC","sourcesContent":["import { Direction } from '@angular/cdk/bidi';\nimport { PositionStrategy, ScrollStrategy } from '@angular/cdk/overlay';\nimport { Injector, ViewContainerRef } from '@angular/core';\nimport { Breakpoint } from '@ethlete/core';\n\n/** Options for where to set focus to automatically on overlay open */\nexport type OverlayAutoFocusTarget = 'dialog' | 'first-tabbable' | 'first-heading';\n\n/** Valid ARIA roles for a overlay element. */\nexport type OverlayRole = 'dialog' | 'alertdialog';\n\n/** Possible overrides for a overlay's position. */\nexport interface OverlayPosition {\n  /** Override for the overlay's top position. */\n  top?: string;\n\n  /** Override for the overlay's bottom position. */\n  bottom?: string;\n\n  /** Override for the overlay's left position. */\n  left?: string;\n\n  /** Override for the overlay's right position. */\n  right?: string;\n}\n\nexport const OVERLAY_STATE = {\n  OPEN: 'open',\n  CLOSING: 'closing',\n  CLOSED: 'closed',\n} as const;\n\nexport type OverlayState = (typeof OVERLAY_STATE)[keyof typeof OVERLAY_STATE];\n\nexport interface OverlayDragToDismissConfig {\n  /** Direction in which the overlay can be dragged. */\n  direction: 'to-top' | 'to-bottom' | 'to-left' | 'to-right';\n\n  /**\n   * The minimum distance in pixels that the user must swipe to dismiss the overlay.\n   *\n   * @default 150 // 150px\n   */\n  minDistanceToDismiss?: number;\n\n  /**\n   * The minimum velocity in pixels per second that the user must swipe to dismiss the overlay.\n   *\n   * @default 150 // 150px/s\n   */\n  minVelocityToDismiss?: number;\n}\n\nexport interface OverlayBreakpointConfig {\n  /** Min-width of the overlay. If a number is provided, assumes pixel units. */\n  minWidth?: number | string;\n\n  /** Max-width of the overlay. If a number is provided, assumes pixel units. */\n  maxWidth?: number | string;\n\n  /** Min-height of the overlay. If a number is provided, assumes pixel units. */\n  minHeight?: number | string;\n\n  /** Max-height of the overlay. If a number is provided, assumes pixel units. */\n  maxHeight?: number | string;\n\n  /** Width of the overlay. */\n  width?: number | string;\n\n  /** Height of the overlay. */\n  height?: number | string;\n\n  /** Position strategy to be used for the overlay. */\n  positionStrategy?: PositionStrategy;\n\n  /** Custom class for the overlay container. */\n  containerClass?: string | string[];\n\n  /** Custom class for the overlay pane. */\n  paneClass?: string | string[];\n\n  /** Extra CSS classes to be added to the overlay overlay container. */\n  overlayClass?: string | string[];\n\n  /** Custom class for the backdrop. */\n  backdropClass?: string | string[];\n\n  /** Position overrides. */\n  position?: OverlayPosition;\n\n  /** Determine if and in what direction the overlay should be able to be dragged to dismiss it. */\n  dragToDismiss?: OverlayDragToDismissConfig;\n}\n\nexport interface OverlayBreakpointConfigEntry {\n  /**\n   * Breakpoint to apply the config for. If a number is provided, it will be used as a pixel value.\n   * Always uses the min-width media query.\n   *\n   * @default 'xs' // 0px\n   */\n  breakpoint?: Breakpoint | number;\n\n  /**\n   * Overlay configuration to be applied when the breakpoint is active.\n   */\n  config: OverlayBreakpointConfig;\n}\n\nexport interface OverlayConfig<D = unknown> {\n  /**\n   * Conditionally applied overlay configurations based on breakpoints.\n   */\n  positions: OverlayBreakpointConfigEntry[];\n\n  /**\n   * Where the attached component should live in Angular's *logical* component tree.\n   * This affects what is available for injection and the change detection order for the\n   * component instantiated inside of the overlay. This does not affect where the overlay\n   * content will be rendered.\n   */\n  viewContainerRef?: ViewContainerRef;\n\n  /**\n   * Injector used for the instantiation of the component to be attached. If provided,\n   * takes precedence over the injector indirectly provided by `ViewContainerRef`.\n   */\n  injector?: Injector;\n\n  /** ID for the overlay. If omitted, a unique one will be generated. */\n  id?: string;\n\n  /**\n   * The ARIA role of the overlay element.\n   * @default 'dialog'\n   */\n  role?: OverlayRole;\n\n  /**\n   * Whether the overlay has a backdrop.\n   * @default true\n   */\n  hasBackdrop?: boolean;\n\n  /**\n   * Whether the user can use escape or clicking on the backdrop to close the modal.\n   * @default false\n   */\n  disableClose?: boolean;\n\n  /**\n   * Data being injected into the child component.\n   * @default null\n   */\n  data?: D | null;\n\n  /** Layout direction for the overlay's content. */\n  direction?: Direction;\n\n  /**\n   * ID of the element that describes the overlay.\n   * @default null\n   */\n  ariaDescribedBy?: string | null;\n\n  /**\n   * ID of the element that labels the overlay.\n   * @default null\n   */\n  ariaLabelledBy?: string | null;\n\n  /**\n   * Aria label to assign to the overlay element.\n   * @default null\n   */\n  ariaLabel?: string | null;\n\n  /**\n   * Whether this is a modal overlay. Used to set the `aria-modal` attribute.\n   * @default true\n   */\n  ariaModal?: boolean;\n\n  /**\n   * Whether the overlay uses a custom animation.\n   * @default false\n   */\n  customAnimated?: boolean;\n\n  /**\n   * Where the overlay should focus on open.\n   * Can be one of AutoFocusTarget, or a css selector string.\n   * @default 'first-tabbable'\n   */\n  autoFocus?: OverlayAutoFocusTarget | string;\n\n  /**\n   * Whether the overlay should restore focus to the\n   * previously-focused element, after it's closed.\n   * @default true\n   */\n  restoreFocus?: boolean;\n\n  /**\n   * Whether to wait for the opening animation to finish before trapping focus.\n   * @default true\n   */\n  delayFocusTrap?: boolean;\n\n  /** Scroll strategy to be used for the overlay. */\n  scrollStrategy?: ScrollStrategy;\n\n  /**\n   * Whether the overlay should close when the user goes backwards/forwards in history.\n   * Note that this usually doesn't include clicking on links (unless the user is using\n   * the `HashLocationStrategy`).\n   * @default true\n   */\n  closeOnNavigation?: boolean;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay.types.js","sourceRoot":"","sources":["../../../../../../../../../../libs/cdk/src/lib/components/overlay/components/overlay/types/overlay.types.ts"],"names":[],"mappings":"AA0BA,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,IAAI,EAAE,MAAM;IACZ,OAAO,EAAE,SAAS;IAClB,MAAM,EAAE,QAAQ;CACR,CAAC","sourcesContent":["import { Direction } from '@angular/cdk/bidi';\nimport { PositionStrategy, ScrollStrategy } from '@angular/cdk/overlay';\nimport { Injector, StaticProvider, ViewContainerRef } from '@angular/core';\nimport { Breakpoint } from '@ethlete/core';\n\n/** Options for where to set focus to automatically on overlay open */\nexport type OverlayAutoFocusTarget = 'dialog' | 'first-tabbable' | 'first-heading';\n\n/** Valid ARIA roles for a overlay element. */\nexport type OverlayRole = 'dialog' | 'alertdialog';\n\n/** Possible overrides for a overlay's position. */\nexport interface OverlayPosition {\n  /** Override for the overlay's top position. */\n  top?: string;\n\n  /** Override for the overlay's bottom position. */\n  bottom?: string;\n\n  /** Override for the overlay's left position. */\n  left?: string;\n\n  /** Override for the overlay's right position. */\n  right?: string;\n}\n\nexport const OVERLAY_STATE = {\n  OPEN: 'open',\n  CLOSING: 'closing',\n  CLOSED: 'closed',\n} as const;\n\nexport type OverlayState = (typeof OVERLAY_STATE)[keyof typeof OVERLAY_STATE];\n\nexport interface OverlayDragToDismissConfig {\n  /** Direction in which the overlay can be dragged. */\n  direction: 'to-top' | 'to-bottom' | 'to-left' | 'to-right';\n\n  /**\n   * The minimum distance in pixels that the user must swipe to dismiss the overlay.\n   *\n   * @default 150 // 150px\n   */\n  minDistanceToDismiss?: number;\n\n  /**\n   * The minimum velocity in pixels per second that the user must swipe to dismiss the overlay.\n   *\n   * @default 150 // 150px/s\n   */\n  minVelocityToDismiss?: number;\n}\n\nexport interface OverlayBreakpointConfig {\n  /** Min-width of the overlay. If a number is provided, assumes pixel units. */\n  minWidth?: number | string;\n\n  /** Max-width of the overlay. If a number is provided, assumes pixel units. */\n  maxWidth?: number | string;\n\n  /** Min-height of the overlay. If a number is provided, assumes pixel units. */\n  minHeight?: number | string;\n\n  /** Max-height of the overlay. If a number is provided, assumes pixel units. */\n  maxHeight?: number | string;\n\n  /** Width of the overlay. */\n  width?: number | string;\n\n  /** Height of the overlay. */\n  height?: number | string;\n\n  /** Position strategy to be used for the overlay. */\n  positionStrategy?: PositionStrategy;\n\n  /** Custom class for the overlay container. */\n  containerClass?: string | string[];\n\n  /** Custom class for the overlay pane. */\n  paneClass?: string | string[];\n\n  /** Extra CSS classes to be added to the overlay overlay container. */\n  overlayClass?: string | string[];\n\n  /** Custom class for the backdrop. */\n  backdropClass?: string | string[];\n\n  /** Custom class for the document (`<html>` element). */\n  documentClass?: string | string[];\n\n  /** Custom class for the `<body>` element */\n  bodyClass?: string | string[];\n\n  /** Position overrides. */\n  position?: OverlayPosition;\n\n  /** Determine if and in what direction the overlay should be able to be dragged to dismiss it. */\n  dragToDismiss?: OverlayDragToDismissConfig;\n}\n\nexport interface OverlayBreakpointConfigEntry {\n  /**\n   * Breakpoint to apply the config for. If a number is provided, it will be used as a pixel value.\n   * Always uses the min-width media query.\n   *\n   * @default 'xs' // 0px\n   */\n  breakpoint?: Breakpoint | number;\n\n  /**\n   * Overlay configuration to be applied when the breakpoint is active.\n   */\n  config: OverlayBreakpointConfig;\n}\n\nexport interface OverlayConfig<D = unknown> {\n  /**\n   * Conditionally applied overlay configurations based on breakpoints.\n   */\n  positions: OverlayBreakpointConfigEntry[];\n\n  /**\n   * Where the attached component should live in Angular's *logical* component tree.\n   * This affects what is available for injection and the change detection order for the\n   * component instantiated inside of the overlay. This does not affect where the overlay\n   * content will be rendered.\n   */\n  viewContainerRef?: ViewContainerRef;\n\n  /**\n   * Injector used for the instantiation of the component to be attached. If provided,\n   * takes precedence over the injector indirectly provided by `ViewContainerRef`.\n   */\n  injector?: Injector;\n\n  /** ID for the overlay. If omitted, a unique one will be generated. */\n  id?: string;\n\n  /**\n   * The ARIA role of the overlay element.\n   * @default 'dialog'\n   */\n  role?: OverlayRole;\n\n  /**\n   * Whether the overlay has a backdrop.\n   * @default true\n   */\n  hasBackdrop?: boolean;\n\n  /**\n   * Whether the user can use escape or clicking on the backdrop to close the modal.\n   * @default false\n   */\n  disableClose?: boolean;\n\n  /**\n   * Data being injected into the child component.\n   * @default null\n   */\n  data?: D | null;\n\n  /** Layout direction for the overlay's content. */\n  direction?: Direction;\n\n  /**\n   * ID of the element that describes the overlay.\n   * @default null\n   */\n  ariaDescribedBy?: string | null;\n\n  /**\n   * ID of the element that labels the overlay.\n   * @default null\n   */\n  ariaLabelledBy?: string | null;\n\n  /**\n   * Aria label to assign to the overlay element.\n   * @default null\n   */\n  ariaLabel?: string | null;\n\n  /**\n   * Whether this is a modal overlay. Used to set the `aria-modal` attribute.\n   * @default true\n   */\n  ariaModal?: boolean;\n\n  /**\n   * Whether the overlay uses a custom animation.\n   * @default false\n   */\n  customAnimated?: boolean;\n\n  /**\n   * Where the overlay should focus on open.\n   * Can be one of AutoFocusTarget, or a css selector string.\n   * @default 'first-tabbable'\n   */\n  autoFocus?: OverlayAutoFocusTarget | string;\n\n  /**\n   * Whether the overlay should restore focus to the\n   * previously-focused element, after it's closed.\n   * @default true\n   */\n  restoreFocus?: boolean;\n\n  /**\n   * Whether to wait for the opening animation to finish before trapping focus.\n   * @default true\n   */\n  delayFocusTrap?: boolean;\n\n  /** Scroll strategy to be used for the overlay. */\n  scrollStrategy?: ScrollStrategy;\n\n  /**\n   * Whether the overlay should close when the user goes backwards/forwards in history.\n   * Note that this usually doesn't include clicking on links (unless the user is using\n   * the `HashLocationStrategy`).\n   * @default true\n   */\n  closeOnNavigation?: boolean;\n\n  /**\n   * Extra providers to be made available to the overlay.\n   */\n  providers?: StaticProvider[];\n}\n"]}

package/esm2022/lib/components/overlay/components/overlay/utils/overlay-position-builder.mjs

@@ -1,5 +1,11 @@
 import { Overlay } from '@angular/cdk/overlay';
 import { inject } from '@angular/core';
+export const ET_OVERLAY_LEFT_SHEET_CLASS = 'et-overlay--left-sheet';
+export const ET_OVERLAY_RIGHT_SHEET_CLASS = 'et-overlay--right-sheet';
+export const ET_OVERLAY_TOP_SHEET_CLASS = 'et-overlay--top-sheet';
+export const ET_OVERLAY_BOTTOM_SHEET_CLASS = 'et-overlay--bottom-sheet';
+export const ET_OVERLAY_DIALOG_CLASS = 'et-overlay--dialog';
+export const ET_OVERLAY_FULL_SCREEN_DIALOG_CLASS = 'et-overlay--full-screen-dialog';
 export class OverlayPositionBuilder {
     constructor() {
         this._overlay = inject(Overlay);
@@ -11,7 +17,7 @@ export class OverlayPositionBuilder {
                 maxWidth: '80vw',
                 minHeight: undefined,
                 minWidth: undefined,
-                containerClass: 'et-overlay--dialog',
+                containerClass: ET_OVERLAY_DIALOG_CLASS,
                 positionStrategy: this._overlay.position().global().centerHorizontally().centerVertically(),
             },
             fullScreenDialog: {
@@ -21,8 +27,9 @@ export class OverlayPositionBuilder {
                 maxWidth: undefined,
                 minHeight: undefined,
                 minWidth: undefined,
-                containerClass: 'et-overlay--full-screen-dialog',
+                containerClass: ET_OVERLAY_FULL_SCREEN_DIALOG_CLASS,
                 positionStrategy: this._overlay.position().global().left('0').top('0').bottom('0').right('0'),
+                documentClass: 'et-overlay--full-screen-dialog-document',
             },
             bottomSheet: {
                 width: '100%',
@@ -31,7 +38,7 @@ export class OverlayPositionBuilder {
                 maxWidth: '640px',
                 minHeight: undefined,
                 minWidth: undefined,
-                containerClass: 'et-overlay--bottom-sheet',
+                containerClass: ET_OVERLAY_BOTTOM_SHEET_CLASS,
                 positionStrategy: this._overlay.position().global().centerHorizontally().bottom('0'),
                 dragToDismiss: {
                     direction: 'to-bottom',
@@ -44,7 +51,7 @@ export class OverlayPositionBuilder {
                 maxWidth: '640px',
                 minHeight: undefined,
                 minWidth: undefined,
-                containerClass: 'et-overlay--top-sheet',
+                containerClass: ET_OVERLAY_TOP_SHEET_CLASS,
                 positionStrategy: this._overlay.position().global().centerHorizontally().top('0'),
                 dragToDismiss: {
                     direction: 'to-top',
@@ -57,7 +64,7 @@ export class OverlayPositionBuilder {
                 maxWidth: '640px',
                 minHeight: undefined,
                 minWidth: undefined,
-                containerClass: 'et-overlay--left-sheet',
+                containerClass: ET_OVERLAY_LEFT_SHEET_CLASS,
                 positionStrategy: this._overlay.position().global().left('0').centerVertically(),
                 dragToDismiss: {
                     direction: 'to-left',
@@ -70,7 +77,7 @@ export class OverlayPositionBuilder {
                 maxWidth: '640px',
                 minHeight: undefined,
                 minWidth: undefined,
-                containerClass: 'et-overlay--right-sheet',
+                containerClass: ET_OVERLAY_RIGHT_SHEET_CLASS,
                 positionStrategy: this._overlay.position().global().right('0').centerVertically(),
                 dragToDismiss: {
                     direction: 'to-right',
@@ -90,6 +97,18 @@ export class OverlayPositionBuilder {
         ];
         return data;
     }
+    transformingFullScreenDialogToRightSheet(customConfig) {
+        const data = [
+            {
+                config: this.mergeConfigs(this.DEFAULTS.fullScreenDialog, customConfig?.fullScreenDialog ?? {}),
+            },
+            {
+                breakpoint: 'md',
+                config: this.mergeConfigs(this.DEFAULTS.rightSheet, customConfig?.rightSheet ?? {}),
+            },
+        ];
+        return data;
+    }
     dialog(customConfig) {
         const data = [
             {
@@ -148,4 +167,4 @@ export class OverlayPositionBuilder {
         return config;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay-position-builder.js","sourceRoot":"","sources":["../../../../../../../../../../libs/cdk/src/lib/components/overlay/components/overlay/utils/overlay-position-builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAC/C,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAGvC,MAAM,OAAO,sBAAsB;IAAnC;QACmB,aAAQ,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;QAEnC,aAAQ,GAAG;YAClB,MAAM,EAAE;gBACN,KAAK,EAAE,SAAS;gBAChB,MAAM,EAAE,SAAS;gBACjB,SAAS,EAAE,MAAM;gBACjB,QAAQ,EAAE,MAAM;gBAChB,SAAS,EAAE,SAAS;gBACpB,QAAQ,EAAE,SAAS;gBACnB,cAAc,EAAE,oBAAoB;gBACpC,gBAAgB,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,kBAAkB,EAAE,CAAC,gBAAgB,EAAE;aAC5F;YACD,gBAAgB,EAAE;gBAChB,KAAK,EAAE,MAAM;gBACb,MAAM,EAAE,MAAM;gBACd,SAAS,EAAE,SAAS;gBACpB,QAAQ,EAAE,SAAS;gBACnB,SAAS,EAAE,SAAS;gBACpB,QAAQ,EAAE,SAAS;gBACnB,cAAc,EAAE,gCAAgC;gBAChD,gBAAgB,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC;aAC9F;YACD,WAAW,EAAE;gBACX,KAAK,EAAE,MAAM;gBACb,MAAM,EAAE,SAAS;gBACjB,SAAS,EAAE,mBAAmB;gBAC9B,QAAQ,EAAE,OAAO;gBACjB,SAAS,EAAE,SAAS;gBACpB,QAAQ,EAAE,SAAS;gBACnB,cAAc,EAAE,0BAA0B;gBAC1C,gBAAgB,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,kBAAkB,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC;gBACpF,aAAa,EAAE;oBACb,SAAS,EAAE,WAAW;iBACvB;aACF;YACD,QAAQ,EAAE;gBACR,KAAK,EAAE,MAAM;gBACb,MAAM,EAAE,SAAS;gBACjB,SAAS,EAAE,mBAAmB;gBAC9B,QAAQ,EAAE,OAAO;gBACjB,SAAS,EAAE,SAAS;gBACpB,QAAQ,EAAE,SAAS;gBACnB,cAAc,EAAE,uBAAuB;gBACvC,gBAAgB,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,kBAAkB,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC;gBACjF,aAAa,EAAE;oBACb,SAAS,EAAE,QAAQ;iBACpB;aACF;YACD,SAAS,EAAE;gBACT,KAAK,EAAE,MAAM;gBACb,MAAM,EAAE,MAAM;gBACd,SAAS,EAAE,SAAS;gBACpB,QAAQ,EAAE,OAAO;gBACjB,SAAS,EAAE,SAAS;gBACpB,QAAQ,EAAE,SAAS;gBACnB,cAAc,EAAE,wBAAwB;gBACxC,gBAAgB,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,gBAAgB,EAAE;gBAChF,aAAa,EAAE;oBACb,SAAS,EAAE,SAAS;iBACrB;aACF;YACD,UAAU,EAAE;gBACV,KAAK,EAAE,MAAM;gBACb,MAAM,EAAE,MAAM;gBACd,SAAS,EAAE,SAAS;gBACpB,QAAQ,EAAE,OAAO;gBACjB,SAAS,EAAE,SAAS;gBACpB,QAAQ,EAAE,SAAS;gBACnB,cAAc,EAAE,yBAAyB;gBACzC,gBAAgB,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,gBAAgB,EAAE;gBACjF,aAAa,EAAE;oBACb,SAAS,EAAE,UAAU;iBACtB;aACF;SACgD,CAAC;IAyFtD,CAAC;IAvFC,+BAA+B,CAAC,YAG/B;QACC,MAAM,IAAI,GAAmC;YAC3C;gBACE,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,YAAY,EAAE,WAAW,IAAI,EAAE,CAAC;aACtF;YACD;gBACE,UAAU,EAAE,IAAI;gBAChB,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,YAAY,EAAE,MAAM,IAAI,EAAE,CAAC;aAC5E;SACF,CAAC;QAEF,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,CAAC,YAAsC;QAC3C,MAAM,IAAI,GAAmC;YAC3C;gBACE,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,YAAY,IAAI,EAAE,CAAC;aACpE;SACF,CAAC;QAEF,OAAO,IAAI,CAAC;IACd,CAAC;IAED,gBAAgB,CAAC,YAAsC;QACrD,MAAM,IAAI,GAAmC;YAC3C;gBACE,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,gBAAgB,EAAE,YAAY,IAAI,EAAE,CAAC;aAC9E;SACF,CAAC;QAEF,OAAO,IAAI,CAAC;IACd,CAAC;IAED,WAAW,CAAC,YAAsC;QAChD,MAAM,IAAI,GAAmC;YAC3C;gBACE,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,YAAY,IAAI,EAAE,CAAC;aACzE;SACF,CAAC;QAEF,OAAO,IAAI,CAAC;IACd,CAAC;IAED,QAAQ,CAAC,YAAsC;QAC7C,MAAM,IAAI,GAAmC;YAC3C;gBACE,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,YAAY,IAAI,EAAE,CAAC;aACtE;SACF,CAAC;QAEF,OAAO,IAAI,CAAC;IACd,CAAC;IAED,SAAS,CAAC,YAAsC;QAC9C,MAAM,IAAI,GAAmC;YAC3C;gBACE,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,YAAY,IAAI,EAAE,CAAC;aACvE;SACF,CAAC;QAEF,OAAO,IAAI,CAAC;IACd,CAAC;IAED,UAAU,CAAC,YAAsC;QAC/C,MAAM,IAAI,GAAmC;YAC3C;gBACE,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,YAAY,IAAI,EAAE,CAAC;aACxE;SACF,CAAC;QAEF,OAAO,IAAI,CAAC;IACd,CAAC;IAED,YAAY,CAAC,GAAG,OAAkC;QAChD,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE;YAC1C,OAAO;gBACL,GAAG,GAAG;gBACN,GAAG,IAAI;aACR,CAAC;QACJ,CAAC,EAAE,EAA6B,CAAC,CAAC;QAElC,OAAO,MAAM,CAAC;IAChB,CAAC;CACF","sourcesContent":["import { Overlay } from '@angular/cdk/overlay';\nimport { inject } from '@angular/core';\nimport { OverlayBreakpointConfig, OverlayBreakpointConfigEntry } from '../types';\n\nexport class OverlayPositionBuilder {\n  private readonly _overlay = inject(Overlay);\n\n  readonly DEFAULTS = {\n    dialog: {\n      width: undefined,\n      height: undefined,\n      maxHeight: '80vh',\n      maxWidth: '80vw',\n      minHeight: undefined,\n      minWidth: undefined,\n      containerClass: 'et-overlay--dialog',\n      positionStrategy: this._overlay.position().global().centerHorizontally().centerVertically(),\n    },\n    fullScreenDialog: {\n      width: '100%',\n      height: '100%',\n      maxHeight: undefined,\n      maxWidth: undefined,\n      minHeight: undefined,\n      minWidth: undefined,\n      containerClass: 'et-overlay--full-screen-dialog',\n      positionStrategy: this._overlay.position().global().left('0').top('0').bottom('0').right('0'),\n    },\n    bottomSheet: {\n      width: '100%',\n      height: undefined,\n      maxHeight: 'calc(100% - 72px)',\n      maxWidth: '640px',\n      minHeight: undefined,\n      minWidth: undefined,\n      containerClass: 'et-overlay--bottom-sheet',\n      positionStrategy: this._overlay.position().global().centerHorizontally().bottom('0'),\n      dragToDismiss: {\n        direction: 'to-bottom',\n      },\n    },\n    topSheet: {\n      width: '100%',\n      height: undefined,\n      maxHeight: 'calc(100% - 72px)',\n      maxWidth: '640px',\n      minHeight: undefined,\n      minWidth: undefined,\n      containerClass: 'et-overlay--top-sheet',\n      positionStrategy: this._overlay.position().global().centerHorizontally().top('0'),\n      dragToDismiss: {\n        direction: 'to-top',\n      },\n    },\n    leftSheet: {\n      width: '100%',\n      height: '100%',\n      maxHeight: undefined,\n      maxWidth: '640px',\n      minHeight: undefined,\n      minWidth: undefined,\n      containerClass: 'et-overlay--left-sheet',\n      positionStrategy: this._overlay.position().global().left('0').centerVertically(),\n      dragToDismiss: {\n        direction: 'to-left',\n      },\n    },\n    rightSheet: {\n      width: '100%',\n      height: '100%',\n      maxHeight: undefined,\n      maxWidth: '640px',\n      minHeight: undefined,\n      minWidth: undefined,\n      containerClass: 'et-overlay--right-sheet',\n      positionStrategy: this._overlay.position().global().right('0').centerVertically(),\n      dragToDismiss: {\n        direction: 'to-right',\n      },\n    },\n  } satisfies Record<string, OverlayBreakpointConfig>;\n\n  transformingBottomSheetToDialog(customConfig?: {\n    bottomSheet?: OverlayBreakpointConfig;\n    dialog?: OverlayBreakpointConfig;\n  }) {\n    const data: OverlayBreakpointConfigEntry[] = [\n      {\n        config: this.mergeConfigs(this.DEFAULTS.bottomSheet, customConfig?.bottomSheet ?? {}),\n      },\n      {\n        breakpoint: 'md',\n        config: this.mergeConfigs(this.DEFAULTS.dialog, customConfig?.dialog ?? {}),\n      },\n    ];\n\n    return data;\n  }\n\n  dialog(customConfig?: OverlayBreakpointConfig) {\n    const data: OverlayBreakpointConfigEntry[] = [\n      {\n        config: this.mergeConfigs(this.DEFAULTS.dialog, customConfig ?? {}),\n      },\n    ];\n\n    return data;\n  }\n\n  fullScreenDialog(customConfig?: OverlayBreakpointConfig) {\n    const data: OverlayBreakpointConfigEntry[] = [\n      {\n        config: this.mergeConfigs(this.DEFAULTS.fullScreenDialog, customConfig ?? {}),\n      },\n    ];\n\n    return data;\n  }\n\n  bottomSheet(customConfig?: OverlayBreakpointConfig) {\n    const data: OverlayBreakpointConfigEntry[] = [\n      {\n        config: this.mergeConfigs(this.DEFAULTS.bottomSheet, customConfig ?? {}),\n      },\n    ];\n\n    return data;\n  }\n\n  topSheet(customConfig?: OverlayBreakpointConfig) {\n    const data: OverlayBreakpointConfigEntry[] = [\n      {\n        config: this.mergeConfigs(this.DEFAULTS.topSheet, customConfig ?? {}),\n      },\n    ];\n\n    return data;\n  }\n\n  leftSheet(customConfig?: OverlayBreakpointConfig) {\n    const data: OverlayBreakpointConfigEntry[] = [\n      {\n        config: this.mergeConfigs(this.DEFAULTS.leftSheet, customConfig ?? {}),\n      },\n    ];\n\n    return data;\n  }\n\n  rightSheet(customConfig?: OverlayBreakpointConfig) {\n    const data: OverlayBreakpointConfigEntry[] = [\n      {\n        config: this.mergeConfigs(this.DEFAULTS.rightSheet, customConfig ?? {}),\n      },\n    ];\n\n    return data;\n  }\n\n  mergeConfigs(...configs: OverlayBreakpointConfig[]) {\n    const config = configs.reduce((acc, curr) => {\n      return {\n        ...acc,\n        ...curr,\n      };\n    }, {} as OverlayBreakpointConfig);\n\n    return config;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay-position-builder.js","sourceRoot":"","sources":["../../../../../../../../../../libs/cdk/src/lib/components/overlay/components/overlay/utils/overlay-position-builder.ts"],"names":[],"mappings":"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","sourcesContent":["import { Overlay } from '@angular/cdk/overlay';\nimport { inject } from '@angular/core';\nimport { OverlayBreakpointConfig, OverlayBreakpointConfigEntry } from '../types';\n\nexport const ET_OVERLAY_LEFT_SHEET_CLASS = 'et-overlay--left-sheet';\nexport const ET_OVERLAY_RIGHT_SHEET_CLASS = 'et-overlay--right-sheet';\nexport const ET_OVERLAY_TOP_SHEET_CLASS = 'et-overlay--top-sheet';\nexport const ET_OVERLAY_BOTTOM_SHEET_CLASS = 'et-overlay--bottom-sheet';\nexport const ET_OVERLAY_DIALOG_CLASS = 'et-overlay--dialog';\nexport const ET_OVERLAY_FULL_SCREEN_DIALOG_CLASS = 'et-overlay--full-screen-dialog';\n\nexport class OverlayPositionBuilder {\n  private readonly _overlay = inject(Overlay);\n\n  readonly DEFAULTS = {\n    dialog: {\n      width: undefined,\n      height: undefined,\n      maxHeight: '80vh',\n      maxWidth: '80vw',\n      minHeight: undefined,\n      minWidth: undefined,\n      containerClass: ET_OVERLAY_DIALOG_CLASS,\n      positionStrategy: this._overlay.position().global().centerHorizontally().centerVertically(),\n    },\n    fullScreenDialog: {\n      width: '100%',\n      height: '100%',\n      maxHeight: undefined,\n      maxWidth: undefined,\n      minHeight: undefined,\n      minWidth: undefined,\n      containerClass: ET_OVERLAY_FULL_SCREEN_DIALOG_CLASS,\n      positionStrategy: this._overlay.position().global().left('0').top('0').bottom('0').right('0'),\n      documentClass: 'et-overlay--full-screen-dialog-document',\n    },\n    bottomSheet: {\n      width: '100%',\n      height: undefined,\n      maxHeight: 'calc(100% - 72px)',\n      maxWidth: '640px',\n      minHeight: undefined,\n      minWidth: undefined,\n      containerClass: ET_OVERLAY_BOTTOM_SHEET_CLASS,\n      positionStrategy: this._overlay.position().global().centerHorizontally().bottom('0'),\n      dragToDismiss: {\n        direction: 'to-bottom',\n      },\n    },\n    topSheet: {\n      width: '100%',\n      height: undefined,\n      maxHeight: 'calc(100% - 72px)',\n      maxWidth: '640px',\n      minHeight: undefined,\n      minWidth: undefined,\n      containerClass: ET_OVERLAY_TOP_SHEET_CLASS,\n      positionStrategy: this._overlay.position().global().centerHorizontally().top('0'),\n      dragToDismiss: {\n        direction: 'to-top',\n      },\n    },\n    leftSheet: {\n      width: '100%',\n      height: '100%',\n      maxHeight: undefined,\n      maxWidth: '640px',\n      minHeight: undefined,\n      minWidth: undefined,\n      containerClass: ET_OVERLAY_LEFT_SHEET_CLASS,\n      positionStrategy: this._overlay.position().global().left('0').centerVertically(),\n      dragToDismiss: {\n        direction: 'to-left',\n      },\n    },\n    rightSheet: {\n      width: '100%',\n      height: '100%',\n      maxHeight: undefined,\n      maxWidth: '640px',\n      minHeight: undefined,\n      minWidth: undefined,\n      containerClass: ET_OVERLAY_RIGHT_SHEET_CLASS,\n      positionStrategy: this._overlay.position().global().right('0').centerVertically(),\n      dragToDismiss: {\n        direction: 'to-right',\n      },\n    },\n  } satisfies Record<string, OverlayBreakpointConfig>;\n\n  transformingBottomSheetToDialog(customConfig?: {\n    bottomSheet?: OverlayBreakpointConfig;\n    dialog?: OverlayBreakpointConfig;\n  }) {\n    const data: OverlayBreakpointConfigEntry[] = [\n      {\n        config: this.mergeConfigs(this.DEFAULTS.bottomSheet, customConfig?.bottomSheet ?? {}),\n      },\n      {\n        breakpoint: 'md',\n        config: this.mergeConfigs(this.DEFAULTS.dialog, customConfig?.dialog ?? {}),\n      },\n    ];\n\n    return data;\n  }\n\n  transformingFullScreenDialogToRightSheet(customConfig?: {\n    fullScreenDialog?: OverlayBreakpointConfig;\n    rightSheet?: OverlayBreakpointConfig;\n  }) {\n    const data: OverlayBreakpointConfigEntry[] = [\n      {\n        config: this.mergeConfigs(this.DEFAULTS.fullScreenDialog, customConfig?.fullScreenDialog ?? {}),\n      },\n      {\n        breakpoint: 'md',\n        config: this.mergeConfigs(this.DEFAULTS.rightSheet, customConfig?.rightSheet ?? {}),\n      },\n    ];\n\n    return data;\n  }\n\n  dialog(customConfig?: OverlayBreakpointConfig) {\n    const data: OverlayBreakpointConfigEntry[] = [\n      {\n        config: this.mergeConfigs(this.DEFAULTS.dialog, customConfig ?? {}),\n      },\n    ];\n\n    return data;\n  }\n\n  fullScreenDialog(customConfig?: OverlayBreakpointConfig) {\n    const data: OverlayBreakpointConfigEntry[] = [\n      {\n        config: this.mergeConfigs(this.DEFAULTS.fullScreenDialog, customConfig ?? {}),\n      },\n    ];\n\n    return data;\n  }\n\n  bottomSheet(customConfig?: OverlayBreakpointConfig) {\n    const data: OverlayBreakpointConfigEntry[] = [\n      {\n        config: this.mergeConfigs(this.DEFAULTS.bottomSheet, customConfig ?? {}),\n      },\n    ];\n\n    return data;\n  }\n\n  topSheet(customConfig?: OverlayBreakpointConfig) {\n    const data: OverlayBreakpointConfigEntry[] = [\n      {\n        config: this.mergeConfigs(this.DEFAULTS.topSheet, customConfig ?? {}),\n      },\n    ];\n\n    return data;\n  }\n\n  leftSheet(customConfig?: OverlayBreakpointConfig) {\n    const data: OverlayBreakpointConfigEntry[] = [\n      {\n        config: this.mergeConfigs(this.DEFAULTS.leftSheet, customConfig ?? {}),\n      },\n    ];\n\n    return data;\n  }\n\n  rightSheet(customConfig?: OverlayBreakpointConfig) {\n    const data: OverlayBreakpointConfigEntry[] = [\n      {\n        config: this.mergeConfigs(this.DEFAULTS.rightSheet, customConfig ?? {}),\n      },\n    ];\n\n    return data;\n  }\n\n  mergeConfigs(...configs: OverlayBreakpointConfig[]) {\n    const config = configs.reduce((acc, curr) => {\n      return {\n        ...acc,\n        ...curr,\n      };\n    }, {} as OverlayBreakpointConfig);\n\n    return config;\n  }\n}\n"]}

package/esm2022/lib/components/overlay/components/overlay/utils/overlay-ref.mjs

@@ -37,7 +37,7 @@ export class OverlayRef {
             .subscribe((event) => {
             if (!this.disableClose) {
                 event.preventDefault();
-                this._closeOverlayVia(this, event.type === 'keydown' ? 'keyboard' : 'mouse');
+                this._closeOverlayVia(event.type === 'keydown' ? 'keyboard' : 'mouse');
             }
         });
     }
@@ -111,9 +111,9 @@ export class OverlayRef {
         this._ref.close(this._result, { focusOrigin: this._closeInteractionType });
         this.componentInstance = null;
     }
-    _closeOverlayVia(ref, interactionType, result) {
-        ref._closeInteractionType = interactionType;
-        return ref.close(result);
+    _closeOverlayVia(interactionType, result) {
+        this._closeInteractionType = interactionType;
+        return this.close(result);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay-ref.js","sourceRoot":"","sources":["../../../../../../../../../../libs/cdk/src/lib/components/overlay/components/overlay/utils/overlay-ref.ts"],"names":[],"mappings":"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","sourcesContent":["import { FocusOrigin } from '@angular/cdk/a11y';\nimport { DialogRef as CdkDialogRef } from '@angular/cdk/dialog';\nimport { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';\nimport { GlobalPositionStrategy } from '@angular/cdk/overlay';\nimport { ComponentRef } from '@angular/core';\nimport { Observable, Subject, filter, merge, skipUntil, take } from 'rxjs';\nimport { OverlayContainerComponent } from '../components';\nimport { OVERLAY_STATE, OverlayConfig, OverlayPosition, OverlayState } from '../types';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class OverlayRef<T = any, R = any> {\n  componentInstance: T | null = null;\n  readonly componentRef: ComponentRef<T> | null = null;\n  disableClose: boolean | undefined;\n  id: string;\n\n  private readonly _afterOpened = new Subject<void>();\n  private readonly _beforeClosed = new Subject<R | undefined>();\n\n  private _result: R | undefined;\n  private _state: OverlayState = OVERLAY_STATE.OPEN;\n  private _closeInteractionType: FocusOrigin | undefined;\n\n  get _cdkRef() {\n    return this._ref;\n  }\n\n  constructor(\n    private _ref: CdkDialogRef<R, T>,\n    config: OverlayConfig,\n    public _containerInstance: OverlayContainerComponent,\n  ) {\n    this.disableClose = config.disableClose;\n    this.id = _ref.id;\n\n    _containerInstance._animatedLifecycle.state$\n      .pipe(\n        filter((event) => event === 'entered'),\n        take(1),\n      )\n      .subscribe(() => {\n        this._afterOpened.next();\n        this._afterOpened.complete();\n      });\n\n    _containerInstance._animatedLifecycle.state$\n      .pipe(\n        filter((event) => event === 'left'),\n        take(1),\n      )\n      .subscribe(() => {\n        this._finishOverlayClose();\n      });\n\n    _ref.overlayRef.detachments().subscribe(() => {\n      this._beforeClosed.next(this._result);\n      this._beforeClosed.complete();\n      this._finishOverlayClose();\n    });\n\n    merge(\n      this.backdropClick(),\n      this.keydownEvents().pipe(\n        filter((event) => event.keyCode === ESCAPE && !this.disableClose && !hasModifierKey(event)),\n      ),\n    )\n      .pipe(skipUntil(_containerInstance._animatedLifecycle.state$.pipe(filter((e) => e === 'entering'))))\n      .subscribe((event) => {\n        if (!this.disableClose) {\n          event.preventDefault();\n          this._closeOverlayVia(this, event.type === 'keydown' ? 'keyboard' : 'mouse');\n        }\n      });\n  }\n\n  close(result?: R): void {\n    if (this._state === OVERLAY_STATE.CLOSING || this._state === OVERLAY_STATE.CLOSED) {\n      return;\n    }\n\n    this._result = result;\n\n    this._containerInstance._animatedLifecycle.state$\n      .pipe(\n        filter((event) => event === 'leaving'),\n        take(1),\n      )\n      .subscribe(() => {\n        this._beforeClosed.next(result);\n        this._beforeClosed.complete();\n        this._ref.overlayRef.detachBackdrop();\n      });\n\n    this._containerInstance._animatedLifecycle.state$\n      .pipe(\n        filter((event) => event === 'left'),\n        take(1),\n      )\n      .subscribe(() => this._finishOverlayClose());\n\n    this._state = OVERLAY_STATE.CLOSING;\n    this._containerInstance._animatedLifecycle.leave();\n  }\n\n  afterOpened(): Observable<void> {\n    return this._afterOpened;\n  }\n\n  afterClosed(): Observable<R | undefined> {\n    return this._ref.closed;\n  }\n\n  beforeClosed(): Observable<R | undefined> {\n    return this._beforeClosed;\n  }\n\n  backdropClick(): Observable<MouseEvent> {\n    return this._ref.backdropClick;\n  }\n\n  keydownEvents(): Observable<KeyboardEvent> {\n    return this._ref.keydownEvents;\n  }\n\n  updatePosition(position?: OverlayPosition): this {\n    const 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  updateSize(width = '', height = ''): this {\n    this._ref.updateSize(width, height);\n    return this;\n  }\n\n  addPanelClass(classes: string | string[]): this {\n    this._ref.addPanelClass(classes);\n    return this;\n  }\n\n  removePanelClass(classes: string | string[]): this {\n    this._ref.removePanelClass(classes);\n    return this;\n  }\n\n  getState(): OverlayState {\n    return this._state;\n  }\n\n  private _finishOverlayClose() {\n    this._state = OVERLAY_STATE.CLOSED;\n    this._ref.close(this._result, { focusOrigin: this._closeInteractionType });\n    this.componentInstance = null;\n  }\n\n  _closeOverlayVia<R>(ref: OverlayRef<R>, interactionType: FocusOrigin, result?: R) {\n    (ref as unknown as { _closeInteractionType: FocusOrigin })._closeInteractionType = interactionType;\n    return ref.close(result);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay-ref.js","sourceRoot":"","sources":["../../../../../../../../../../libs/cdk/src/lib/components/overlay/components/overlay/utils/overlay-ref.ts"],"names":[],"mappings":"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","sourcesContent":["import { FocusOrigin } from '@angular/cdk/a11y';\nimport { DialogRef as CdkDialogRef } from '@angular/cdk/dialog';\nimport { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';\nimport { GlobalPositionStrategy } from '@angular/cdk/overlay';\nimport { ComponentRef } from '@angular/core';\nimport { Observable, Subject, filter, merge, skipUntil, take } from 'rxjs';\nimport { OverlayContainerComponent } from '../components';\nimport { OVERLAY_STATE, OverlayConfig, OverlayPosition, OverlayState } from '../types';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class OverlayRef<T = any, R = any> {\n  componentInstance: T | null = null;\n  readonly componentRef: ComponentRef<T> | null = null;\n  disableClose: boolean | undefined;\n  id: string;\n\n  private readonly _afterOpened = new Subject<void>();\n  private readonly _beforeClosed = new Subject<R | undefined>();\n\n  private _result: R | undefined;\n  private _state: OverlayState = OVERLAY_STATE.OPEN;\n  private _closeInteractionType: FocusOrigin | undefined;\n\n  get _cdkRef() {\n    return this._ref;\n  }\n\n  constructor(\n    private _ref: CdkDialogRef<R, T>,\n    config: OverlayConfig,\n    public _containerInstance: OverlayContainerComponent,\n  ) {\n    this.disableClose = config.disableClose;\n    this.id = _ref.id;\n\n    _containerInstance._animatedLifecycle.state$\n      .pipe(\n        filter((event) => event === 'entered'),\n        take(1),\n      )\n      .subscribe(() => {\n        this._afterOpened.next();\n        this._afterOpened.complete();\n      });\n\n    _containerInstance._animatedLifecycle.state$\n      .pipe(\n        filter((event) => event === 'left'),\n        take(1),\n      )\n      .subscribe(() => {\n        this._finishOverlayClose();\n      });\n\n    _ref.overlayRef.detachments().subscribe(() => {\n      this._beforeClosed.next(this._result);\n      this._beforeClosed.complete();\n      this._finishOverlayClose();\n    });\n\n    merge(\n      this.backdropClick(),\n      this.keydownEvents().pipe(\n        filter((event) => event.keyCode === ESCAPE && !this.disableClose && !hasModifierKey(event)),\n      ),\n    )\n      .pipe(skipUntil(_containerInstance._animatedLifecycle.state$.pipe(filter((e) => e === 'entering'))))\n      .subscribe((event) => {\n        if (!this.disableClose) {\n          event.preventDefault();\n          this._closeOverlayVia(event.type === 'keydown' ? 'keyboard' : 'mouse');\n        }\n      });\n  }\n\n  close(result?: R): void {\n    if (this._state === OVERLAY_STATE.CLOSING || this._state === OVERLAY_STATE.CLOSED) {\n      return;\n    }\n\n    this._result = result;\n\n    this._containerInstance._animatedLifecycle.state$\n      .pipe(\n        filter((event) => event === 'leaving'),\n        take(1),\n      )\n      .subscribe(() => {\n        this._beforeClosed.next(result);\n        this._beforeClosed.complete();\n        this._ref.overlayRef.detachBackdrop();\n      });\n\n    this._containerInstance._animatedLifecycle.state$\n      .pipe(\n        filter((event) => event === 'left'),\n        take(1),\n      )\n      .subscribe(() => this._finishOverlayClose());\n\n    this._state = OVERLAY_STATE.CLOSING;\n    this._containerInstance._animatedLifecycle.leave();\n  }\n\n  afterOpened(): Observable<void> {\n    return this._afterOpened;\n  }\n\n  afterClosed(): Observable<R | undefined> {\n    return this._ref.closed;\n  }\n\n  beforeClosed(): Observable<R | undefined> {\n    return this._beforeClosed;\n  }\n\n  backdropClick(): Observable<MouseEvent> {\n    return this._ref.backdropClick;\n  }\n\n  keydownEvents(): Observable<KeyboardEvent> {\n    return this._ref.keydownEvents;\n  }\n\n  updatePosition(position?: OverlayPosition): this {\n    const 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  updateSize(width = '', height = ''): this {\n    this._ref.updateSize(width, height);\n    return this;\n  }\n\n  addPanelClass(classes: string | string[]): this {\n    this._ref.addPanelClass(classes);\n    return this;\n  }\n\n  removePanelClass(classes: string | string[]): this {\n    this._ref.removePanelClass(classes);\n    return this;\n  }\n\n  getState(): OverlayState {\n    return this._state;\n  }\n\n  private _finishOverlayClose() {\n    this._state = OVERLAY_STATE.CLOSED;\n    this._ref.close(this._result, { focusOrigin: this._closeInteractionType });\n    this.componentInstance = null;\n  }\n\n  _closeOverlayVia(interactionType: FocusOrigin, result?: R) {\n    this._closeInteractionType = interactionType;\n    return this.close(result);\n  }\n}\n"]}