@ethlete/cdk 4.28.0 → 4.28.2

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

@@ -0,0 +1,287 @@
+import { coerceCssPixelValue } from '@angular/cdk/coercion';
+import { Dialog as CdkDialog, DialogConfig as CdkDialogConfig } from '@angular/cdk/dialog';
+import { Injectable, inject } from '@angular/core';
+import { ROOT_BOUNDARY_TOKEN, RootBoundaryDirective, ViewportService, createDestroy, equal } from '@ethlete/core';
+import { ProvideThemeDirective, THEME_PROVIDER } from '@ethlete/theming';
+import { Subject, combineLatest, defer, map, of, pairwise, startWith, takeUntil, tap } from 'rxjs';
+import { OverlayContainerComponent } from '../components/overlay-container';
+import { OVERLAY_CONFIG, OVERLAY_DATA, OVERLAY_DEFAULT_OPTIONS, OVERLAY_SCROLL_STRATEGY } from '../constants';
+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-';
+const setStyle = (el, style, value) => {
+    if (value === null || value === undefined) {
+        el.style.removeProperty(style);
+    }
+    else {
+        el.style.setProperty(style, coerceCssPixelValue(value));
+    }
+};
+const setClass = (el, prevClass, currClass) => {
+    if (!equal(prevClass, currClass)) {
+        if (prevClass) {
+            if (Array.isArray(prevClass)) {
+                el.classList.remove(...prevClass);
+            }
+            else {
+                el.classList.remove(prevClass);
+            }
+        }
+        if (currClass) {
+            if (Array.isArray(currClass)) {
+                el.classList.add(...currClass);
+            }
+            else {
+                el.classList.add(currClass);
+            }
+        }
+    }
+};
+const isHtmlElement = (element) => {
+    return element instanceof HTMLElement;
+};
+const isTouchEvent = (event) => {
+    return event.type[0] === 't';
+};
+const isPointerEvent = (event) => {
+    return event.type[0] === 'c';
+};
+export class OverlayService {
+    constructor() {
+        this._destroy$ = createDestroy();
+        this._defaultOptions = inject(OVERLAY_DEFAULT_OPTIONS, { optional: true });
+        this._scrollStrategy = inject(OVERLAY_SCROLL_STRATEGY);
+        this._parentOverlayService = inject(OverlayService, { optional: true, skipSelf: true });
+        this._dialog = inject(CdkDialog);
+        this._viewportService = inject(ViewportService);
+        this._openOverlaysAtThisLevel = [];
+        this._afterAllClosedAtThisLevel = new Subject();
+        this._afterOpenedAtThisLevel = new Subject();
+        this.positions = new OverlayPositionBuilder();
+        this.afterAllClosed = defer(() => this.openOverlays.length ? this._getAfterAllClosed() : this._getAfterAllClosed().pipe(startWith(undefined)));
+    }
+    get openOverlays() {
+        return this._parentOverlayService ? this._parentOverlayService.openOverlays : this._openOverlaysAtThisLevel;
+    }
+    get afterOpened() {
+        return this._parentOverlayService ? this._parentOverlayService.afterOpened : this._afterOpenedAtThisLevel;
+    }
+    ngOnDestroy() {
+        this._closeOverlays(this._openOverlaysAtThisLevel);
+        this._afterAllClosedAtThisLevel.complete();
+        this._afterOpenedAtThisLevel.complete();
+    }
+    open(componentOrTemplateRef, config) {
+        let overlayRef;
+        const composedConfig = createOverlayConfig(this._defaultOptions, config);
+        composedConfig.id = composedConfig.id || `${ID_PREFIX}${uniqueId++}`;
+        composedConfig.scrollStrategy = composedConfig.scrollStrategy || this._scrollStrategy();
+        const cdkRef = this._dialog.open(componentOrTemplateRef, {
+            ...composedConfig,
+            disableClose: true,
+            closeOnDestroy: false,
+            panelClass: 'et-overlay-pane',
+            container: {
+                type: OverlayContainerComponent,
+                providers: () => [
+                    { provide: OVERLAY_CONFIG, useValue: composedConfig },
+                    { provide: CdkDialogConfig, useValue: composedConfig },
+                ],
+            },
+            templateContext: () => ({ dialogRef: overlayRef }),
+            providers: (ref, cdkConfig, overlayContainer) => {
+                const container = overlayContainer;
+                overlayRef = new OverlayRef(ref, composedConfig, container);
+                return [
+                    { provide: OverlayContainerComponent, useValue: overlayContainer },
+                    { provide: THEME_PROVIDER, useValue: container._themeProvider },
+                    { provide: ProvideThemeDirective, useValue: container._themeProvider },
+                    { provide: ROOT_BOUNDARY_TOKEN, useValue: container._rootBoundary },
+                    { provide: RootBoundaryDirective, useValue: container._rootBoundary },
+                    { provide: OVERLAY_DATA, useValue: cdkConfig.data },
+                    { provide: OverlayRef, useValue: overlayRef },
+                    ...(composedConfig.providers ?? []),
+                ];
+            },
+        });
+        /* eslint-disable @typescript-eslint/no-non-null-assertion*/
+        overlayRef.componentRef = cdkRef.componentRef;
+        overlayRef.componentInstance = cdkRef.componentInstance;
+        cdkRef.containerInstance.overlayRef = overlayRef;
+        const containerEl = overlayRef._containerInstance.elementRef.nativeElement;
+        const overlayPaneEl = cdkRef.overlayRef.overlayElement;
+        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 origin = composedConfig.origin;
+        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 containerClass = currConfig.containerClass;
+            const applyDefaultMaxWidths = () => {
+                setStyle(overlayPaneEl, 'max-width', currConfig.maxWidth);
+                setStyle(overlayPaneEl, 'max-height', currConfig.maxHeight);
+            };
+            const combineOrMakeCalc = (value, append) => {
+                if (!value)
+                    return append;
+                if (typeof value === 'number') {
+                    return `calc(${value}px + ${append})`;
+                }
+                else if (value.startsWith('calc(')) {
+                    return `${value.slice(0, value.length - 1)} + ${append})`;
+                }
+                return `calc(${value} + ${append})`;
+            };
+            if (origin) {
+                // TODO: If getBoundingClientRect is used it should use the center of the element.
+                const originX = isHtmlElement(origin)
+                    ? origin.getBoundingClientRect().left
+                    : isTouchEvent(origin)
+                        ? origin.targetTouches[0].clientX
+                        : isPointerEvent(origin)
+                            ? origin.clientX !== 0
+                                ? origin.clientX
+                                : origin.target.getBoundingClientRect().left
+                            : -1;
+                const originY = isHtmlElement(origin)
+                    ? origin.getBoundingClientRect().top
+                    : isTouchEvent(origin)
+                        ? origin.targetTouches[0].clientY
+                        : isPointerEvent(origin)
+                            ? origin.clientY !== 0
+                                ? origin.clientY
+                                : origin.target.getBoundingClientRect().top
+                            : -1;
+                if (originX !== -1 && originY !== -1 && currConfig.applyTransformOrigin) {
+                    setStyle(containerEl, 'transform-origin', `${originX}px ${originY}px`);
+                }
+                else {
+                    setStyle(containerEl, 'transform-origin', null);
+                }
+            }
+            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);
+                }
+                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 {
+                    applyDefaultMaxWidths();
+                }
+            }
+            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)
+                return;
+            this.openOverlays.splice(index, 1);
+            if (!this.openOverlays.length) {
+                this._getAfterAllClosed().next();
+            }
+        });
+        return overlayRef;
+        /* eslint-enable @typescript-eslint/no-non-null-assertion*/
+    }
+    closeAll() {
+        this._closeOverlays(this.openOverlays);
+    }
+    getOverlayById(id) {
+        return this.openOverlays.find((overlay) => overlay.id === id);
+    }
+    _closeOverlays(overlays) {
+        let i = overlays.length;
+        while (i--) {
+            overlays[i]?.close();
+        }
+    }
+    _getAfterAllClosed() {
+        const parent = this._parentOverlayService;
+        return parent ? parent._getAfterAllClosed() : this._afterAllClosedAtThisLevel;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: OverlayService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: OverlayService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", 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 { ROOT_BOUNDARY_TOKEN, RootBoundaryDirective, ViewportService, createDestroy, equal } from '@ethlete/core';\nimport { ProvideThemeDirective, THEME_PROVIDER } from '@ethlete/theming';\nimport { Observable, Subject, combineLatest, defer, map, of, pairwise, startWith, takeUntil, tap } from 'rxjs';\nimport { OverlayContainerComponent } from '../components/overlay-container';\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\nconst isHtmlElement = (element: HTMLElement | unknown): element is HTMLElement => {\n  return element instanceof HTMLElement;\n};\n\nconst isTouchEvent = (event: Event): event is TouchEvent => {\n  return event.type[0] === 't';\n};\n\nconst isPointerEvent = (event: Event): event is PointerEvent => {\n  return event.type[0] === 'c';\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        const container = overlayContainer as OverlayContainerComponent;\n        overlayRef = new OverlayRef(ref, composedConfig, container);\n\n        return [\n          { provide: OverlayContainerComponent, useValue: overlayContainer },\n          { provide: THEME_PROVIDER, useValue: container._themeProvider },\n          { provide: ProvideThemeDirective, useValue: container._themeProvider },\n          { provide: ROOT_BOUNDARY_TOKEN, useValue: container._rootBoundary },\n          { provide: RootBoundaryDirective, useValue: container._rootBoundary },\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    const containerEl = overlayRef!._containerInstance.elementRef.nativeElement as HTMLElement;\n    const overlayPaneEl = cdkRef.overlayRef.overlayElement;\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 origin = composedConfig.origin;\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 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 (origin) {\n            // TODO: If getBoundingClientRect is used it should use the center of the element.\n            const originX = isHtmlElement(origin)\n              ? origin.getBoundingClientRect().left\n              : isTouchEvent(origin)\n                ? origin.targetTouches[0]!.clientX\n                : isPointerEvent(origin)\n                  ? origin.clientX !== 0\n                    ? origin.clientX\n                    : (origin.target as HTMLElement).getBoundingClientRect().left\n                  : -1;\n            const originY = isHtmlElement(origin)\n              ? origin.getBoundingClientRect().top\n              : isTouchEvent(origin)\n                ? origin.targetTouches[0]!.clientY\n                : isPointerEvent(origin)\n                  ? origin.clientY !== 0\n                    ? origin.clientY\n                    : (origin.target as HTMLElement).getBoundingClientRect().top\n                  : -1;\n\n            if (originX !== -1 && originY !== -1 && currConfig.applyTransformOrigin) {\n              setStyle(containerEl, 'transform-origin', `${originX}px ${originY}px`);\n            } else {\n              setStyle(containerEl, 'transform-origin', null);\n            }\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/index.mjs

@@ -0,0 +1,2 @@
+export * from './overlay.types';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2NvbXBvbmVudHMvb3ZlcmxheS9jb21wb25lbnRzL292ZXJsYXkvdHlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vb3ZlcmxheS50eXBlcyc7XG4iXX0=

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

@@ -0,0 +1,6 @@
+export const OVERLAY_STATE = {
+    OPEN: 'open',
+    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, 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  /**\n   * Whether the transform origin should be set using the config's `origin` property value.\n   *\n   * @default false\n   */\n  applyTransformOrigin?: boolean;\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`). Will be automatically set to false if the overlay contains a overlay router.\n   * @default true\n   */\n  closeOnNavigation?: boolean;\n\n  /**\n   * Extra providers to be made available to the overlay.\n   *\n   * **WARNING**: Avoid providing `@Injectable()` classes such as services here, as they will never be destroyed.\n   * This could lead to memory leaks over time.\n   */\n  providers?: StaticProvider[];\n\n  /**\n   * The origin element that triggered the overlay's opening.\n   */\n  origin?: HTMLElement | MouseEvent | TouchEvent | KeyboardEvent | PointerEvent;\n}\n"]}

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

@@ -0,0 +1,124 @@
+import { Injectable, InjectionToken, computed, inject, isDevMode } from '@angular/core';
+import { toObservable, toSignal } from '@angular/core/rxjs-interop';
+import { cloneFormGroup, controlValueSignal, getFormGroupValue } from '@ethlete/core';
+import { isQueryStateFailure, isQueryStateLoading, isQueryStateSuccess, queryComputed, switchQueryState, } from '@ethlete/query';
+import { OverlayRef } from './overlay-ref';
+import * as i0 from "@angular/core";
+export const FILTER_OVERLAY_CONFIG = new InjectionToken('FILTER_OVERLAY_CONFIG');
+export const defaultSubmitButtonConfigFn = (config) => {
+    const { queryState, totalHits, locale = 'en' } = config;
+    const isInitializing = queryState === null && totalHits === null;
+    if (isQueryStateLoading(queryState) || isInitializing) {
+        return {
+            disabled: true,
+            label: locale === 'en' ? 'Loading results...' : 'Lade Ergebnisse...',
+        };
+    }
+    else if (isQueryStateFailure(queryState)) {
+        return {
+            disabled: true,
+            label: locale === 'en' ? 'An error occurred' : 'Ein Fehler ist aufgetreten',
+        };
+    }
+    else if (totalHits !== null) {
+        if (totalHits === 0) {
+            return {
+                disabled: true,
+                label: locale === 'en' ? 'No results found' : 'Keine Ergebnisse gefunden',
+            };
+        }
+        else if (totalHits === 1) {
+            return {
+                disabled: false,
+                label: locale === 'en' ? 'Show one result' : 'Zeige ein Ergebnis',
+            };
+        }
+        else if (totalHits > 250) {
+            return {
+                disabled: false,
+                label: locale === 'en' ? 'Show more than 250 results' : 'Zeige mehr als 250 Ergebnisse',
+            };
+        }
+        else {
+            return {
+                disabled: false,
+                label: locale === 'en' ? `Show ${totalHits} results` : `Zeige ${totalHits} Ergebnisse`,
+            };
+        }
+    }
+    if (isDevMode()) {
+        console.error('The default submit button config function resulted in an unknown state. The fallback state might be invalid and should be checked.', config);
+    }
+    // This should never happen
+    return {
+        disabled: true,
+        label: locale === 'en' ? 'No results found' : 'Keine Ergebnisse gefunden',
+    };
+};
+export class FilterOverlayService {
+    constructor() {
+        this.config = inject(FILTER_OVERLAY_CONFIG);
+        this.overlayRef = inject(OverlayRef);
+        this.form = cloneFormGroup(this.config.form);
+        this.formValue = controlValueSignal(this.form);
+        this.searchPreviewQuery = queryComputed(() => {
+            const formVal = this.formValue();
+            if (!this.config.searchPreviewQueryFn || !formVal) {
+                return null;
+            }
+            return this.config.searchPreviewQueryFn(formVal);
+        });
+        this.searchPreviewQueryState = toSignal(toObservable(this.searchPreviewQuery).pipe(switchQueryState()), {
+            initialValue: null,
+        });
+        this.searchPreviewTotalHits = computed(() => {
+            const state = this.searchPreviewQueryState();
+            if (isQueryStateSuccess(state)) {
+                if (this.config.totalHitsExtractorFn) {
+                    return this.config.totalHitsExtractorFn(state.response);
+                }
+                if (!state.response || typeof state.response !== 'object' || !('totalHits' in state.response)) {
+                    console.error(`The response does not contain a totalHits property.`, state.response);
+                    return null;
+                }
+                return state.response.totalHits;
+            }
+            return null;
+        });
+        this.submitButtonConfig = computed(() => {
+            const state = this.searchPreviewQueryState();
+            const totalHits = this.searchPreviewTotalHits();
+            return (this.config.submitButtonConfigFn?.({ queryState: state, totalHits }) ??
+                defaultSubmitButtonConfigFn({ queryState: state, totalHits }));
+        });
+    }
+    submit() {
+        const value = getFormGroupValue(this.form);
+        this.config.form.setValue(value);
+        this.close({ didUpdate: true, formValue: value });
+    }
+    reset() {
+        if (!this.config.defaults) {
+            throw new Error(`The default form value is not defined.`);
+        }
+        this.form.patchValue(this.config.defaults);
+    }
+    close(data) {
+        this.overlayRef?.close(data);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: FilterOverlayService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: FilterOverlayService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: FilterOverlayService, decorators: [{
+            type: Injectable
+        }] });
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const provideFilterOverlayConfig = (config) => {
+    return [
+        {
+            provide: FILTER_OVERLAY_CONFIG,
+            useValue: config,
+        },
+    ];
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filter-overlay.js","sourceRoot":"","sources":["../../../../../../../../../../libs/cdk/src/lib/components/overlay/components/overlay/utils/filter-overlay.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentType } from '@angular/cdk/portal';\nimport { Injectable, InjectionToken, Provider, computed, inject, isDevMode } from '@angular/core';\nimport { toObservable, toSignal } from '@angular/core/rxjs-interop';\nimport { FormGroup } from '@angular/forms';\nimport { cloneFormGroup, controlValueSignal, getFormGroupValue } from '@ethlete/core';\nimport {\n  AnyQuery,\n  QueryResponseOf,\n  QueryState,\n  isQueryStateFailure,\n  isQueryStateLoading,\n  isQueryStateSuccess,\n  queryComputed,\n  switchQueryState,\n} from '@ethlete/query';\nimport { OverlayRef } from './overlay-ref';\n\nexport const FILTER_OVERLAY_CONFIG = new InjectionToken<FilterOverlayConfig>('FILTER_OVERLAY_CONFIG');\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type FilterOverlayConfig<F extends FormGroup<any> = FormGroup<any>, Q extends AnyQuery = AnyQuery> = {\n  /**\n   * The form to use.\n   */\n  form: F;\n\n  /**\n   * The default form value. Used when the form is reset.\n   */\n  defaults?: ReturnType<F['getRawValue']>;\n\n  /**\n   * A function to create a query based on the form value.\n   */\n  searchPreviewQueryFn?: (formValue: ReturnType<F['getRawValue']>) => Q;\n\n  /**\n   * A function to extract the total hits from the response.\n   * @default `response.totalHits`\n   */\n  totalHitsExtractorFn?: (response: QueryResponseOf<Q>) => number;\n\n  /**\n   * A function to create the submit button config based on the query state and the total hits.\n   * If a german translation is needed, manually provide the `defaultSubmitButtonConfigFn` and set the locale to `de`.\n   * @default defaultSubmitButtonConfigFn()\n   */\n  submitButtonConfigFn?: (\n    config: DefaultSubmitButtonConfigFnConfig<QueryResponseOf<Q>>,\n  ) => FilterOverlaySubmitButtonConfig;\n};\n\nexport type FilterOverlaySubmitButtonConfig = {\n  label: string;\n  disabled: boolean;\n};\n\nexport type DefaultSubmitButtonConfigFnConfig<ResponseType = unknown> = {\n  queryState: QueryState<ResponseType> | null;\n  totalHits: number | null;\n  locale?: 'en' | 'de';\n};\n\nexport const defaultSubmitButtonConfigFn = (\n  config: DefaultSubmitButtonConfigFnConfig,\n): FilterOverlaySubmitButtonConfig => {\n  const { queryState, totalHits, locale = 'en' } = config;\n\n  const isInitializing = queryState === null && totalHits === null;\n\n  if (isQueryStateLoading(queryState) || isInitializing) {\n    return {\n      disabled: true,\n      label: locale === 'en' ? 'Loading results...' : 'Lade Ergebnisse...',\n    };\n  } else if (isQueryStateFailure(queryState)) {\n    return {\n      disabled: true,\n      label: locale === 'en' ? 'An error occurred' : 'Ein Fehler ist aufgetreten',\n    };\n  } else if (totalHits !== null) {\n    if (totalHits === 0) {\n      return {\n        disabled: true,\n        label: locale === 'en' ? 'No results found' : 'Keine Ergebnisse gefunden',\n      };\n    } else if (totalHits === 1) {\n      return {\n        disabled: false,\n        label: locale === 'en' ? 'Show one result' : 'Zeige ein Ergebnis',\n      };\n    } else if (totalHits > 250) {\n      return {\n        disabled: false,\n        label: locale === 'en' ? 'Show more than 250 results' : 'Zeige mehr als 250 Ergebnisse',\n      };\n    } else {\n      return {\n        disabled: false,\n        label: locale === 'en' ? `Show ${totalHits} results` : `Zeige ${totalHits} Ergebnisse`,\n      };\n    }\n  }\n\n  if (isDevMode()) {\n    console.error(\n      'The default submit button config function resulted in an unknown state. The fallback state might be invalid and should be checked.',\n      config,\n    );\n  }\n\n  // This should never happen\n  return {\n    disabled: true,\n    label: locale === 'en' ? 'No results found' : 'Keine Ergebnisse gefunden',\n  };\n};\n\nexport type FilterOverlayResult<FormValue = unknown> =\n  | {\n      didUpdate: false;\n    }\n  | {\n      didUpdate: true;\n      formValue: FormValue;\n    };\n\n@Injectable()\nexport class FilterOverlayService<F extends FormGroup, C extends ComponentType<unknown> | unknown = unknown> {\n  config = inject<FilterOverlayConfig<F>>(FILTER_OVERLAY_CONFIG);\n  overlayRef = inject<OverlayRef<C, FilterOverlayResult>>(OverlayRef);\n\n  form = cloneFormGroup(this.config.form as F);\n\n  formValue = controlValueSignal(this.form);\n  searchPreviewQuery = queryComputed(() => {\n    const formVal = this.formValue();\n\n    if (!this.config.searchPreviewQueryFn || !formVal) {\n      return null;\n    }\n\n    return this.config.searchPreviewQueryFn(formVal);\n  });\n\n  searchPreviewQueryState = toSignal(toObservable(this.searchPreviewQuery).pipe(switchQueryState()), {\n    initialValue: null,\n  });\n\n  searchPreviewTotalHits = computed(() => {\n    const state = this.searchPreviewQueryState();\n\n    if (isQueryStateSuccess(state)) {\n      if (this.config.totalHitsExtractorFn) {\n        return this.config.totalHitsExtractorFn(state.response);\n      }\n\n      if (!state.response || typeof state.response !== 'object' || !('totalHits' in state.response)) {\n        console.error(`The response does not contain a totalHits property.`, state.response);\n        return null;\n      }\n\n      return state.response.totalHits as number;\n    }\n\n    return null;\n  });\n\n  submitButtonConfig = computed(() => {\n    const state = this.searchPreviewQueryState();\n    const totalHits = this.searchPreviewTotalHits();\n\n    return (\n      this.config.submitButtonConfigFn?.({ queryState: state, totalHits }) ??\n      defaultSubmitButtonConfigFn({ queryState: state, totalHits })\n    );\n  });\n\n  submit() {\n    const value = getFormGroupValue(this.form);\n    this.config.form.setValue(value);\n\n    this.close({ didUpdate: true, formValue: value });\n  }\n\n  reset() {\n    if (!this.config.defaults) {\n      throw new Error(`The default form value is not defined.`);\n    }\n\n    this.form.patchValue(this.config.defaults);\n  }\n\n  close(data?: FilterOverlayResult) {\n    this.overlayRef?.close(data);\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const provideFilterOverlayConfig = <F extends FormGroup<any> = FormGroup<any>, Q extends AnyQuery = AnyQuery>(\n  config: FilterOverlayConfig<F, Q>,\n): Provider[] => {\n  return [\n    {\n      provide: FILTER_OVERLAY_CONFIG,\n      useValue: config,\n    },\n  ];\n};\n"]}

package/esm2022/lib/components/overlay/components/overlay/utils/index.mjs

@@ -0,0 +1,8 @@
+export * from './filter-overlay';
+export * from './overlay-config';
+export * from './overlay-position-builder';
+export * from './overlay-ref';
+export * from './overlay-router';
+export * from './overlay.utils';
+export * from './sidebar-overlay';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2NvbXBvbmVudHMvb3ZlcmxheS9jb21wb25lbnRzL292ZXJsYXkvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsbUJBQW1CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2ZpbHRlci1vdmVybGF5JztcbmV4cG9ydCAqIGZyb20gJy4vb3ZlcmxheS1jb25maWcnO1xuZXhwb3J0ICogZnJvbSAnLi9vdmVybGF5LXBvc2l0aW9uLWJ1aWxkZXInO1xuZXhwb3J0ICogZnJvbSAnLi9vdmVybGF5LXJlZic7XG5leHBvcnQgKiBmcm9tICcuL292ZXJsYXktcm91dGVyJztcbmV4cG9ydCAqIGZyb20gJy4vb3ZlcmxheS51dGlscyc7XG5leHBvcnQgKiBmcm9tICcuL3NpZGViYXItb3ZlcmxheSc7XG4iXX0=

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

@@ -0,0 +1,7 @@
+import { OVERLAY_DEFAULT_CONFIG } from '../constants';
+export const createOverlayConfig = (globalConfig, localConfig) => ({
+    ...OVERLAY_DEFAULT_CONFIG,
+    ...(globalConfig || {}),
+    ...(localConfig || {}),
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcmxheS1jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2NvbXBvbmVudHMvb3ZlcmxheS9jb21wb25lbnRzL292ZXJsYXkvdXRpbHMvb3ZlcmxheS1jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sY0FBYyxDQUFDO0FBR3RELE1BQU0sQ0FBQyxNQUFNLG1CQUFtQixHQUFHLENBQ2pDLFlBQTJELEVBQzNELFdBQTBELEVBQ3hDLEVBQUUsQ0FBQyxDQUFDO0lBQ3RCLEdBQUksc0JBQTJDO0lBQy9DLEdBQUcsQ0FBQyxZQUFZLElBQUksRUFBRSxDQUFDO0lBQ3ZCLEdBQUcsQ0FBQyxXQUFXLElBQUksRUFBRSxDQUFDO0NBQ3ZCLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE9WRVJMQVlfREVGQVVMVF9DT05GSUcgfSBmcm9tICcuLi9jb25zdGFudHMnO1xuaW1wb3J0IHsgT3ZlcmxheUNvbmZpZyB9IGZyb20gJy4uL3R5cGVzJztcblxuZXhwb3J0IGNvbnN0IGNyZWF0ZU92ZXJsYXlDb25maWcgPSA8RCA9IHVua25vd24+KFxuICBnbG9iYWxDb25maWc/OiBQYXJ0aWFsPE92ZXJsYXlDb25maWc8RD4+IHwgbnVsbCB8IHVuZGVmaW5lZCxcbiAgbG9jYWxDb25maWc/OiBQYXJ0aWFsPE92ZXJsYXlDb25maWc8RD4+IHwgbnVsbCB8IHVuZGVmaW5lZCxcbik6IE92ZXJsYXlDb25maWc8RD4gPT4gKHtcbiAgLi4uKE9WRVJMQVlfREVGQVVMVF9DT05GSUcgYXMgT3ZlcmxheUNvbmZpZzxEPiksXG4gIC4uLihnbG9iYWxDb25maWcgfHwge30pLFxuICAuLi4obG9jYWxDb25maWcgfHwge30pLFxufSk7XG4iXX0=