@ethlete/cdk 4.10.1 → 4.11.1

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

@@ -1,5 +1,6 @@
 import { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';
-import { BehaviorSubject, Subject, filter, merge, skipUntil, take } from 'rxjs';
+import { signal } from '@angular/core';
+import { Subject, filter, merge, skipUntil, take } from 'rxjs';
 import { OVERLAY_STATE } from '../types';
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export class OverlayRef {
@@ -30,15 +31,8 @@ export class OverlayRef {
          * @internal
          */
         this._isCloseFnCloseControlledExternally = false;
-        /**
-         * @internal
-         */
-        this._layout$ = new BehaviorSubject({
-            hasHeader: false,
-            hasBody: false,
-            hasFooter: false,
-        });
         this._disableCloseFromInternalInitiators = new Set();
+        this.headerTemplate = signal(null);
         this.disableClose = config.disableClose;
         this.id = _ref.id;
         _containerInstance._animatedLifecycle.state$
@@ -161,11 +155,8 @@ export class OverlayRef {
             return;
         this._disableCloseFromInternalInitiators.delete(initiatorId);
     }
-    _updateLayout(layout) {
-        this._layout$.next({
-            ...this._layout$.value,
-            ...layout,
-        });
+    _setCurrentHeaderTemplate(template) {
+        this.headerTemplate.set(template);
     }
 }
-//# 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 { BehaviorSubject, Subject, filter, merge, skipUntil, take } from 'rxjs';\nimport { OverlayContainerComponent } from '../components/overlay-container';\nimport { OVERLAY_STATE, OverlayConfig, OverlayPosition, OverlayState } from '../types';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport interface OverlayCloseCallEvent<R = any> {\n  result: R | undefined;\n  forced: boolean;\n}\n\nexport interface OverlayLayout {\n  hasHeader: boolean;\n  hasBody: boolean;\n  hasFooter: boolean;\n}\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\n  id: string;\n\n  private readonly _afterOpened = new Subject<void>();\n  private readonly _beforeClosed = new Subject<R | undefined>();\n  private readonly _closeCalled = new Subject<OverlayCloseCallEvent<R>>();\n\n  private _result: R | undefined;\n  private _state: OverlayState = OVERLAY_STATE.OPEN;\n\n  /**\n   * @internal\n   */\n  _closeInteractionType: FocusOrigin | undefined;\n\n  /**\n   * @internal\n   */\n  _isEscCloseControlledExternally = false;\n\n  /**\n   * @internal\n   */\n  _isBackdropCloseControlledExternally = false;\n\n  /**\n   * @internal\n   */\n  _isCloseFnCloseControlledExternally = false;\n\n  /**\n   * @internal\n   */\n  readonly _layout$ = new BehaviorSubject<OverlayLayout>({\n    hasHeader: false,\n    hasBody: false,\n    hasFooter: false,\n  });\n\n  private _disableCloseFromInternalInitiators = new Set<string | number>();\n\n  get _internalDisableClose() {\n    return this._disableCloseFromInternalInitiators.size > 0;\n  }\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 (\n          (this._isEscCloseControlledExternally && event.type === 'keydown') ||\n          (this._isBackdropCloseControlledExternally && event.type !== 'keydown')\n        ) {\n          return;\n        }\n\n        if (!this.disableClose && !this._internalDisableClose) {\n          event.preventDefault();\n          this._closeOverlayVia(event.type === 'keydown' ? 'keyboard' : 'mouse', undefined, true);\n        }\n      });\n  }\n\n  close(result?: R, force?: boolean): void {\n    if (this._state === OVERLAY_STATE.CLOSING || this._state === OVERLAY_STATE.CLOSED) {\n      return;\n    }\n\n    this._closeCalled.next({ result, forced: force ?? false });\n\n    if (this._isCloseFnCloseControlledExternally && !force) {\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() {\n    return this._afterOpened.asObservable();\n  }\n\n  afterClosed() {\n    return this._ref.closed;\n  }\n\n  beforeClosed() {\n    return this._beforeClosed.asObservable();\n  }\n\n  backdropClick() {\n    return this._ref.backdropClick;\n  }\n\n  keydownEvents() {\n    return this._ref.keydownEvents;\n  }\n\n  closeCalled() {\n    return this._closeCalled.asObservable();\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, force?: boolean) {\n    this._closeInteractionType = interactionType;\n    return this.close(result, force);\n  }\n\n  _addInternalBackdropCloseInitiator(initiatorId: string | number) {\n    if (this.disableClose) return;\n\n    this._disableCloseFromInternalInitiators.add(initiatorId);\n  }\n\n  _removeInternalBackdropCloseInitiator(initiatorId: string | number) {\n    if (this.disableClose) return;\n\n    this._disableCloseFromInternalInitiators.delete(initiatorId);\n  }\n\n  _updateLayout(layout: Partial<OverlayLayout>) {\n    this._layout$.next({\n      ...this._layout$.value,\n      ...layout,\n    });\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, TemplateRef, signal } from '@angular/core';\nimport { Subject, filter, merge, skipUntil, take } from 'rxjs';\nimport { OverlayContainerComponent } from '../components/overlay-container';\nimport { OVERLAY_STATE, OverlayConfig, OverlayPosition, OverlayState } from '../types';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport interface OverlayCloseCallEvent<R = any> {\n  result: R | undefined;\n  forced: boolean;\n}\n\nexport interface OverlayLayout {\n  hasHeader: boolean;\n  hasBody: boolean;\n  hasFooter: boolean;\n}\n\nexport interface OverlayHeaderTemplates {\n  current: TemplateRef<unknown> | null;\n  previous: TemplateRef<unknown> | null;\n}\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\n  id: string;\n\n  private readonly _afterOpened = new Subject<void>();\n  private readonly _beforeClosed = new Subject<R | undefined>();\n  private readonly _closeCalled = new Subject<OverlayCloseCallEvent<R>>();\n\n  private _result: R | undefined;\n  private _state: OverlayState = OVERLAY_STATE.OPEN;\n\n  /**\n   * @internal\n   */\n  _closeInteractionType: FocusOrigin | undefined;\n\n  /**\n   * @internal\n   */\n  _isEscCloseControlledExternally = false;\n\n  /**\n   * @internal\n   */\n  _isBackdropCloseControlledExternally = false;\n\n  /**\n   * @internal\n   */\n  _isCloseFnCloseControlledExternally = false;\n\n  private _disableCloseFromInternalInitiators = new Set<string | number>();\n\n  get _internalDisableClose() {\n    return this._disableCloseFromInternalInitiators.size > 0;\n  }\n\n  get _cdkRef() {\n    return this._ref;\n  }\n\n  headerTemplate = signal<TemplateRef<unknown> | null>(null);\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 (\n          (this._isEscCloseControlledExternally && event.type === 'keydown') ||\n          (this._isBackdropCloseControlledExternally && event.type !== 'keydown')\n        ) {\n          return;\n        }\n\n        if (!this.disableClose && !this._internalDisableClose) {\n          event.preventDefault();\n          this._closeOverlayVia(event.type === 'keydown' ? 'keyboard' : 'mouse', undefined, true);\n        }\n      });\n  }\n\n  close(result?: R, force?: boolean): void {\n    if (this._state === OVERLAY_STATE.CLOSING || this._state === OVERLAY_STATE.CLOSED) {\n      return;\n    }\n\n    this._closeCalled.next({ result, forced: force ?? false });\n\n    if (this._isCloseFnCloseControlledExternally && !force) {\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() {\n    return this._afterOpened.asObservable();\n  }\n\n  afterClosed() {\n    return this._ref.closed;\n  }\n\n  beforeClosed() {\n    return this._beforeClosed.asObservable();\n  }\n\n  backdropClick() {\n    return this._ref.backdropClick;\n  }\n\n  keydownEvents() {\n    return this._ref.keydownEvents;\n  }\n\n  closeCalled() {\n    return this._closeCalled.asObservable();\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, force?: boolean) {\n    this._closeInteractionType = interactionType;\n    return this.close(result, force);\n  }\n\n  _addInternalBackdropCloseInitiator(initiatorId: string | number) {\n    if (this.disableClose) return;\n\n    this._disableCloseFromInternalInitiators.add(initiatorId);\n  }\n\n  _removeInternalBackdropCloseInitiator(initiatorId: string | number) {\n    if (this.disableClose) return;\n\n    this._disableCloseFromInternalInitiators.delete(initiatorId);\n  }\n\n  _setCurrentHeaderTemplate(template: TemplateRef<unknown> | null) {\n    this.headerTemplate.set(template);\n  }\n}\n"]}

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

@@ -0,0 +1,190 @@
+import { Injectable, InjectionToken, computed, inject, isSignal, signal } from '@angular/core';
+import { toObservable, toSignal } from '@angular/core/rxjs-interop';
+import { fromNextFrame } from '@ethlete/core';
+import { map, switchMap } from 'rxjs';
+import * as i0 from "@angular/core";
+export const OVERLAY_ROUTER_CONFIG_TOKEN = new InjectionToken('OVERLAY_ROUTER_CONFIG_TOKEN');
+export class OverlayRouterService {
+    constructor() {
+        this.config = inject(OVERLAY_ROUTER_CONFIG_TOKEN);
+        this.syncCurrentRoute = signal('/');
+        // The current route, but delayed by one frame to ensure that the needed animation classes are applied.
+        this.currentRoute = toSignal(toObservable(this.syncCurrentRoute).pipe(switchMap((r) => fromNextFrame().pipe(map(() => r)))), { initialValue: '/' });
+        this.routeHistory = signal([]);
+        this.rootHistoryItem = signal(null);
+        this.extraRoutes = signal([]);
+        this.routes = computed(() => {
+            const allRoutes = [...this.config.routes, ...this.extraRoutes()];
+            const allRoundsWithTransformedInputs = allRoutes.map((route) => {
+                return {
+                    ...route,
+                    inputs: Object.entries(route.inputs ?? {}).reduce((acc, [key, value]) => {
+                        if (isSignal(value)) {
+                            acc[key] = value();
+                        }
+                        else {
+                            acc[key] = value;
+                        }
+                        return acc;
+                    }, {}),
+                };
+            });
+            return allRoundsWithTransformedInputs;
+        });
+        this.currentPage = computed(() => {
+            const currentRoute = this.syncCurrentRoute();
+            for (const route of this.routes()) {
+                if (route.path === currentRoute) {
+                    return route;
+                }
+            }
+            return null;
+        });
+        this.lastPage = computed(() => {
+            const history = this.routeHistory();
+            if (history.length) {
+                return history[history.length - 1];
+            }
+            return null;
+        });
+        this.canGoBack = computed(() => {
+            return this.routeHistory().length;
+        });
+        this.navigationDirection = signal('forward');
+        this._navigateToInitialRoute();
+    }
+    navigate(route) {
+        const resolvedRoute = this.resolvePath(route);
+        if (resolvedRoute.type === 'back') {
+            this.navigationDirection.set('backward');
+        }
+        else {
+            this.navigationDirection.set('forward');
+        }
+        this._updateCurrentRoute(resolvedRoute.route);
+    }
+    back() {
+        const prevRoute = this.lastPage();
+        if (!prevRoute)
+            return;
+        this.navigationDirection.set('backward');
+        this.routeHistory.set(this.routeHistory().slice(0, -1));
+        this._updateCurrentRoute(prevRoute, { updateHistory: false });
+    }
+    resolvePath(route) {
+        if (Array.isArray(route)) {
+            route = route.join('/');
+        }
+        if (route === '') {
+            route = '/';
+        }
+        const isAbsolute = route.startsWith('/');
+        const isReplaceCurrent = route.startsWith('./');
+        const isBack = route.startsWith('../');
+        const isForward = !isAbsolute && !isReplaceCurrent && !isBack;
+        const curr = this.syncCurrentRoute();
+        if (isForward) {
+            route = `${curr}/${route}`;
+        }
+        else if (isReplaceCurrent) {
+            const currSegments = curr.split('/').filter((s) => s !== '');
+            currSegments.pop();
+            const newSegments = route.split('/').filter((s) => s !== '.');
+            route = `/${currSegments.concat(newSegments).join('/')}`;
+        }
+        else if (isBack) {
+            const currSegments = curr.split('/').filter((s) => s !== '');
+            const newSegments = route.split('/').filter((s) => s !== '..');
+            const stepsBack = route.split('/').filter((s) => s === '..').length;
+            for (let i = 0; i < stepsBack; i++) {
+                currSegments.pop();
+            }
+            route = `/${currSegments.concat(newSegments).join('/')}`;
+        }
+        return {
+            route,
+            type: isBack || route === '/'
+                ? 'back'
+                : isReplaceCurrent
+                    ? 'replace-current'
+                    : isAbsolute
+                        ? 'absolute'
+                        : isForward
+                            ? 'forward'
+                            : 'unknown',
+        };
+    }
+    addRoute(route) {
+        this.extraRoutes.set([...this.extraRoutes(), route]);
+    }
+    removeRoute(path) {
+        this.extraRoutes.set(this.extraRoutes().filter((r) => r.path !== path));
+    }
+    _updateCurrentRoute(route, config) {
+        console.log('from', this.syncCurrentRoute(), 'to', route, 'with config', config);
+        if (route === this.syncCurrentRoute())
+            return;
+        if (this.routes().findIndex((r) => r.path === route) === -1) {
+            console.error(`The route "${route}" does not exist.`, this.config);
+            return;
+        }
+        const lastRoute = this.syncCurrentRoute();
+        if (config?.updateHistory === true || config?.updateHistory === undefined) {
+            const history = this.routeHistory();
+            if (history[history.length - 1] !== lastRoute) {
+                const newHistory = [...history, lastRoute];
+                // limit the history to 25 items
+                if (newHistory.length > 25) {
+                    newHistory.shift();
+                }
+                const rootHistoryItem = this.rootHistoryItem();
+                if (rootHistoryItem && newHistory[0] !== rootHistoryItem) {
+                    newHistory.unshift(rootHistoryItem);
+                }
+                this.routeHistory.set(newHistory);
+            }
+        }
+        this.syncCurrentRoute.set(route);
+    }
+    _removeItemFromHistory(item) {
+        const history = this.routeHistory();
+        const cleanedHistory = history.filter((i) => i !== item);
+        console.log({
+            history,
+            cleanedHistory,
+            len: cleanedHistory.length,
+            null: cleanedHistory[0],
+            curr: this.syncCurrentRoute(),
+        });
+        if (cleanedHistory.length === 1 && cleanedHistory[0] === this.syncCurrentRoute()) {
+            this.routeHistory.set([]);
+        }
+        else {
+            this.routeHistory.set(cleanedHistory);
+        }
+    }
+    _navigateToInitialRoute() {
+        if (this.config.initialRoute) {
+            this._updateCurrentRoute(this.config.initialRoute ?? '/', { updateHistory: false });
+        }
+        else {
+            const first = this.config.routes[0]?.path;
+            this._updateCurrentRoute(first ?? '/', { updateHistory: false });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: OverlayRouterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: OverlayRouterService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: OverlayRouterService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+export const provideOverlayRouterConfig = (config) => {
+    return [
+        {
+            provide: OVERLAY_ROUTER_CONFIG_TOKEN,
+            useValue: config,
+        },
+        OverlayRouterService,
+    ];
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay-router.js","sourceRoot":"","sources":["../../../../../../../../../../libs/cdk/src/lib/components/overlay/components/overlay/utils/overlay-router.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentType } from '@angular/cdk/portal';\nimport { Injectable, InjectionToken, computed, inject, isSignal, signal } from '@angular/core';\nimport { toObservable, toSignal } from '@angular/core/rxjs-interop';\nimport { fromNextFrame } from '@ethlete/core';\nimport { map, switchMap } from 'rxjs';\n\nexport const OVERLAY_ROUTER_CONFIG_TOKEN = new InjectionToken<OverlayRouterConfig>('OVERLAY_ROUTER_CONFIG_TOKEN');\n\nexport type OverlayRoute = {\n  /**\n   * The component to render.\n   */\n  component: ComponentType<unknown>;\n\n  /**\n   * The route of the page.\n   *\n   * @example\n   * \"/\" // The root route\n   * \"/two\" // The route \"two\"\n   */\n  path: `/${string}`;\n\n  /**\n   * The inputs to pass to the component.\n   */\n  inputs?: Record<string, unknown>;\n};\n\nexport type OverlayRouterConfig = {\n  /**\n   * The routes to be able to navigate to.\n   */\n  routes: OverlayRoute[];\n\n  /**\n   * The route on which to start.\n   * @default \"\" // The root route\n   * @default routes[0].path // The first route if no root route is defined\n   */\n  initialRoute?: string;\n};\n\nexport type OverlayRouterNavigationDirection = 'forward' | 'backward';\n\n@Injectable()\nexport class OverlayRouterService {\n  config = inject(OVERLAY_ROUTER_CONFIG_TOKEN);\n\n  syncCurrentRoute = signal('/');\n\n  // The current route, but delayed by one frame to ensure that the needed animation classes are applied.\n  currentRoute = toSignal(\n    toObservable(this.syncCurrentRoute).pipe(switchMap((r) => fromNextFrame().pipe(map(() => r)))),\n    { initialValue: '/' },\n  );\n\n  routeHistory = signal<string[]>([]);\n  rootHistoryItem = signal<string | null>(null);\n  extraRoutes = signal<OverlayRoute[]>([]);\n\n  routes = computed(() => {\n    const allRoutes = [...this.config.routes, ...this.extraRoutes()];\n\n    const allRoundsWithTransformedInputs = allRoutes.map((route) => {\n      return {\n        ...route,\n        inputs: Object.entries(route.inputs ?? {}).reduce(\n          (acc, [key, value]) => {\n            if (isSignal(value)) {\n              acc[key] = value();\n            } else {\n              acc[key] = value;\n            }\n\n            return acc;\n          },\n          {} as Record<string, unknown>,\n        ),\n      };\n    });\n\n    return allRoundsWithTransformedInputs;\n  });\n\n  currentPage = computed(() => {\n    const currentRoute = this.syncCurrentRoute();\n\n    for (const route of this.routes()) {\n      if (route.path === currentRoute) {\n        return route;\n      }\n    }\n\n    return null;\n  });\n\n  lastPage = computed(() => {\n    const history = this.routeHistory();\n\n    if (history.length) {\n      return history[history.length - 1];\n    }\n\n    return null;\n  });\n\n  canGoBack = computed(() => {\n    return this.routeHistory().length;\n  });\n\n  navigationDirection = signal<OverlayRouterNavigationDirection>('forward');\n\n  constructor() {\n    this._navigateToInitialRoute();\n  }\n\n  navigate(route: string | (string | number)[]) {\n    const resolvedRoute = this.resolvePath(route);\n\n    if (resolvedRoute.type === 'back') {\n      this.navigationDirection.set('backward');\n    } else {\n      this.navigationDirection.set('forward');\n    }\n\n    this._updateCurrentRoute(resolvedRoute.route);\n  }\n\n  back() {\n    const prevRoute = this.lastPage();\n\n    if (!prevRoute) return;\n\n    this.navigationDirection.set('backward');\n\n    this.routeHistory.set(this.routeHistory().slice(0, -1));\n    this._updateCurrentRoute(prevRoute, { updateHistory: false });\n  }\n\n  resolvePath(route: string | (string | number)[]) {\n    if (Array.isArray(route)) {\n      route = route.join('/');\n    }\n\n    if (route === '') {\n      route = '/';\n    }\n\n    const isAbsolute = route.startsWith('/');\n    const isReplaceCurrent = route.startsWith('./');\n    const isBack = route.startsWith('../');\n    const isForward = !isAbsolute && !isReplaceCurrent && !isBack;\n\n    const curr = this.syncCurrentRoute();\n\n    if (isForward) {\n      route = `${curr}/${route}`;\n    } else if (isReplaceCurrent) {\n      const currSegments = curr.split('/').filter((s) => s !== '');\n      currSegments.pop();\n\n      const newSegments = route.split('/').filter((s) => s !== '.');\n\n      route = `/${currSegments.concat(newSegments).join('/')}`;\n    } else if (isBack) {\n      const currSegments = curr.split('/').filter((s) => s !== '');\n      const newSegments = route.split('/').filter((s) => s !== '..');\n      const stepsBack = route.split('/').filter((s) => s === '..').length;\n\n      for (let i = 0; i < stepsBack; i++) {\n        currSegments.pop();\n      }\n\n      route = `/${currSegments.concat(newSegments).join('/')}`;\n    }\n\n    return {\n      route,\n      type:\n        isBack || route === '/'\n          ? 'back'\n          : isReplaceCurrent\n            ? 'replace-current'\n            : isAbsolute\n              ? 'absolute'\n              : isForward\n                ? 'forward'\n                : 'unknown',\n    } as const;\n  }\n\n  addRoute(route: OverlayRoute) {\n    this.extraRoutes.set([...this.extraRoutes(), route]);\n  }\n\n  removeRoute(path: string) {\n    this.extraRoutes.set(this.extraRoutes().filter((r) => r.path !== path));\n  }\n\n  _updateCurrentRoute(route: string, config?: { updateHistory?: boolean }) {\n    console.log('from', this.syncCurrentRoute(), 'to', route, 'with config', config);\n\n    if (route === this.syncCurrentRoute()) return;\n\n    if (this.routes().findIndex((r) => r.path === route) === -1) {\n      console.error(`The route \"${route}\" does not exist.`, this.config);\n      return;\n    }\n\n    const lastRoute = this.syncCurrentRoute();\n\n    if (config?.updateHistory === true || config?.updateHistory === undefined) {\n      const history = this.routeHistory();\n\n      if (history[history.length - 1] !== lastRoute) {\n        const newHistory = [...history, lastRoute];\n\n        // limit the history to 25 items\n        if (newHistory.length > 25) {\n          newHistory.shift();\n        }\n\n        const rootHistoryItem = this.rootHistoryItem();\n        if (rootHistoryItem && newHistory[0] !== rootHistoryItem) {\n          newHistory.unshift(rootHistoryItem);\n        }\n\n        this.routeHistory.set(newHistory);\n      }\n    }\n\n    this.syncCurrentRoute.set(route);\n  }\n\n  _removeItemFromHistory(item: string) {\n    const history = this.routeHistory();\n    const cleanedHistory = history.filter((i) => i !== item);\n\n    console.log({\n      history,\n      cleanedHistory,\n      len: cleanedHistory.length,\n      null: cleanedHistory[0],\n      curr: this.syncCurrentRoute(),\n    });\n\n    if (cleanedHistory.length === 1 && cleanedHistory[0] === this.syncCurrentRoute()) {\n      this.routeHistory.set([]);\n    } else {\n      this.routeHistory.set(cleanedHistory);\n    }\n  }\n\n  _navigateToInitialRoute() {\n    if (this.config.initialRoute) {\n      this._updateCurrentRoute(this.config.initialRoute ?? '/', { updateHistory: false });\n    } else {\n      const first = this.config.routes[0]?.path;\n      this._updateCurrentRoute(first ?? '/', { updateHistory: false });\n    }\n  }\n}\n\nexport const provideOverlayRouterConfig = (config: OverlayRouterConfig) => {\n  return [\n    {\n      provide: OVERLAY_ROUTER_CONFIG_TOKEN,\n      useValue: config,\n    },\n    OverlayRouterService,\n  ];\n};\n"]}

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

@@ -0,0 +1,63 @@
+import { Injectable, InjectionToken, inject, signal } from '@angular/core';
+import { takeUntilDestroyed, toObservable, toSignal } from '@angular/core/rxjs-interop';
+import { ViewportService } from '@ethlete/core';
+import { distinctUntilChanged, tap } from 'rxjs';
+import { OverlaySidebarPageComponent } from '../partials/overlay-sidebar-page';
+import { OverlayRouterService } from './overlay-router';
+import * as i0 from "@angular/core";
+export const SIDEBAR_OVERLAY_CONFIG = new InjectionToken('SIDEBAR_OVERLAY_CONFIG');
+export class SidebarOverlayService {
+    constructor() {
+        this.config = inject(SIDEBAR_OVERLAY_CONFIG);
+        this.viewportService = inject(ViewportService);
+        this.router = inject(OverlayRouterService);
+        this.renderSidebar = toSignal(this.viewportService.observe({ min: this.config.renderSidebarFrom ?? 'md' }), {
+            initialValue: this.viewportService.isMatched({ min: this.config.renderSidebarFrom ?? 'md' }),
+        });
+        this.sidebarContentTemplate = signal(null);
+        this.sidebarHeaderTemplate = signal(null);
+        const sidebarPageRoute = this.config.sidebarPageRoute ?? '/sidebar';
+        toObservable(this.renderSidebar)
+            .pipe(distinctUntilChanged(), tap((renderSidebar) => {
+            if (renderSidebar) {
+                this.router.removeRoute(sidebarPageRoute);
+                this.router.rootHistoryItem.set(null);
+                // if the user is currently on the sidebar route, navigate to the initial route.
+                if (this.router.currentRoute() === sidebarPageRoute) {
+                    this.router._navigateToInitialRoute();
+                }
+                // clean up all history entries that are the sidebar route.
+                // we don't want to navigate to the sidebar route if the sidebar is already visible as a actual sidebar.
+                this.router._removeItemFromHistory(sidebarPageRoute);
+            }
+            else {
+                this.router.addRoute({
+                    path: sidebarPageRoute,
+                    component: OverlaySidebarPageComponent,
+                    inputs: {
+                        headerTemplate: this.sidebarHeaderTemplate,
+                        bodyTemplate: this.sidebarContentTemplate,
+                    },
+                });
+                // ensure that the sidebar route is always the last route in the history so it can be reached.
+                this.router.rootHistoryItem.set(sidebarPageRoute);
+            }
+        }), takeUntilDestroyed())
+            .subscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: SidebarOverlayService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: SidebarOverlayService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: SidebarOverlayService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+export const provideSidebarOverlayConfig = (config) => {
+    return [
+        {
+            provide: SIDEBAR_OVERLAY_CONFIG,
+            useValue: config,
+        },
+        SidebarOverlayService,
+    ];
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/overlay/components/toggletip/components/toggletip/toggletip.component.mjs

@@ -35,15 +35,15 @@ export class ToggletipComponent {
     _setThemeFromProvider(provider) {
         this._themeProvider.syncWithProvider(provider);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: ToggletipComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.0", type: ToggletipComponent, isStandalone: true, selector: "et-toggletip", host: { properties: { "attr.aria-hidden": "this.attrAriaHidden", "class.et-with-default-animation": "this.usesDefaultAnimation", "class": "this.containerClass" }, classAttribute: "et-toggletip" }, providers: [
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: ToggletipComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.1", type: ToggletipComponent, isStandalone: true, selector: "et-toggletip", host: { properties: { "attr.aria-hidden": "this.attrAriaHidden", "class.et-with-default-animation": "this.usesDefaultAnimation", "class": "this.containerClass" }, classAttribute: "et-toggletip" }, providers: [
             {
                 provide: TOGGLETIP,
                 useExisting: ToggletipComponent,
             },
-        ], viewQueries: [{ propertyName: "_animatedLifecycle", first: true, predicate: ANIMATED_LIFECYCLE_TOKEN, descendants: true, static: true }], hostDirectives: [{ directive: i1.ProvideThemeDirective }], ngImport: i0, template: "<div class=\"et-toggletip-container\" etAnimatedLifecycle>\n  @if (toggletipText) {\n    {{ toggletipText }}\n  }\n\n  @if (toggletipTemplate) {\n    <ng-container *ngTemplateOutlet=\"toggletipTemplate; injector: injector\" />\n  }\n\n  <div class=\"toggletip-arrow\" et-floating-arrow></div>\n</div>\n", styles: [":where(.et-toggletip){--background-color: hsl(0 0% 20%);--foreground-color: CanvasText;--border-radius: 4px;--padding-inline: 1.5ch;--padding-block: .75ch;--inline-max-size: 25ch;--arrow-size: 10px;--arrow-radius: 2px}.et-toggletip{transform:var(--et-floating-translate);will-change:transform}.et-toggletip[et-floating-placement^=top] .toggletip-arrow{bottom:-4px;left:0}.et-toggletip[et-floating-placement^=right] .toggletip-arrow{left:-4px;top:0}.et-toggletip[et-floating-placement^=bottom] .toggletip-arrow{top:-4px;left:0}.et-toggletip[et-floating-placement^=left] .toggletip-arrow{right:-4px;top:0}.et-toggletip-container{z-index:1;inline-size:max-content;max-inline-size:var(--inline-max-size);padding:var(--padding-block) var(--padding-inline);border-radius:var(--border-radius);background:var(--background-color);color:var(--foreground-color);will-change:transform}.et-toggletip-container:before{content:\"; Has toggletip: \";clip:rect(1px,1px,1px,1px);clip-path:inset(50%);height:1px;width:1px;margin:-1px;overflow:hidden;padding:0;position:absolute}.toggletip-arrow{transform:var(--et-floating-arrow-translate);inline-size:var(--arrow-size);block-size:var(--arrow-size);position:absolute;z-index:1;will-change:transform}.toggletip-arrow:before{inline-size:var(--arrow-size);block-size:var(--arrow-size);border-radius:var(--arrow-radius);position:absolute;z-index:-1;transform:rotate(45deg);background:var(--background-color);top:0;left:0;content:\"\"}.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-enter-from,.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-leave-to{opacity:0}.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-enter-from .toggletip-arrow:before,.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-leave-to .toggletip-arrow:before{transform:rotate(45deg) scale(0)}.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-enter-active{transition:transform .2s var(--ease-out-5),opacity .2s var(--ease-out-5)}.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-enter-active .toggletip-arrow:before{transition:transform .2s var(--ease-out-5)}.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-leave-active{transition:transform .15s var(--ease-in-5),opacity .15s var(--ease-in-5)}.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-leave-active .toggletip-arrow:before{transition:transform .15s var(--ease-in-5)}.et-toggletip.et-with-default-animation[et-floating-placement^=top] .et-toggletip-container.et-animation-enter-from,.et-toggletip.et-with-default-animation[et-floating-placement^=top] .et-toggletip-container.et-animation-leave-to{transform:translateY(5px)}.et-toggletip.et-with-default-animation[et-floating-placement^=right] .et-toggletip-container.et-animation-enter-from,.et-toggletip.et-with-default-animation[et-floating-placement^=right] .et-toggletip-container.et-animation-leave-to{transform:translate(-5px)}.et-toggletip.et-with-default-animation[et-floating-placement^=bottom] .et-toggletip-container.et-animation-enter-from,.et-toggletip.et-with-default-animation[et-floating-placement^=bottom] .et-toggletip-container.et-animation-leave-to{transform:translateY(-5px)}.et-toggletip.et-with-default-animation[et-floating-placement^=left] .et-toggletip-container.et-animation-enter-from,.et-toggletip.et-with-default-animation[et-floating-placement^=left] .et-toggletip-container.et-animation-leave-to{transform:translate(5px)}\n"], dependencies: [{ kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: AnimatedLifecycleDirective, selector: "[etAnimatedLifecycle]", exportAs: ["etAnimatedLifecycle"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+        ], viewQueries: [{ propertyName: "_animatedLifecycle", first: true, predicate: ANIMATED_LIFECYCLE_TOKEN, descendants: true, static: true }], hostDirectives: [{ directive: i1.ProvideThemeDirective }], ngImport: i0, template: "<div class=\"et-toggletip-container\" etAnimatedLifecycle>\n  @if (toggletipText) {\n    {{ toggletipText }}\n  }\n\n  @if (toggletipTemplate) {\n    <ng-container *ngTemplateOutlet=\"toggletipTemplate; injector: injector\" />\n  }\n\n  <div class=\"toggletip-arrow\" et-floating-arrow></div>\n</div>\n", styles: [":where(.et-toggletip){--background-color: hsl(0 0% 20%);--foreground-color: CanvasText;--border-radius: 4px;--padding-inline: 1.5ch;--padding-block: .75ch;--inline-max-size: 25ch;--arrow-size: 10px;--arrow-radius: 2px}.et-toggletip{transform:var(--et-floating-translate);will-change:transform}.et-toggletip[et-floating-placement^=top] .toggletip-arrow{bottom:-4px;left:0}.et-toggletip[et-floating-placement^=right] .toggletip-arrow{left:-4px;top:0}.et-toggletip[et-floating-placement^=bottom] .toggletip-arrow{top:-4px;left:0}.et-toggletip[et-floating-placement^=left] .toggletip-arrow{right:-4px;top:0}.et-toggletip-container{z-index:1;inline-size:max-content;max-inline-size:var(--inline-max-size);padding:var(--padding-block) var(--padding-inline);border-radius:var(--border-radius);background:var(--background-color);color:var(--foreground-color);will-change:transform}.et-toggletip-container:before{content:\"; Has toggletip: \";clip:rect(1px,1px,1px,1px);clip-path:inset(50%);height:1px;width:1px;margin:-1px;overflow:hidden;padding:0;position:absolute}.toggletip-arrow{transform:var(--et-floating-arrow-translate);inline-size:var(--arrow-size);block-size:var(--arrow-size);position:absolute;z-index:1;will-change:transform}.toggletip-arrow:before{inline-size:var(--arrow-size);block-size:var(--arrow-size);border-radius:var(--arrow-radius);position:absolute;z-index:-1;transform:rotate(45deg);background:var(--background-color);top:0;left:0;content:\"\"}.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-enter-from,.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-leave-to{opacity:0}.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-enter-from .toggletip-arrow:before,.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-leave-to .toggletip-arrow:before{transform:rotate(45deg) scale(0)}.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-enter-active{transition:transform .2s var(--ease-out-5),opacity .2s var(--ease-out-5)}.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-enter-active .toggletip-arrow:before{transition:transform .2s var(--ease-out-5)}.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-leave-active{transition:transform .15s var(--ease-in-5),opacity .15s var(--ease-in-5)}.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-leave-active .toggletip-arrow:before{transition:transform .15s var(--ease-in-5)}.et-toggletip.et-with-default-animation[et-floating-placement^=top] .et-toggletip-container.et-animation-enter-from,.et-toggletip.et-with-default-animation[et-floating-placement^=top] .et-toggletip-container.et-animation-leave-to{transform:translateY(5px)}.et-toggletip.et-with-default-animation[et-floating-placement^=right] .et-toggletip-container.et-animation-enter-from,.et-toggletip.et-with-default-animation[et-floating-placement^=right] .et-toggletip-container.et-animation-leave-to{transform:translate(-5px)}.et-toggletip.et-with-default-animation[et-floating-placement^=bottom] .et-toggletip-container.et-animation-enter-from,.et-toggletip.et-with-default-animation[et-floating-placement^=bottom] .et-toggletip-container.et-animation-leave-to{transform:translateY(-5px)}.et-toggletip.et-with-default-animation[et-floating-placement^=left] .et-toggletip-container.et-animation-enter-from,.et-toggletip.et-with-default-animation[et-floating-placement^=left] .et-toggletip-container.et-animation-leave-to{transform:translate(5px)}\n"], dependencies: [{ kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: AnimatedLifecycleDirective, selector: "[etAnimatedLifecycle]", inputs: ["skipNextEnter"], outputs: ["skipNextEnterChange"], exportAs: ["etAnimatedLifecycle"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: ToggletipComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: ToggletipComponent, decorators: [{
             type: Component,
             args: [{ selector: 'et-toggletip', standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, imports: [NgTemplateOutlet, AnimatedLifecycleDirective], hostDirectives: [ProvideThemeDirective], host: {
                         class: 'et-toggletip',

package/esm2022/lib/components/overlay/components/toggletip/directives/toggletip/toggletip.directive.mjs

@@ -104,15 +104,15 @@ export class ToggletipDirective {
             ],
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: ToggletipDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.0", type: ToggletipDirective, isStandalone: true, selector: "[etToggletip]", inputs: { toggletip: ["etToggletip", "toggletip"], showToggletip: "showToggletip" }, outputs: { toggletipClose: "toggletipClose" }, providers: [
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: ToggletipDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.1", type: ToggletipDirective, isStandalone: true, selector: "[etToggletip]", inputs: { toggletip: ["etToggletip", "toggletip"], showToggletip: "showToggletip" }, outputs: { toggletipClose: "toggletipClose" }, providers: [
             {
                 provide: TOGGLETIP_DIRECTIVE,
                 useExisting: ToggletipDirective,
             },
         ], hostDirectives: [{ directive: i1.AnimatedOverlayDirective, inputs: ["placement", "placement"] }, { directive: i2.OverlayCloseBlockerDirective }], ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: ToggletipDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: ToggletipDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[etToggletip]',

package/esm2022/lib/components/overlay/components/toggletip/partials/toggletip-close/toggletip-close.directive.mjs

@@ -8,10 +8,10 @@ export class ToggletipCloseDirective {
     _onButtonClick() {
         this._toggletipDirective._trigger._animatedOverlay.unmount();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: ToggletipCloseDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.0", type: ToggletipCloseDirective, isStandalone: true, selector: "[et-toggletip-close], [etToggletipClose]", host: { listeners: { "click": "_onButtonClick($event)" } }, exportAs: ["etToggletipClose"], ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: ToggletipCloseDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.1", type: ToggletipCloseDirective, isStandalone: true, selector: "[et-toggletip-close], [etToggletipClose]", host: { listeners: { "click": "_onButtonClick($event)" } }, exportAs: ["etToggletipClose"], ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: ToggletipCloseDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: ToggletipCloseDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[et-toggletip-close], [etToggletipClose]',

package/esm2022/lib/components/overlay/components/tooltip/components/tooltip/tooltip.component.mjs

@@ -33,15 +33,15 @@ export class TooltipComponent {
     _setThemeFromProvider(provider) {
         this._themeProvider.syncWithProvider(provider);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: TooltipComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.0", type: TooltipComponent, isStandalone: true, selector: "et-tooltip", host: { properties: { "attr.aria-hidden": "this.attrAriaHidden", "class.et-with-default-animation": "this.usesDefaultAnimation", "class": "this.containerClass" }, classAttribute: "et-tooltip" }, providers: [
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: TooltipComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.1", type: TooltipComponent, isStandalone: true, selector: "et-tooltip", host: { properties: { "attr.aria-hidden": "this.attrAriaHidden", "class.et-with-default-animation": "this.usesDefaultAnimation", "class": "this.containerClass" }, classAttribute: "et-tooltip" }, providers: [
             {
                 provide: TOOLTIP,
                 useExisting: TooltipComponent,
             },
-        ], viewQueries: [{ propertyName: "_animatedLifecycle", first: true, predicate: ANIMATED_LIFECYCLE_TOKEN, descendants: true, static: true }], hostDirectives: [{ directive: i1.ProvideThemeDirective }], ngImport: i0, template: "<div class=\"et-tooltip-container\" etAnimatedLifecycle>\n  @if (tooltipText) {\n    {{ tooltipText }}\n  }\n\n  @if (tooltipTemplate) {\n    <ng-container *ngTemplateOutlet=\"tooltipTemplate; injector: injector\" />\n  }\n\n  <div class=\"tooltip-arrow\" et-floating-arrow></div>\n</div>\n", styles: [":where(.et-tooltip){--background-color: hsl(0 0% 20%);--foreground-color: CanvasText;--border-radius: 4px;--padding-inline: 1.5ch;--padding-block: .75ch;--inline-max-size: 25ch;--arrow-size: 10px;--arrow-radius: 2px}.et-tooltip{pointer-events:none;-webkit-user-select:none;user-select:none;transform:var(--et-floating-translate);will-change:transform}.et-tooltip[et-floating-placement^=top] .tooltip-arrow{bottom:-4px;left:0}.et-tooltip[et-floating-placement^=right] .tooltip-arrow{left:-4px;top:0}.et-tooltip[et-floating-placement^=bottom] .tooltip-arrow{top:-4px;left:0}.et-tooltip[et-floating-placement^=left] .tooltip-arrow{right:-4px;top:0}.et-tooltip-container{z-index:1;inline-size:max-content;max-inline-size:var(--inline-max-size);padding:var(--padding-block) var(--padding-inline);border-radius:var(--border-radius);background:var(--background-color);color:var(--foreground-color);will-change:transform}.et-tooltip-container:before{content:\"; Has tooltip: \";clip:rect(1px,1px,1px,1px);clip-path:inset(50%);height:1px;width:1px;margin:-1px;overflow:hidden;padding:0;position:absolute}.tooltip-arrow{inline-size:var(--arrow-size);block-size:var(--arrow-size);position:absolute;z-index:1;transform:var(--et-floating-arrow-translate);will-change:transform}.tooltip-arrow:before{inline-size:var(--arrow-size);block-size:var(--arrow-size);border-radius:var(--arrow-radius);position:absolute;z-index:-1;transform:rotate(45deg);background:var(--background-color);top:0;left:0;content:\"\"}.et-tooltip.et-with-default-animation .et-tooltip-container.et-animation-enter-from,.et-tooltip.et-with-default-animation .et-tooltip-container.et-animation-leave-to{opacity:0}.et-tooltip.et-with-default-animation .et-tooltip-container.et-animation-enter-active{transition:transform .3s var(--ease-out-5),opacity .3s var(--ease-out-5)}.et-tooltip.et-with-default-animation .et-tooltip-container.et-animation-leave-active{transition:transform .15s var(--ease-in-5),opacity .15s var(--ease-in-5)}.et-tooltip.et-with-default-animation[et-floating-placement^=top] .et-tooltip-container.et-animation-enter-from,.et-tooltip.et-with-default-animation[et-floating-placement^=top] .et-tooltip-container.et-animation-leave-to{transform:translateY(5px)}.et-tooltip.et-with-default-animation[et-floating-placement^=right] .et-tooltip-container.et-animation-enter-from,.et-tooltip.et-with-default-animation[et-floating-placement^=right] .et-tooltip-container.et-animation-leave-to{transform:translate(-5px)}.et-tooltip.et-with-default-animation[et-floating-placement^=bottom] .et-tooltip-container.et-animation-enter-from,.et-tooltip.et-with-default-animation[et-floating-placement^=bottom] .et-tooltip-container.et-animation-leave-to{transform:translateY(-5px)}.et-tooltip.et-with-default-animation[et-floating-placement^=left] .et-tooltip-container.et-animation-enter-from,.et-tooltip.et-with-default-animation[et-floating-placement^=left] .et-tooltip-container.et-animation-leave-to{transform:translate(5px)}\n"], dependencies: [{ kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: AnimatedLifecycleDirective, selector: "[etAnimatedLifecycle]", exportAs: ["etAnimatedLifecycle"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+        ], viewQueries: [{ propertyName: "_animatedLifecycle", first: true, predicate: ANIMATED_LIFECYCLE_TOKEN, descendants: true, static: true }], hostDirectives: [{ directive: i1.ProvideThemeDirective }], ngImport: i0, template: "<div class=\"et-tooltip-container\" etAnimatedLifecycle>\n  @if (tooltipText) {\n    {{ tooltipText }}\n  }\n\n  @if (tooltipTemplate) {\n    <ng-container *ngTemplateOutlet=\"tooltipTemplate; injector: injector\" />\n  }\n\n  <div class=\"tooltip-arrow\" et-floating-arrow></div>\n</div>\n", styles: [":where(.et-tooltip){--background-color: hsl(0 0% 20%);--foreground-color: CanvasText;--border-radius: 4px;--padding-inline: 1.5ch;--padding-block: .75ch;--inline-max-size: 25ch;--arrow-size: 10px;--arrow-radius: 2px}.et-tooltip{pointer-events:none;-webkit-user-select:none;user-select:none;transform:var(--et-floating-translate);will-change:transform}.et-tooltip[et-floating-placement^=top] .tooltip-arrow{bottom:-4px;left:0}.et-tooltip[et-floating-placement^=right] .tooltip-arrow{left:-4px;top:0}.et-tooltip[et-floating-placement^=bottom] .tooltip-arrow{top:-4px;left:0}.et-tooltip[et-floating-placement^=left] .tooltip-arrow{right:-4px;top:0}.et-tooltip-container{z-index:1;inline-size:max-content;max-inline-size:var(--inline-max-size);padding:var(--padding-block) var(--padding-inline);border-radius:var(--border-radius);background:var(--background-color);color:var(--foreground-color);will-change:transform}.et-tooltip-container:before{content:\"; Has tooltip: \";clip:rect(1px,1px,1px,1px);clip-path:inset(50%);height:1px;width:1px;margin:-1px;overflow:hidden;padding:0;position:absolute}.tooltip-arrow{inline-size:var(--arrow-size);block-size:var(--arrow-size);position:absolute;z-index:1;transform:var(--et-floating-arrow-translate);will-change:transform}.tooltip-arrow:before{inline-size:var(--arrow-size);block-size:var(--arrow-size);border-radius:var(--arrow-radius);position:absolute;z-index:-1;transform:rotate(45deg);background:var(--background-color);top:0;left:0;content:\"\"}.et-tooltip.et-with-default-animation .et-tooltip-container.et-animation-enter-from,.et-tooltip.et-with-default-animation .et-tooltip-container.et-animation-leave-to{opacity:0}.et-tooltip.et-with-default-animation .et-tooltip-container.et-animation-enter-active{transition:transform .3s var(--ease-out-5),opacity .3s var(--ease-out-5)}.et-tooltip.et-with-default-animation .et-tooltip-container.et-animation-leave-active{transition:transform .15s var(--ease-in-5),opacity .15s var(--ease-in-5)}.et-tooltip.et-with-default-animation[et-floating-placement^=top] .et-tooltip-container.et-animation-enter-from,.et-tooltip.et-with-default-animation[et-floating-placement^=top] .et-tooltip-container.et-animation-leave-to{transform:translateY(5px)}.et-tooltip.et-with-default-animation[et-floating-placement^=right] .et-tooltip-container.et-animation-enter-from,.et-tooltip.et-with-default-animation[et-floating-placement^=right] .et-tooltip-container.et-animation-leave-to{transform:translate(-5px)}.et-tooltip.et-with-default-animation[et-floating-placement^=bottom] .et-tooltip-container.et-animation-enter-from,.et-tooltip.et-with-default-animation[et-floating-placement^=bottom] .et-tooltip-container.et-animation-leave-to{transform:translateY(-5px)}.et-tooltip.et-with-default-animation[et-floating-placement^=left] .et-tooltip-container.et-animation-enter-from,.et-tooltip.et-with-default-animation[et-floating-placement^=left] .et-tooltip-container.et-animation-leave-to{transform:translate(5px)}\n"], dependencies: [{ kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: AnimatedLifecycleDirective, selector: "[etAnimatedLifecycle]", inputs: ["skipNextEnter"], outputs: ["skipNextEnterChange"], exportAs: ["etAnimatedLifecycle"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: TooltipComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: TooltipComponent, decorators: [{
             type: Component,
             args: [{ selector: 'et-tooltip', standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, imports: [NgTemplateOutlet, AnimatedLifecycleDirective], hostDirectives: [ProvideThemeDirective], host: {
                         class: 'et-tooltip',

package/esm2022/lib/components/overlay/components/tooltip/directives/tooltip/tooltip.directive.mjs

@@ -141,15 +141,15 @@ export class TooltipDirective {
                 ? this.tooltip
                 : null;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: TooltipDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.0", type: TooltipDirective, isStandalone: true, selector: "[etTooltip]", inputs: { tooltip: ["etTooltip", "tooltip"], tooltipAriaDescription: "tooltipAriaDescription" }, providers: [
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: TooltipDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.1", type: TooltipDirective, isStandalone: true, selector: "[etTooltip]", inputs: { tooltip: ["etTooltip", "tooltip"], tooltipAriaDescription: "tooltipAriaDescription" }, providers: [
             {
                 provide: TOOLTIP_DIRECTIVE,
                 useExisting: TooltipDirective,
             },
         ], hostDirectives: [{ directive: i1.AnimatedOverlayDirective, inputs: ["placement", "placement"] }, { directive: i2.OverlayCloseBlockerDirective }], ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: TooltipDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: TooltipDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[etTooltip]',

package/esm2022/lib/components/overlay/directives/dynamic-overlay-title/dynamic-overlay-title.directive.mjs

@@ -27,10 +27,10 @@ export class DynamicOverlayTitleDirective {
         }
         Promise.resolve().then(() => this._overlayRef?._containerInstance?._ariaLabelledByQueue?.push(this.id));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: DynamicOverlayTitleDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.0", type: DynamicOverlayTitleDirective, isStandalone: true, selector: "[et-dynamic-overlay-title], [etDynamicOverlayTitle]", inputs: { id: "id" }, host: { properties: { "attr.id": "this.id" }, classAttribute: "et-dynamic-overlay-title" }, exportAs: ["etDynamicOverlayTitle"], ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: DynamicOverlayTitleDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.1", type: DynamicOverlayTitleDirective, isStandalone: true, selector: "[et-dynamic-overlay-title], [etDynamicOverlayTitle]", inputs: { id: "id" }, host: { properties: { "attr.id": "this.id" }, classAttribute: "et-dynamic-overlay-title" }, exportAs: ["etDynamicOverlayTitle"], ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: DynamicOverlayTitleDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: DynamicOverlayTitleDirective, decorators: [{
             type: Directive,
             args: [{
                     // eslint-disable-next-line @angular-eslint/directive-selector

package/esm2022/lib/components/overlay/directives/overlay-close-auto-blocker/overlay-close-auto-blocker.directive.mjs

@@ -27,15 +27,15 @@ export class OverlayCloseBlockerDirective {
     ngOnDestroy() {
         this._nearestOverlayRef?._removeInternalBackdropCloseInitiator(this._id);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: OverlayCloseBlockerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.0", type: OverlayCloseBlockerDirective, isStandalone: true, selector: "[etOverlayCloseBlocker]", providers: [
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: OverlayCloseBlockerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.1", type: OverlayCloseBlockerDirective, isStandalone: true, selector: "[etOverlayCloseBlocker]", providers: [
             {
                 provide: OVERLAY_CLOSE_BLOCKER_TOKEN,
                 useExisting: OverlayCloseBlockerDirective,
             },
         ], ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: OverlayCloseBlockerDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: OverlayCloseBlockerDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[etOverlayCloseBlocker]',