@ethlete/cdk 4.28.0 → 4.28.2

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

@@ -0,0 +1,190 @@
+import { DestroyRef, InjectionToken, computed, inject, isSignal, signal } from '@angular/core';
+import { takeUntilDestroyed, toObservable, toSignal } from '@angular/core/rxjs-interop';
+import { Router } from '@angular/router';
+import { RouterStateService, createComponentId, fromNextFrame } from '@ethlete/core';
+import { map, skip, switchMap, tap } from 'rxjs';
+import { OverlayRef } from './overlay-ref';
+export const OVERLAY_ROUTER_CONFIG_TOKEN = new InjectionToken('OVERLAY_ROUTER_CONFIG_TOKEN');
+export class OverlayRouterService {
+    constructor() {
+        this._router = inject(Router);
+        this._routerStateService = inject(RouterStateService);
+        this._id = createComponentId('ovr');
+        this._overlayRef = inject(OverlayRef);
+        this._config = inject(OVERLAY_ROUTER_CONFIG_TOKEN);
+        this._syncCurrentRoute = signal(this._getInitialRoute());
+        this._nativeBrowserTempBackNavigationStack = 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._getInitialRoute() });
+        this.extraRoutes = signal([]);
+        this.transitionType = signal('slide');
+        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.navigationDirection = signal('forward');
+        this._disableCloseOnNavigation();
+        this._updateBrowserUrl(this._syncCurrentRoute());
+        this._routerStateService
+            .selectQueryParam(this._id)
+            .pipe(takeUntilDestroyed(), skip(1), tap((route) => {
+            // The user navigated back or forward using the browser history
+            if (!route) {
+                // The route query param no longer exists - close the overlay
+                this._overlayRef.close();
+            }
+            else if (route !== this._syncCurrentRoute()) {
+                const navStack = this._nativeBrowserTempBackNavigationStack();
+                const currentRoute = this._syncCurrentRoute();
+                if (!navStack.length) {
+                    // If the nav stack is empty the only way to navigate is back.
+                    this.navigate(route, { navigationDirection: 'backward' });
+                    this._nativeBrowserTempBackNavigationStack.set([currentRoute]);
+                }
+                else {
+                    const lastItem = navStack[navStack.length - 1];
+                    if (route === lastItem) {
+                        // The new route matches the last item in the back nav stack.
+                        // This means we are going forward again.
+                        this.navigate(route, { navigationDirection: 'forward' });
+                        this._nativeBrowserTempBackNavigationStack.set(navStack.slice(0, -1));
+                    }
+                    else {
+                        // Else we are going back.
+                        this.navigate(route, { navigationDirection: 'backward' });
+                        this._nativeBrowserTempBackNavigationStack.set([...navStack, currentRoute]);
+                    }
+                }
+            }
+            else {
+                // The navigation was triggered by ui interaction. Clear the back nav stack.
+                this._nativeBrowserTempBackNavigationStack.set([]);
+            }
+        }))
+            .subscribe();
+        inject(DestroyRef).onDestroy(() => {
+            // Remove the dialog route from the browser url
+            this._updateBrowserUrl(undefined);
+        });
+    }
+    navigate(route, config) {
+        const resolvedRoute = this.resolvePath(route);
+        if (config?.navigationDirection) {
+            this.navigationDirection.set(config.navigationDirection);
+        }
+        else if (resolvedRoute.type === 'back') {
+            this.navigationDirection.set('backward');
+        }
+        else {
+            this.navigationDirection.set('forward');
+        }
+        this._updateCurrentRoute(resolvedRoute.route);
+    }
+    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) {
+        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;
+        }
+        this._syncCurrentRoute.set(route);
+        this._updateBrowserUrl(route);
+    }
+    _getInitialRoute() {
+        return this._config.initialRoute ?? this._config.routes[0]?.path ?? '/';
+    }
+    _navigateToInitialRoute() {
+        this._updateCurrentRoute(this._getInitialRoute());
+    }
+    _updateBrowserUrl(route) {
+        this._router.navigate([this._routerStateService.route], {
+            queryParams: { [this._id]: route },
+            queryParamsHandling: 'merge',
+        });
+    }
+    _disableCloseOnNavigation() {
+        // @ts-expect-error - private property
+        this._overlayRef._cdkRef.overlayRef._locationChanges?.unsubscribe?.();
+    }
+}
+export const provideOverlayRouterConfig = (config) => {
+    return [
+        {
+            provide: OVERLAY_ROUTER_CONFIG_TOKEN,
+            useValue: config,
+        },
+    ];
+};
+//# 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 { DestroyRef, InjectionToken, Provider, computed, inject, isSignal, signal } from '@angular/core';\nimport { takeUntilDestroyed, toObservable, toSignal } from '@angular/core/rxjs-interop';\nimport { Router } from '@angular/router';\nimport { RouterStateService, createComponentId, fromNextFrame } from '@ethlete/core';\nimport { map, skip, switchMap, tap } from 'rxjs';\nimport { OverlayRef } from './overlay-ref';\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\nexport type OverlayRouterNavigateConfig = {\n  navigationDirection?: OverlayRouterNavigationDirection;\n};\n\nexport type OverlayRouterTransitionType = 'slide' | 'fade' | 'overlay' | 'vertical' | 'none';\n\nexport class OverlayRouterService {\n  _router = inject(Router);\n  _routerStateService = inject(RouterStateService);\n  _id = createComponentId('ovr');\n  _overlayRef = inject(OverlayRef);\n  _config = inject(OVERLAY_ROUTER_CONFIG_TOKEN);\n\n  _syncCurrentRoute = signal(this._getInitialRoute());\n  _nativeBrowserTempBackNavigationStack = signal<string[]>([]);\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: this._getInitialRoute() },\n  );\n\n  extraRoutes = signal<OverlayRoute[]>([]);\n\n  transitionType = signal<OverlayRouterTransitionType>('slide');\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  navigationDirection = signal<OverlayRouterNavigationDirection>('forward');\n\n  constructor() {\n    this._disableCloseOnNavigation();\n    this._updateBrowserUrl(this._syncCurrentRoute());\n\n    this._routerStateService\n      .selectQueryParam(this._id)\n      .pipe(\n        takeUntilDestroyed(),\n        skip(1),\n        tap((route) => {\n          // The user navigated back or forward using the browser history\n          if (!route) {\n            // The route query param no longer exists - close the overlay\n            this._overlayRef.close();\n          } else if (route !== this._syncCurrentRoute()) {\n            const navStack = this._nativeBrowserTempBackNavigationStack();\n            const currentRoute = this._syncCurrentRoute();\n\n            if (!navStack.length) {\n              // If the nav stack is empty the only way to navigate is back.\n              this.navigate(route, { navigationDirection: 'backward' });\n              this._nativeBrowserTempBackNavigationStack.set([currentRoute]);\n            } else {\n              const lastItem = navStack[navStack.length - 1];\n\n              if (route === lastItem) {\n                // The new route matches the last item in the back nav stack.\n                // This means we are going forward again.\n                this.navigate(route, { navigationDirection: 'forward' });\n                this._nativeBrowserTempBackNavigationStack.set(navStack.slice(0, -1));\n              } else {\n                // Else we are going back.\n                this.navigate(route, { navigationDirection: 'backward' });\n                this._nativeBrowserTempBackNavigationStack.set([...navStack, currentRoute]);\n              }\n            }\n          } else {\n            // The navigation was triggered by ui interaction. Clear the back nav stack.\n            this._nativeBrowserTempBackNavigationStack.set([]);\n          }\n        }),\n      )\n      .subscribe();\n\n    inject(DestroyRef).onDestroy(() => {\n      // Remove the dialog route from the browser url\n      this._updateBrowserUrl(undefined);\n    });\n  }\n\n  navigate(route: string | (string | number)[], config?: OverlayRouterNavigateConfig) {\n    const resolvedRoute = this.resolvePath(route);\n    if (config?.navigationDirection) {\n      this.navigationDirection.set(config.navigationDirection);\n    } else 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  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) {\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    this._syncCurrentRoute.set(route);\n\n    this._updateBrowserUrl(route);\n  }\n\n  _getInitialRoute() {\n    return this._config.initialRoute ?? this._config.routes[0]?.path ?? '/';\n  }\n\n  _navigateToInitialRoute() {\n    this._updateCurrentRoute(this._getInitialRoute());\n  }\n\n  _updateBrowserUrl(route: string | undefined) {\n    this._router.navigate([this._routerStateService.route], {\n      queryParams: { [this._id]: route },\n      queryParamsHandling: 'merge',\n    });\n  }\n\n  private _disableCloseOnNavigation() {\n    // @ts-expect-error - private property\n    this._overlayRef._cdkRef.overlayRef._locationChanges?.unsubscribe?.();\n  }\n}\n\nexport const provideOverlayRouterConfig = (config: OverlayRouterConfig): Provider[] => {\n  return [\n    {\n      provide: OVERLAY_ROUTER_CONFIG_TOKEN,\n      useValue: config,\n    },\n  ];\n};\n"]}

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

@@ -0,0 +1,13 @@
+import { OVERLAY_DEFAULT_OPTIONS } from '../constants';
+import { createOverlayConfig } from './overlay-config';
+export function getClosestOverlay(element, openOverlays) {
+    let parent = element.nativeElement.parentElement;
+    while (parent && !parent.classList.contains('et-overlay')) {
+        parent = parent.parentElement;
+    }
+    return parent ? openOverlays.find((overlay) => overlay.id === parent?.id) : null;
+}
+export const provideOverlayDefaultConfig = (config = {}) => {
+    return { provide: OVERLAY_DEFAULT_OPTIONS, useValue: createOverlayConfig(config) };
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,54 @@
+import { 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';
+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);
+        this.sidebarPageDividers = signal(false);
+        const sidebarPageRoute = this.config.sidebarPageRoute ?? '/sidebar';
+        toObservable(this.renderSidebar)
+            .pipe(distinctUntilChanged(), tap((renderSidebar) => {
+            if (renderSidebar) {
+                this.router.transitionType.set('vertical');
+                this.router.removeRoute(sidebarPageRoute);
+                // if the user is currently on the sidebar route, navigate to the initial route.
+                if (this.router.currentRoute() === sidebarPageRoute) {
+                    this.router._navigateToInitialRoute();
+                }
+            }
+            else {
+                this.router.transitionType.set('overlay');
+                this.router.addRoute({
+                    path: sidebarPageRoute,
+                    component: OverlaySidebarPageComponent,
+                    inputs: {
+                        headerTemplate: this.sidebarHeaderTemplate,
+                        bodyTemplate: this.sidebarContentTemplate,
+                        pageDividers: this.sidebarPageDividers,
+                    },
+                });
+            }
+        }), takeUntilDestroyed())
+            .subscribe();
+    }
+}
+export const provideSidebarOverlayConfig = (config) => {
+    return [
+        {
+            provide: SIDEBAR_OVERLAY_CONFIG,
+            useValue: config,
+        },
+    ];
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,2 @@
+export * from './toggletip.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2NvbXBvbmVudHMvb3ZlcmxheS9jb21wb25lbnRzL3RvZ2dsZXRpcC9jb21wb25lbnRzL3RvZ2dsZXRpcC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHVCQUF1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90b2dnbGV0aXAuY29tcG9uZW50JztcbiJdfQ==

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

@@ -0,0 +1,69 @@
+import { NgTemplateOutlet } from '@angular/common';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, HostBinding, InjectionToken, Injector, ViewChild, ViewEncapsulation, inject, } from '@angular/core';
+import { ANIMATED_LIFECYCLE_TOKEN, AnimatedLifecycleDirective } from '@ethlete/core';
+import { ProvideThemeDirective, THEME_PROVIDER } from '@ethlete/theming';
+import { TOGGLETIP_CONFIG, TOGGLETIP_TEMPLATE, TOGGLETIP_TEXT } from '../../constants';
+import { TOGGLETIP_DIRECTIVE } from '../../directives/toggletip';
+import * as i0 from "@angular/core";
+import * as i1 from "@ethlete/theming";
+export const TOGGLETIP = new InjectionToken('Toggletip');
+// TODO(TRB): The focus should get trapped inside the toggletip.
+// The toggletip trigger should get a aria-haspopup="true" and aria-expanded="true" attribute.
+export class ToggletipComponent {
+    constructor() {
+        this._config = inject(TOGGLETIP_CONFIG);
+        this.toggletipText = inject(TOGGLETIP_TEXT, { optional: true });
+        this.toggletipTemplate = inject(TOGGLETIP_TEMPLATE, { optional: true });
+        this._themeProvider = inject(THEME_PROVIDER);
+        this.injector = inject(Injector);
+        this._cdr = inject(ChangeDetectorRef);
+        this._trigger = inject(TOGGLETIP_DIRECTIVE);
+        this._elementRef = inject(ElementRef);
+    }
+    get attrAriaHidden() {
+        return true;
+    }
+    get usesDefaultAnimation() {
+        return !this._config.customAnimated;
+    }
+    get containerClass() {
+        return this._config.containerClass;
+    }
+    _markForCheck() {
+        this._cdr.markForCheck();
+    }
+    _setThemeFromProvider(provider) {
+        this._themeProvider.syncWithProvider(provider);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: ToggletipComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.6", 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]", inputs: ["skipNextEnter"], outputs: ["stateChange", "skipNextEnterChange"], exportAs: ["etAnimatedLifecycle"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", 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',
+                    }, providers: [
+                        {
+                            provide: TOGGLETIP,
+                            useExisting: ToggletipComponent,
+                        },
+                    ], 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"] }]
+        }], propDecorators: { _animatedLifecycle: [{
+                type: ViewChild,
+                args: [ANIMATED_LIFECYCLE_TOKEN, { static: true }]
+            }], attrAriaHidden: [{
+                type: HostBinding,
+                args: ['attr.aria-hidden']
+            }], usesDefaultAnimation: [{
+                type: HostBinding,
+                args: ['class.et-with-default-animation']
+            }], containerClass: [{
+                type: HostBinding,
+                args: ['class']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9nZ2xldGlwLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY2RrL3NyYy9saWIvY29tcG9uZW50cy9vdmVybGF5L2NvbXBvbmVudHMvdG9nZ2xldGlwL2NvbXBvbmVudHMvdG9nZ2xldGlwL3RvZ2dsZXRpcC5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2NvbXBvbmVudHMvb3ZlcmxheS9jb21wb25lbnRzL3RvZ2dsZXRpcC9jb21wb25lbnRzL3RvZ2dsZXRpcC90b2dnbGV0aXAuY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDbkQsT0FBTyxFQUNMLHVCQUF1QixFQUN2QixpQkFBaUIsRUFDakIsU0FBUyxFQUNULFVBQVUsRUFDVixXQUFXLEVBQ1gsY0FBYyxFQUNkLFFBQVEsRUFDUixTQUFTLEVBQ1QsaUJBQWlCLEVBQ2pCLE1BQU0sR0FDUCxNQUFNLGVBQWUsQ0FBQztBQUN2QixPQUFPLEVBQUUsd0JBQXdCLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDckYsT0FBTyxFQUFFLHFCQUFxQixFQUFFLGNBQWMsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ3pFLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxrQkFBa0IsRUFBRSxjQUFjLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUN2RixPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQzs7O0FBRWpFLE1BQU0sQ0FBQyxNQUFNLFNBQVMsR0FBRyxJQUFJLGNBQWMsQ0FBcUIsV0FBVyxDQUFDLENBQUM7QUFFN0UsZ0VBQWdFO0FBQ2hFLDhGQUE4RjtBQW9COUYsTUFBTSxPQUFPLGtCQUFrQjtJQW5CL0I7UUF1Qm1CLFlBQU8sR0FBRyxNQUFNLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztRQUNqQyxrQkFBYSxHQUFHLE1BQU0sQ0FBQyxjQUFjLEVBQUUsRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztRQUMzRCxzQkFBaUIsR0FBRyxNQUFNLENBQUMsa0JBQWtCLEVBQUUsRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztRQUNyRSxtQkFBYyxHQUFHLE1BQU0sQ0FBQyxjQUFjLENBQUMsQ0FBQztRQUN0QyxhQUFRLEdBQUcsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBQzlCLFNBQUksR0FBRyxNQUFNLENBQUMsaUJBQWlCLENBQUMsQ0FBQztRQUN6QyxhQUFRLEdBQUcsTUFBTSxDQUFDLG1CQUFtQixDQUFDLENBQUM7UUFDdkMsZ0JBQVcsR0FBRyxNQUFNLENBQTBCLFVBQVUsQ0FBQyxDQUFDO0tBd0JwRTtJQXRCQyxJQUNJLGNBQWM7UUFDaEIsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0lBRUQsSUFDSSxvQkFBb0I7UUFDdEIsT0FBTyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsY0FBYyxDQUFDO0lBQ3RDLENBQUM7SUFFRCxJQUNJLGNBQWM7UUFDaEIsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDLGNBQWMsQ0FBQztJQUNyQyxDQUFDO0lBRUQsYUFBYTtRQUNYLElBQUksQ0FBQyxJQUFJLENBQUMsWUFBWSxFQUFFLENBQUM7SUFDM0IsQ0FBQztJQUVELHFCQUFxQixDQUFDLFFBQStCO1FBQ25ELElBQUksQ0FBQyxjQUFjLENBQUMsZ0JBQWdCLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDakQsQ0FBQzs4R0FsQ1Usa0JBQWtCO2tHQUFsQixrQkFBa0IsZ1FBUGxCO1lBQ1Q7Z0JBQ0UsT0FBTyxFQUFFLFNBQVM7Z0JBQ2xCLFdBQVcsRUFBRSxrQkFBa0I7YUFDaEM7U0FDRiw4RUFHVSx3QkFBd0IseUhDMUNyQyxnVEFXQSxvakhEa0JZLGdCQUFnQixvSkFBRSwwQkFBMEI7OzJGQVkzQyxrQkFBa0I7a0JBbkI5QixTQUFTOytCQUNFLGNBQWMsY0FHWixJQUFJLG1CQUNDLHVCQUF1QixDQUFDLE1BQU0saUJBQ2hDLGlCQUFpQixDQUFDLElBQUksV0FDNUIsQ0FBQyxnQkFBZ0IsRUFBRSwwQkFBMEIsQ0FBQyxrQkFDdkMsQ0FBQyxxQkFBcUIsQ0FBQyxRQUNqQzt3QkFDSixLQUFLLEVBQUUsY0FBYztxQkFDdEIsYUFDVTt3QkFDVDs0QkFDRSxPQUFPLEVBQUUsU0FBUzs0QkFDbEIsV0FBVyxvQkFBb0I7eUJBQ2hDO3FCQUNGOzhCQUlRLGtCQUFrQjtzQkFEMUIsU0FBUzt1QkFBQyx3QkFBd0IsRUFBRSxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUU7Z0JBYWpELGNBQWM7c0JBRGpCLFdBQVc7dUJBQUMsa0JBQWtCO2dCQU0zQixvQkFBb0I7c0JBRHZCLFdBQVc7dUJBQUMsaUNBQWlDO2dCQU0xQyxjQUFjO3NCQURqQixXQUFXO3VCQUFDLE9BQU8iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ1RlbXBsYXRlT3V0bGV0IH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7XG4gIENoYW5nZURldGVjdGlvblN0cmF0ZWd5LFxuICBDaGFuZ2VEZXRlY3RvclJlZixcbiAgQ29tcG9uZW50LFxuICBFbGVtZW50UmVmLFxuICBIb3N0QmluZGluZyxcbiAgSW5qZWN0aW9uVG9rZW4sXG4gIEluamVjdG9yLFxuICBWaWV3Q2hpbGQsXG4gIFZpZXdFbmNhcHN1bGF0aW9uLFxuICBpbmplY3QsXG59IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQU5JTUFURURfTElGRUNZQ0xFX1RPS0VOLCBBbmltYXRlZExpZmVjeWNsZURpcmVjdGl2ZSB9IGZyb20gJ0BldGhsZXRlL2NvcmUnO1xuaW1wb3J0IHsgUHJvdmlkZVRoZW1lRGlyZWN0aXZlLCBUSEVNRV9QUk9WSURFUiB9IGZyb20gJ0BldGhsZXRlL3RoZW1pbmcnO1xuaW1wb3J0IHsgVE9HR0xFVElQX0NPTkZJRywgVE9HR0xFVElQX1RFTVBMQVRFLCBUT0dHTEVUSVBfVEVYVCB9IGZyb20gJy4uLy4uL2NvbnN0YW50cyc7XG5pbXBvcnQgeyBUT0dHTEVUSVBfRElSRUNUSVZFIH0gZnJvbSAnLi4vLi4vZGlyZWN0aXZlcy90b2dnbGV0aXAnO1xuXG5leHBvcnQgY29uc3QgVE9HR0xFVElQID0gbmV3IEluamVjdGlvblRva2VuPFRvZ2dsZXRpcENvbXBvbmVudD4oJ1RvZ2dsZXRpcCcpO1xuXG4vLyBUT0RPKFRSQik6IFRoZSBmb2N1cyBzaG91bGQgZ2V0IHRyYXBwZWQgaW5zaWRlIHRoZSB0b2dnbGV0aXAuXG4vLyBUaGUgdG9nZ2xldGlwIHRyaWdnZXIgc2hvdWxkIGdldCBhIGFyaWEtaGFzcG9wdXA9XCJ0cnVlXCIgYW5kIGFyaWEtZXhwYW5kZWQ9XCJ0cnVlXCIgYXR0cmlidXRlLlxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnZXQtdG9nZ2xldGlwJyxcbiAgdGVtcGxhdGVVcmw6ICcuL3RvZ2dsZXRpcC5jb21wb25lbnQuaHRtbCcsXG4gIHN0eWxlVXJsczogWycuL3RvZ2dsZXRpcC5jb21wb25lbnQuc2NzcyddLFxuICBzdGFuZGFsb25lOiB0cnVlLFxuICBjaGFuZ2VEZXRlY3Rpb246IENoYW5nZURldGVjdGlvblN0cmF0ZWd5Lk9uUHVzaCxcbiAgZW5jYXBzdWxhdGlvbjogVmlld0VuY2Fwc3VsYXRpb24uTm9uZSxcbiAgaW1wb3J0czogW05nVGVtcGxhdGVPdXRsZXQsIEFuaW1hdGVkTGlmZWN5Y2xlRGlyZWN0aXZlXSxcbiAgaG9zdERpcmVjdGl2ZXM6IFtQcm92aWRlVGhlbWVEaXJlY3RpdmVdLFxuICBob3N0OiB7XG4gICAgY2xhc3M6ICdldC10b2dnbGV0aXAnLFxuICB9LFxuICBwcm92aWRlcnM6IFtcbiAgICB7XG4gICAgICBwcm92aWRlOiBUT0dHTEVUSVAsXG4gICAgICB1c2VFeGlzdGluZzogVG9nZ2xldGlwQ29tcG9uZW50LFxuICAgIH0sXG4gIF0sXG59KVxuZXhwb3J0IGNsYXNzIFRvZ2dsZXRpcENvbXBvbmVudCB7XG4gIEBWaWV3Q2hpbGQoQU5JTUFURURfTElGRUNZQ0xFX1RPS0VOLCB7IHN0YXRpYzogdHJ1ZSB9KVxuICByZWFkb25seSBfYW5pbWF0ZWRMaWZlY3ljbGU/OiBBbmltYXRlZExpZmVjeWNsZURpcmVjdGl2ZTtcblxuICBwcml2YXRlIHJlYWRvbmx5IF9jb25maWcgPSBpbmplY3QoVE9HR0xFVElQX0NPTkZJRyk7XG4gIHByb3RlY3RlZCByZWFkb25seSB0b2dnbGV0aXBUZXh0ID0gaW5qZWN0KFRPR0dMRVRJUF9URVhULCB7IG9wdGlvbmFsOiB0cnVlIH0pO1xuICBwcm90ZWN0ZWQgcmVhZG9ubHkgdG9nZ2xldGlwVGVtcGxhdGUgPSBpbmplY3QoVE9HR0xFVElQX1RFTVBMQVRFLCB7IG9wdGlvbmFsOiB0cnVlIH0pO1xuICBwcml2YXRlIHJlYWRvbmx5IF90aGVtZVByb3ZpZGVyID0gaW5qZWN0KFRIRU1FX1BST1ZJREVSKTtcbiAgcHJvdGVjdGVkIHJlYWRvbmx5IGluamVjdG9yID0gaW5qZWN0KEluamVjdG9yKTtcbiAgcHJpdmF0ZSByZWFkb25seSBfY2RyID0gaW5qZWN0KENoYW5nZURldGVjdG9yUmVmKTtcbiAgcmVhZG9ubHkgX3RyaWdnZXIgPSBpbmplY3QoVE9HR0xFVElQX0RJUkVDVElWRSk7XG4gIHJlYWRvbmx5IF9lbGVtZW50UmVmID0gaW5qZWN0PEVsZW1lbnRSZWY8SFRNTEVsZW1lbnQ+PihFbGVtZW50UmVmKTtcblxuICBASG9zdEJpbmRpbmcoJ2F0dHIuYXJpYS1oaWRkZW4nKVxuICBnZXQgYXR0ckFyaWFIaWRkZW4oKSB7XG4gICAgcmV0dXJuIHRydWU7XG4gIH1cblxuICBASG9zdEJpbmRpbmcoJ2NsYXNzLmV0LXdpdGgtZGVmYXVsdC1hbmltYXRpb24nKVxuICBnZXQgdXNlc0RlZmF1bHRBbmltYXRpb24oKSB7XG4gICAgcmV0dXJuICF0aGlzLl9jb25maWcuY3VzdG9tQW5pbWF0ZWQ7XG4gIH1cblxuICBASG9zdEJpbmRpbmcoJ2NsYXNzJylcbiAgZ2V0IGNvbnRhaW5lckNsYXNzKCkge1xuICAgIHJldHVybiB0aGlzLl9jb25maWcuY29udGFpbmVyQ2xhc3M7XG4gIH1cblxuICBfbWFya0ZvckNoZWNrKCkge1xuICAgIHRoaXMuX2Nkci5tYXJrRm9yQ2hlY2soKTtcbiAgfVxuXG4gIF9zZXRUaGVtZUZyb21Qcm92aWRlcihwcm92aWRlcjogUHJvdmlkZVRoZW1lRGlyZWN0aXZlKSB7XG4gICAgdGhpcy5fdGhlbWVQcm92aWRlci5zeW5jV2l0aFByb3ZpZGVyKHByb3ZpZGVyKTtcbiAgfVxufVxuIiwiPGRpdiBjbGFzcz1cImV0LXRvZ2dsZXRpcC1jb250YWluZXJcIiBldEFuaW1hdGVkTGlmZWN5Y2xlPlxuICBAaWYgKHRvZ2dsZXRpcFRleHQpIHtcbiAgICB7eyB0b2dnbGV0aXBUZXh0IH19XG4gIH1cblxuICBAaWYgKHRvZ2dsZXRpcFRlbXBsYXRlKSB7XG4gICAgPG5nLWNvbnRhaW5lciAqbmdUZW1wbGF0ZU91dGxldD1cInRvZ2dsZXRpcFRlbXBsYXRlOyBpbmplY3RvcjogaW5qZWN0b3JcIiAvPlxuICB9XG5cbiAgPGRpdiBjbGFzcz1cInRvZ2dsZXRpcC1hcnJvd1wiIGV0LWZsb2F0aW5nLWFycm93PjwvZGl2PlxuPC9kaXY+XG4iXX0=

package/esm2022/lib/components/overlay/components/toggletip/constants/index.mjs

@@ -0,0 +1,2 @@
+export * from './toggletip.constants';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2NvbXBvbmVudHMvb3ZlcmxheS9jb21wb25lbnRzL3RvZ2dsZXRpcC9jb25zdGFudHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdG9nZ2xldGlwLmNvbnN0YW50cyc7XG4iXX0=

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

@@ -0,0 +1,12 @@
+import { InjectionToken } from '@angular/core';
+export const TOGGLETIP_CONFIG = new InjectionToken('ToggletipConfig');
+export const TOGGLETIP_TEXT = new InjectionToken('ToggletipText');
+export const TOGGLETIP_TEMPLATE = new InjectionToken('ToggletipTemplate');
+export const TOGGLETIP_DEFAULT_CONFIG = {
+    placement: 'bottom',
+    offset: 8,
+    arrowPadding: 8,
+    viewportPadding: 8,
+    customAnimated: false,
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9nZ2xldGlwLmNvbnN0YW50cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY2RrL3NyYy9saWIvY29tcG9uZW50cy9vdmVybGF5L2NvbXBvbmVudHMvdG9nZ2xldGlwL2NvbnN0YW50cy90b2dnbGV0aXAuY29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQWUsTUFBTSxlQUFlLENBQUM7QUFHNUQsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQUcsSUFBSSxjQUFjLENBQWtCLGlCQUFpQixDQUFDLENBQUM7QUFDdkYsTUFBTSxDQUFDLE1BQU0sY0FBYyxHQUFHLElBQUksY0FBYyxDQUFnQixlQUFlLENBQUMsQ0FBQztBQUNqRixNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxJQUFJLGNBQWMsQ0FBOEIsbUJBQW1CLENBQUMsQ0FBQztBQUV2RyxNQUFNLENBQUMsTUFBTSx3QkFBd0IsR0FBb0I7SUFDdkQsU0FBUyxFQUFFLFFBQVE7SUFDbkIsTUFBTSxFQUFFLENBQUM7SUFDVCxZQUFZLEVBQUUsQ0FBQztJQUNmLGVBQWUsRUFBRSxDQUFDO0lBQ2xCLGNBQWMsRUFBRSxLQUFLO0NBQ2IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuLCBUZW1wbGF0ZVJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgVG9nZ2xldGlwQ29uZmlnIH0gZnJvbSAnLi4vdHlwZXMnO1xuXG5leHBvcnQgY29uc3QgVE9HR0xFVElQX0NPTkZJRyA9IG5ldyBJbmplY3Rpb25Ub2tlbjxUb2dnbGV0aXBDb25maWc+KCdUb2dnbGV0aXBDb25maWcnKTtcbmV4cG9ydCBjb25zdCBUT0dHTEVUSVBfVEVYVCA9IG5ldyBJbmplY3Rpb25Ub2tlbjxzdHJpbmcgfCBudWxsPignVG9nZ2xldGlwVGV4dCcpO1xuZXhwb3J0IGNvbnN0IFRPR0dMRVRJUF9URU1QTEFURSA9IG5ldyBJbmplY3Rpb25Ub2tlbjxUZW1wbGF0ZVJlZjx1bmtub3duPiB8IG51bGw+KCdUb2dnbGV0aXBUZW1wbGF0ZScpO1xuXG5leHBvcnQgY29uc3QgVE9HR0xFVElQX0RFRkFVTFRfQ09ORklHOiBUb2dnbGV0aXBDb25maWcgPSB7XG4gIHBsYWNlbWVudDogJ2JvdHRvbScsXG4gIG9mZnNldDogOCxcbiAgYXJyb3dQYWRkaW5nOiA4LFxuICB2aWV3cG9ydFBhZGRpbmc6IDgsXG4gIGN1c3RvbUFuaW1hdGVkOiBmYWxzZSxcbn0gYXMgY29uc3Q7XG4iXX0=

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

@@ -0,0 +1,2 @@
+export * from './toggletip.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2NvbXBvbmVudHMvb3ZlcmxheS9jb21wb25lbnRzL3RvZ2dsZXRpcC9kaXJlY3RpdmVzL3RvZ2dsZXRpcC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHVCQUF1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90b2dnbGV0aXAuZGlyZWN0aXZlJztcbiJdfQ==

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

@@ -0,0 +1,136 @@
+import { Directive, EventEmitter, InjectionToken, Input, Output, booleanAttribute, inject, } from '@angular/core';
+import { AnimatedOverlayDirective, ClickObserverService, createDestroy, nextFrame } from '@ethlete/core';
+import { THEME_PROVIDER } from '@ethlete/theming';
+import { filter, fromEvent, takeUntil, tap } from 'rxjs';
+import { OverlayCloseBlockerDirective } from '../../../../directives/overlay-close-auto-blocker';
+import { ToggletipComponent } from '../../components/toggletip';
+import { TOGGLETIP_CONFIG, TOGGLETIP_TEMPLATE, TOGGLETIP_TEXT } from '../../constants';
+import { createToggletipConfig } from '../../utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@ethlete/core";
+import * as i2 from "../../../../directives/overlay-close-auto-blocker/overlay-close-auto-blocker.directive";
+export const TOGGLETIP_DIRECTIVE = new InjectionToken('TOGGLETIP_DIRECTIVE');
+export class ToggletipDirective {
+    get toggletip() {
+        return this._toggletip;
+    }
+    set toggletip(v) {
+        this._toggletip = v;
+    }
+    get showToggletip() {
+        return this._showToggletip;
+    }
+    set showToggletip(value) {
+        this._showToggletip = booleanAttribute(value);
+        if (this._showToggletip && !this._animatedOverlay.isMounted) {
+            nextFrame(() => {
+                this._mountToggletip();
+                this._addListeners();
+            });
+        }
+        else if (!this._showToggletip && this._animatedOverlay.isMounted) {
+            this._animatedOverlay.unmount();
+            this._removeListeners();
+        }
+    }
+    constructor() {
+        this._destroy$ = createDestroy();
+        this._defaultConfig = inject(TOGGLETIP_CONFIG, { optional: true }) ?? createToggletipConfig();
+        this._animatedOverlay = inject(AnimatedOverlayDirective);
+        this._themeProvider = inject(THEME_PROVIDER, { optional: true });
+        this._toggletip = null;
+        this._showToggletip = false;
+        this.toggletipClose = new EventEmitter();
+        this._clickObserverService = inject(ClickObserverService);
+        this._listenerSubscriptions = [];
+        this._animatedOverlay.placement = this._defaultConfig.placement;
+        this._animatedOverlay.offset = this._defaultConfig.offset;
+        this._animatedOverlay.viewportPadding = this._defaultConfig.viewportPadding;
+        this._animatedOverlay.arrowPadding = this._defaultConfig.arrowPadding;
+        this._animatedOverlay.autoCloseIfReferenceHidden = true;
+    }
+    ngOnInit() {
+        this._animatedOverlay
+            .afterClosed()
+            .pipe(tap(() => {
+            this._removeListeners();
+            this.toggletipClose.emit();
+        }), takeUntil(this._destroy$))
+            .subscribe();
+    }
+    ngOnDestroy() {
+        this._animatedOverlay._destroy();
+        this._removeListeners();
+    }
+    _addListeners() {
+        const keyupEscSub = fromEvent(document, 'keyup')
+            .pipe(filter((e) => e.key === 'Escape'), tap(() => this._animatedOverlay.unmount()))
+            .subscribe();
+        const clickOutsideSub = this._clickObserverService
+            .observe(this._animatedOverlay.componentRef?.location.nativeElement)
+            .subscribe((e) => {
+            const targetElement = e.target;
+            const isInside = this._animatedOverlay.componentRef?.location.nativeElement.contains(targetElement);
+            if (!isInside) {
+                this._animatedOverlay.unmount();
+            }
+        });
+        this._listenerSubscriptions.push(keyupEscSub, clickOutsideSub);
+    }
+    _removeListeners() {
+        this._listenerSubscriptions.forEach((s) => s.unsubscribe());
+        this._listenerSubscriptions.length = 0;
+    }
+    _mountToggletip() {
+        this._animatedOverlay.mount({
+            component: ToggletipComponent,
+            themeProvider: this._themeProvider,
+            providers: [
+                {
+                    provide: TOGGLETIP_CONFIG,
+                    useValue: this._defaultConfig,
+                },
+                ...[
+                    typeof this.toggletip === 'string'
+                        ? {
+                            provide: TOGGLETIP_TEXT,
+                            useValue: this.toggletip,
+                        }
+                        : {
+                            provide: TOGGLETIP_TEMPLATE,
+                            useValue: this.toggletip,
+                        },
+                ],
+            ],
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: ToggletipDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.6", 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: "18.0.6", ngImport: i0, type: ToggletipDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[etToggletip]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: TOGGLETIP_DIRECTIVE,
+                            useExisting: ToggletipDirective,
+                        },
+                    ],
+                    hostDirectives: [{ directive: AnimatedOverlayDirective, inputs: ['placement'] }, OverlayCloseBlockerDirective],
+                }]
+        }], ctorParameters: () => [], propDecorators: { toggletip: [{
+                type: Input,
+                args: ['etToggletip']
+            }], showToggletip: [{
+                type: Input
+            }], toggletipClose: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toggletip.directive.js","sourceRoot":"","sources":["../../../../../../../../../../../libs/cdk/src/lib/components/overlay/components/toggletip/directives/toggletip/toggletip.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Directive,\n  EventEmitter,\n  InjectionToken,\n  Input,\n  OnDestroy,\n  OnInit,\n  Output,\n  TemplateRef,\n  booleanAttribute,\n  inject,\n} from '@angular/core';\nimport { AnimatedOverlayDirective, ClickObserverService, createDestroy, nextFrame } from '@ethlete/core';\nimport { THEME_PROVIDER } from '@ethlete/theming';\nimport { Subscription, filter, fromEvent, takeUntil, tap } from 'rxjs';\nimport { OverlayCloseBlockerDirective } from '../../../../directives/overlay-close-auto-blocker';\nimport { ToggletipComponent } from '../../components/toggletip';\nimport { TOGGLETIP_CONFIG, TOGGLETIP_TEMPLATE, TOGGLETIP_TEXT } from '../../constants';\nimport { ToggletipConfig } from '../../types';\nimport { createToggletipConfig } from '../../utils';\n\ntype ToggletipTemplate = string | TemplateRef<unknown>;\n\nexport const TOGGLETIP_DIRECTIVE = new InjectionToken<ToggletipDirective>('TOGGLETIP_DIRECTIVE');\n\n@Directive({\n  selector: '[etToggletip]',\n  standalone: true,\n  providers: [\n    {\n      provide: TOGGLETIP_DIRECTIVE,\n      useExisting: ToggletipDirective,\n    },\n  ],\n  hostDirectives: [{ directive: AnimatedOverlayDirective, inputs: ['placement'] }, OverlayCloseBlockerDirective],\n})\nexport class ToggletipDirective implements OnInit, OnDestroy {\n  private readonly _destroy$ = createDestroy();\n  private readonly _defaultConfig =\n    inject<ToggletipConfig>(TOGGLETIP_CONFIG, { optional: true }) ?? createToggletipConfig();\n  readonly _animatedOverlay = inject<AnimatedOverlayDirective<ToggletipComponent>>(AnimatedOverlayDirective);\n  private readonly _themeProvider = inject(THEME_PROVIDER, { optional: true });\n\n  @Input('etToggletip')\n  get toggletip() {\n    return this._toggletip;\n  }\n  set toggletip(v: ToggletipTemplate | null) {\n    this._toggletip = v;\n  }\n  private _toggletip: ToggletipTemplate | null = null;\n\n  @Input()\n  get showToggletip(): boolean {\n    return this._showToggletip;\n  }\n  set showToggletip(value: unknown) {\n    this._showToggletip = booleanAttribute(value);\n\n    if (this._showToggletip && !this._animatedOverlay.isMounted) {\n      nextFrame(() => {\n        this._mountToggletip();\n        this._addListeners();\n      });\n    } else if (!this._showToggletip && this._animatedOverlay.isMounted) {\n      this._animatedOverlay.unmount();\n      this._removeListeners();\n    }\n  }\n  private _showToggletip = false;\n\n  @Output()\n  toggletipClose = new EventEmitter();\n\n  private _clickObserverService = inject(ClickObserverService);\n\n  private readonly _listenerSubscriptions: Subscription[] = [];\n\n  constructor() {\n    this._animatedOverlay.placement = this._defaultConfig.placement;\n    this._animatedOverlay.offset = this._defaultConfig.offset;\n    this._animatedOverlay.viewportPadding = this._defaultConfig.viewportPadding;\n    this._animatedOverlay.arrowPadding = this._defaultConfig.arrowPadding;\n    this._animatedOverlay.autoCloseIfReferenceHidden = true;\n  }\n\n  ngOnInit(): void {\n    this._animatedOverlay\n      .afterClosed()\n      .pipe(\n        tap(() => {\n          this._removeListeners();\n          this.toggletipClose.emit();\n        }),\n        takeUntil(this._destroy$),\n      )\n      .subscribe();\n  }\n\n  ngOnDestroy(): void {\n    this._animatedOverlay._destroy();\n    this._removeListeners();\n  }\n\n  private _addListeners() {\n    const keyupEscSub = fromEvent<KeyboardEvent>(document, 'keyup')\n      .pipe(\n        filter((e) => e.key === 'Escape'),\n        tap(() => this._animatedOverlay.unmount()),\n      )\n      .subscribe();\n\n    const clickOutsideSub = this._clickObserverService\n      .observe(this._animatedOverlay.componentRef?.location.nativeElement)\n      .subscribe((e) => {\n        const targetElement = e.target as HTMLElement;\n        const isInside = this._animatedOverlay.componentRef?.location.nativeElement.contains(targetElement);\n\n        if (!isInside) {\n          this._animatedOverlay.unmount();\n        }\n      });\n\n    this._listenerSubscriptions.push(keyupEscSub, clickOutsideSub);\n  }\n\n  private _removeListeners() {\n    this._listenerSubscriptions.forEach((s) => s.unsubscribe());\n    this._listenerSubscriptions.length = 0;\n  }\n\n  private _mountToggletip() {\n    this._animatedOverlay.mount({\n      component: ToggletipComponent,\n      themeProvider: this._themeProvider,\n      providers: [\n        {\n          provide: TOGGLETIP_CONFIG,\n          useValue: this._defaultConfig,\n        },\n        ...[\n          typeof this.toggletip === 'string'\n            ? {\n                provide: TOGGLETIP_TEXT,\n                useValue: this.toggletip,\n              }\n            : {\n                provide: TOGGLETIP_TEMPLATE,\n                useValue: this.toggletip,\n              },\n        ],\n      ],\n    });\n  }\n}\n"]}

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

@@ -0,0 +1,2 @@
+export * from './toggletip-close.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2NvbXBvbmVudHMvb3ZlcmxheS9jb21wb25lbnRzL3RvZ2dsZXRpcC9wYXJ0aWFscy90b2dnbGV0aXAtY2xvc2UvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw2QkFBNkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdG9nZ2xldGlwLWNsb3NlLmRpcmVjdGl2ZSc7XG4iXX0=