@ethlete/cdk 4.28.0 → 4.28.1

package/esm2022/lib/components/overlay/components/overlay/partials/overlay-body/overlay-body.component.mjs

@@ -0,0 +1,131 @@
+import { Component, ElementRef, InjectionToken, Input, computed, effect, inject, signal, viewChild, } from '@angular/core';
+import { RootBoundaryDirective, isElementVisible, nextFrame, signalElementIntersection, signalElementScrollState, signalHostClasses, } from '@ethlete/core';
+import { OverlayService } from '../../services';
+import { OverlayRef, getClosestOverlay } from '../../utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@ethlete/core";
+export const OVERLAY_BODY_TOKEN = new InjectionToken('OVERLAY_BODY_TOKEN');
+export class OverlayBodyComponent {
+    set __dividers(value) {
+        this.dividers.set(value);
+    }
+    constructor() {
+        this._overlayRef = inject(OverlayRef, { optional: true });
+        this._elementRef = inject(ElementRef);
+        this._overlayService = inject(OverlayService);
+        this.dividers = signal(false);
+        this.firstElement = viewChild('firstElement');
+        this.lastElement = viewChild('lastElement');
+        this._dividersEnabled = computed(() => this.dividers() === 'dynamic' || this.dividers() === 'static');
+        this._dynamicDividersEnabled = computed(() => this.dividers() === 'dynamic');
+        this.containerScrollState = signalElementScrollState(this._elementRef);
+        this.firstElementIntersection = signalElementIntersection(this.firstElement, {
+            root: this._elementRef,
+            enabled: this._dynamicDividersEnabled,
+        });
+        this.firstElementVisibility = signal(null);
+        this.lastElementIntersection = signalElementIntersection(this.lastElement, {
+            root: this._elementRef,
+            enabled: this._dynamicDividersEnabled,
+        });
+        this.lastElementVisibility = signal(null);
+        this.canScroll = computed(() => this.containerScrollState().canScrollHorizontally);
+        this.isAtStart = computed(() => {
+            if (!this.canScroll()) {
+                return true;
+            }
+            const intersection = this.firstElementIntersection()[0];
+            if (!intersection) {
+                return this.firstElementVisibility()?.inline ?? true;
+            }
+            return intersection.isIntersecting;
+        });
+        this.isAtEnd = computed(() => {
+            if (!this.canScroll()) {
+                return true;
+            }
+            const intersection = this.lastElementIntersection()[0];
+            if (!intersection) {
+                return this.lastElementVisibility()?.inline ?? true;
+            }
+            return intersection.isIntersecting;
+        });
+        this.enableDividerAnimations = signal(false);
+        this.hostClassBindings = signalHostClasses({
+            'et-overlay-body--render-dividers': this._dividersEnabled,
+            'et-overlay-body--dynamic-dividers': this._dynamicDividersEnabled,
+            'et-overlay-body--enable-divider-animations': this.enableDividerAnimations,
+            'et-scrollable-body--can-scroll': this.canScroll,
+            'et-scrollable-body--is-at-start': computed(() => (this._dynamicDividersEnabled() ? this.isAtStart() : false)),
+            'et-scrollable-body--is-at-end': computed(() => (this._dynamicDividersEnabled() ? this.isAtEnd() : false)),
+        });
+        effect(() => {
+            const scrollable = this._elementRef.nativeElement;
+            const firstElement = this.firstElement()?.nativeElement;
+            const lastElement = this.lastElement()?.nativeElement;
+            if (!scrollable || !firstElement || !lastElement) {
+                return;
+            }
+            this.firstElementVisibility.set(isElementVisible({
+                container: scrollable,
+                element: firstElement,
+            }));
+            this.lastElementVisibility.set(isElementVisible({
+                container: scrollable,
+                element: lastElement,
+            }));
+            // We need to wait one frame before enabling animations to prevent a animation from playing during initial render.
+            nextFrame(() => this.enableDividerAnimations.set(true));
+        }, { allowSignalWrites: true });
+    }
+    ngOnInit() {
+        if (!this._overlayRef) {
+            const closestRef = getClosestOverlay(this._elementRef, this._overlayService.openOverlays);
+            if (!closestRef) {
+                throw Error('No closest ref found');
+            }
+            this._overlayRef = closestRef;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: OverlayBodyComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.0.6", type: OverlayBodyComponent, isStandalone: true, selector: "[et-overlay-body], et-overlay-body", inputs: { __dividers: ["dividers", "__dividers"] }, host: { classAttribute: "et-overlay-body" }, providers: [
+            {
+                provide: OVERLAY_BODY_TOKEN,
+                useExisting: OverlayBodyComponent,
+            },
+        ], viewQueries: [{ propertyName: "firstElement", first: true, predicate: ["firstElement"], descendants: true, isSignal: true }, { propertyName: "lastElement", first: true, predicate: ["lastElement"], descendants: true, isSignal: true }], hostDirectives: [{ directive: i1.RootBoundaryDirective }], ngImport: i0, template: `
+    <div class="et-overlay-body-container">
+      <div #firstElement class="et-overlay-body-start-element"></div>
+      <ng-content />
+      <div #lastElement class="et-overlay-body-end-element"></div>
+    </div>
+  `, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: OverlayBodyComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: '[et-overlay-body], et-overlay-body',
+                    template: `
+    <div class="et-overlay-body-container">
+      <div #firstElement class="et-overlay-body-start-element"></div>
+      <ng-content />
+      <div #lastElement class="et-overlay-body-end-element"></div>
+    </div>
+  `,
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: OVERLAY_BODY_TOKEN,
+                            useExisting: OverlayBodyComponent,
+                        },
+                    ],
+                    hostDirectives: [RootBoundaryDirective],
+                    host: {
+                        class: 'et-overlay-body',
+                    },
+                }]
+        }], ctorParameters: () => [], propDecorators: { __dividers: [{
+                type: Input,
+                args: [{ alias: 'dividers' }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay-body.component.js","sourceRoot":"","sources":["../../../../../../../../../../../libs/cdk/src/lib/components/overlay/components/overlay/partials/overlay-body/overlay-body.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  ElementRef,\n  InjectionToken,\n  Input,\n  OnInit,\n  computed,\n  effect,\n  inject,\n  signal,\n  viewChild,\n} from '@angular/core';\nimport {\n  CurrentElementVisibility,\n  RootBoundaryDirective,\n  isElementVisible,\n  nextFrame,\n  signalElementIntersection,\n  signalElementScrollState,\n  signalHostClasses,\n} from '@ethlete/core';\nimport { OverlayService } from '../../services';\nimport { OverlayRef, getClosestOverlay } from '../../utils';\n\nexport const OVERLAY_BODY_TOKEN = new InjectionToken<OverlayBodyComponent>('OVERLAY_BODY_TOKEN');\n\nexport type OverlayBodyDividerType = 'static' | 'dynamic' | false;\n\n@Component({\n  selector: '[et-overlay-body], et-overlay-body',\n  template: `\n    <div class=\"et-overlay-body-container\">\n      <div #firstElement class=\"et-overlay-body-start-element\"></div>\n      <ng-content />\n      <div #lastElement class=\"et-overlay-body-end-element\"></div>\n    </div>\n  `,\n  standalone: true,\n  providers: [\n    {\n      provide: OVERLAY_BODY_TOKEN,\n      useExisting: OverlayBodyComponent,\n    },\n  ],\n  hostDirectives: [RootBoundaryDirective],\n  host: {\n    class: 'et-overlay-body',\n  },\n})\nexport class OverlayBodyComponent implements OnInit {\n  private _overlayRef = inject(OverlayRef, { optional: true });\n  private readonly _elementRef = inject<ElementRef<HTMLElement>>(ElementRef);\n  private readonly _overlayService = inject(OverlayService);\n\n  @Input({ alias: 'dividers' })\n  set __dividers(value: OverlayBodyDividerType) {\n    this.dividers.set(value);\n  }\n  protected readonly dividers = signal<OverlayBodyDividerType>(false);\n\n  readonly firstElement = viewChild<ElementRef<HTMLElement> | null>('firstElement');\n  readonly lastElement = viewChild<ElementRef<HTMLElement> | null>('lastElement');\n\n  private readonly _dividersEnabled = computed(() => this.dividers() === 'dynamic' || this.dividers() === 'static');\n  private readonly _dynamicDividersEnabled = computed(() => this.dividers() === 'dynamic');\n\n  private readonly containerScrollState = signalElementScrollState(this._elementRef);\n  private readonly firstElementIntersection = signalElementIntersection(this.firstElement, {\n    root: this._elementRef,\n    enabled: this._dynamicDividersEnabled,\n  });\n  private readonly firstElementVisibility = signal<CurrentElementVisibility | null>(null);\n  private readonly lastElementIntersection = signalElementIntersection(this.lastElement, {\n    root: this._elementRef,\n    enabled: this._dynamicDividersEnabled,\n  });\n  private readonly lastElementVisibility = signal<CurrentElementVisibility | null>(null);\n\n  private readonly canScroll = computed(() => this.containerScrollState().canScrollHorizontally);\n\n  private readonly isAtStart = computed(() => {\n    if (!this.canScroll()) {\n      return true;\n    }\n\n    const intersection = this.firstElementIntersection()[0];\n\n    if (!intersection) {\n      return this.firstElementVisibility()?.inline ?? true;\n    }\n\n    return intersection.isIntersecting;\n  });\n  private readonly isAtEnd = computed(() => {\n    if (!this.canScroll()) {\n      return true;\n    }\n\n    const intersection = this.lastElementIntersection()[0];\n\n    if (!intersection) {\n      return this.lastElementVisibility()?.inline ?? true;\n    }\n\n    return intersection.isIntersecting;\n  });\n\n  private readonly enableDividerAnimations = signal(false);\n\n  readonly hostClassBindings = signalHostClasses({\n    'et-overlay-body--render-dividers': this._dividersEnabled,\n    'et-overlay-body--dynamic-dividers': this._dynamicDividersEnabled,\n    'et-overlay-body--enable-divider-animations': this.enableDividerAnimations,\n\n    'et-scrollable-body--can-scroll': this.canScroll,\n    'et-scrollable-body--is-at-start': computed(() => (this._dynamicDividersEnabled() ? this.isAtStart() : false)),\n    'et-scrollable-body--is-at-end': computed(() => (this._dynamicDividersEnabled() ? this.isAtEnd() : false)),\n  });\n\n  constructor() {\n    effect(\n      () => {\n        const scrollable = this._elementRef.nativeElement;\n        const firstElement = this.firstElement()?.nativeElement;\n        const lastElement = this.lastElement()?.nativeElement;\n\n        if (!scrollable || !firstElement || !lastElement) {\n          return;\n        }\n\n        this.firstElementVisibility.set(\n          isElementVisible({\n            container: scrollable,\n            element: firstElement,\n          }),\n        );\n\n        this.lastElementVisibility.set(\n          isElementVisible({\n            container: scrollable,\n            element: lastElement,\n          }),\n        );\n\n        // We need to wait one frame before enabling animations to prevent a animation from playing during initial render.\n        nextFrame(() => this.enableDividerAnimations.set(true));\n      },\n      { allowSignalWrites: true },\n    );\n  }\n\n  ngOnInit() {\n    if (!this._overlayRef) {\n      const closestRef = getClosestOverlay(this._elementRef, this._overlayService.openOverlays);\n\n      if (!closestRef) {\n        throw Error('No closest ref found');\n      }\n\n      this._overlayRef = closestRef;\n    }\n  }\n}\n"]}

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

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

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

@@ -0,0 +1,61 @@
+import { Directive, ElementRef, HostBinding, HostListener, Input, inject } from '@angular/core';
+import { OverlayService } from '../../services';
+import { OverlayRef, getClosestOverlay } from '../../utils';
+import * as i0 from "@angular/core";
+export class OverlayCloseDirective {
+    constructor() {
+        this._overlayRef = inject(OverlayRef, { optional: true });
+        this._elementRef = inject(ElementRef);
+        this._overlayService = inject(OverlayService);
+        this.type = 'button';
+    }
+    set _closeResult(value) {
+        this.closeResult = value;
+    }
+    ngOnInit() {
+        if (!this._overlayRef) {
+            const closestRef = getClosestOverlay(this._elementRef, this._overlayService.openOverlays);
+            if (!closestRef) {
+                throw Error('No closest ref found');
+            }
+            this._overlayRef = closestRef;
+        }
+    }
+    _onButtonClick(event) {
+        if (!this._overlayRef) {
+            return;
+        }
+        this._overlayRef._closeOverlayVia(event.screenX === 0 && event.screenY === 0 ? 'keyboard' : 'mouse', this.closeResult);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: OverlayCloseDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.6", type: OverlayCloseDirective, isStandalone: true, selector: "[et-overlay-close], [etOverlayClose]", inputs: { ariaLabel: ["aria-label", "ariaLabel"], type: "type", closeResult: ["et-overlay-close", "closeResult"], _closeResult: ["etOverlayClose", "_closeResult"] }, host: { listeners: { "click": "_onButtonClick($event)" }, properties: { "attr.aria-label": "ariaLabel || null", "attr.type": "this.type" } }, exportAs: ["etOverlayClose"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: OverlayCloseDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[et-overlay-close], [etOverlayClose]',
+                    exportAs: 'etOverlayClose',
+                    host: {
+                        '[attr.aria-label]': 'ariaLabel || null',
+                    },
+                    standalone: true,
+                }]
+        }], propDecorators: { ariaLabel: [{
+                type: Input,
+                args: ['aria-label']
+            }], type: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['attr.type']
+            }], closeResult: [{
+                type: Input,
+                args: ['et-overlay-close']
+            }], _closeResult: [{
+                type: Input,
+                args: ['etOverlayClose']
+            }], _onButtonClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/overlay/components/overlay/partials/overlay-footer/index.mjs

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

package/esm2022/lib/components/overlay/components/overlay/partials/overlay-footer/overlay-footer.directive.mjs

@@ -0,0 +1,45 @@
+import { Directive, ElementRef, InjectionToken, inject } from '@angular/core';
+import { OverlayService } from '../../services';
+import { OverlayRef, getClosestOverlay } from '../../utils';
+import * as i0 from "@angular/core";
+export const OVERLAY_FOOTER_TOKEN = new InjectionToken('OVERLAY_FOOTER_TOKEN');
+export class OverlayFooterDirective {
+    constructor() {
+        this._overlayRef = inject(OverlayRef, { optional: true });
+        this._elementRef = inject(ElementRef);
+        this._overlayService = inject(OverlayService);
+    }
+    ngOnInit() {
+        if (!this._overlayRef) {
+            const closestRef = getClosestOverlay(this._elementRef, this._overlayService.openOverlays);
+            if (!closestRef) {
+                throw Error('No closest ref found');
+            }
+            this._overlayRef = closestRef;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: OverlayFooterDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.6", type: OverlayFooterDirective, isStandalone: true, selector: "[etOverlayFooter], et-overlay-footer", host: { classAttribute: "et-overlay-footer" }, providers: [
+            {
+                provide: OVERLAY_FOOTER_TOKEN,
+                useExisting: OverlayFooterDirective,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: OverlayFooterDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[etOverlayFooter], et-overlay-footer',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: OVERLAY_FOOTER_TOKEN,
+                            useExisting: OverlayFooterDirective,
+                        },
+                    ],
+                    host: {
+                        class: 'et-overlay-footer',
+                    },
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/overlay/components/overlay/partials/overlay-header/index.mjs

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

package/esm2022/lib/components/overlay/components/overlay/partials/overlay-header/overlay-header.directive.mjs

@@ -0,0 +1,45 @@
+import { Directive, ElementRef, InjectionToken, inject } from '@angular/core';
+import { OverlayService } from '../../services';
+import { OverlayRef, getClosestOverlay } from '../../utils';
+import * as i0 from "@angular/core";
+export const OVERLAY_HEADER_TOKEN = new InjectionToken('OVERLAY_HEADER_TOKEN');
+export class OverlayHeaderDirective {
+    constructor() {
+        this._overlayRef = inject(OverlayRef, { optional: true });
+        this._elementRef = inject(ElementRef);
+        this._overlayService = inject(OverlayService);
+    }
+    ngOnInit() {
+        if (!this._overlayRef) {
+            const closestRef = getClosestOverlay(this._elementRef, this._overlayService.openOverlays);
+            if (!closestRef) {
+                throw Error('No closest ref found');
+            }
+            this._overlayRef = closestRef;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: OverlayHeaderDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.6", type: OverlayHeaderDirective, isStandalone: true, selector: "[etOverlayHeader], et-overlay-header", host: { classAttribute: "et-overlay-header" }, providers: [
+            {
+                provide: OVERLAY_HEADER_TOKEN,
+                useExisting: OverlayHeaderDirective,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: OverlayHeaderDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[etOverlayHeader], et-overlay-header',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: OVERLAY_HEADER_TOKEN,
+                            useExisting: OverlayHeaderDirective,
+                        },
+                    ],
+                    host: {
+                        class: 'et-overlay-header',
+                    },
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/overlay/components/overlay/partials/overlay-header-template/index.mjs

@@ -0,0 +1,2 @@
+export * from './overlay-header-template.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2NvbXBvbmVudHMvb3ZlcmxheS9jb21wb25lbnRzL292ZXJsYXkvcGFydGlhbHMvb3ZlcmxheS1oZWFkZXItdGVtcGxhdGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxxQ0FBcUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vb3ZlcmxheS1oZWFkZXItdGVtcGxhdGUuZGlyZWN0aXZlJztcbiJdfQ==

package/esm2022/lib/components/overlay/components/overlay/partials/overlay-header-template/overlay-header-template.directive.mjs

@@ -0,0 +1,50 @@
+import { Directive, ElementRef, InjectionToken, TemplateRef, inject } from '@angular/core';
+import { OverlayService } from '../../services';
+import { OverlayRef, getClosestOverlay } from '../../utils';
+import * as i0 from "@angular/core";
+export const OVERLAY_HEADER_TEMPLATE_TOKEN = new InjectionToken('OVERLAY_HEADER_TEMPLATE_TOKEN');
+export class OverlayHeaderTemplateDirective {
+    constructor() {
+        this._overlayRef = inject(OverlayRef, { optional: true });
+        this._elementRef = inject(ElementRef);
+        this._overlayService = inject(OverlayService);
+        this.template = inject(TemplateRef);
+        this._overlayRef?._setCurrentHeaderTemplate(this.template);
+    }
+    ngOnInit() {
+        if (!this._overlayRef) {
+            const closestRef = getClosestOverlay(this._elementRef, this._overlayService.openOverlays);
+            if (!closestRef) {
+                throw Error('No closest ref found');
+            }
+            this._overlayRef = closestRef;
+            this._overlayRef._setCurrentHeaderTemplate(this.template);
+        }
+    }
+    ngOnDestroy() {
+        if (this._overlayRef?.headerTemplate() === this.template) {
+            this._overlayRef?._setCurrentHeaderTemplate(null);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: OverlayHeaderTemplateDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.6", type: OverlayHeaderTemplateDirective, isStandalone: true, selector: "ng-template[etOverlayHeaderTemplate]", providers: [
+            {
+                provide: OVERLAY_HEADER_TEMPLATE_TOKEN,
+                useExisting: OverlayHeaderTemplateDirective,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: OverlayHeaderTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ng-template[etOverlayHeaderTemplate]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: OVERLAY_HEADER_TEMPLATE_TOKEN,
+                            useExisting: OverlayHeaderTemplateDirective,
+                        },
+                    ],
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcmxheS1oZWFkZXItdGVtcGxhdGUuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jZGsvc3JjL2xpYi9jb21wb25lbnRzL292ZXJsYXkvY29tcG9uZW50cy9vdmVybGF5L3BhcnRpYWxzL292ZXJsYXktaGVhZGVyLXRlbXBsYXRlL292ZXJsYXktaGVhZGVyLXRlbXBsYXRlLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLFVBQVUsRUFBRSxjQUFjLEVBQXFCLFdBQVcsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDOUcsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ2hELE9BQU8sRUFBRSxVQUFVLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxhQUFhLENBQUM7O0FBRTVELE1BQU0sQ0FBQyxNQUFNLDZCQUE2QixHQUFHLElBQUksY0FBYyxDQUM3RCwrQkFBK0IsQ0FDaEMsQ0FBQztBQVlGLE1BQU0sT0FBTyw4QkFBOEI7SUFPekM7UUFOUSxnQkFBVyxHQUFHLE1BQU0sQ0FBQyxVQUFVLEVBQUUsRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztRQUM1QyxnQkFBVyxHQUFHLE1BQU0sQ0FBMEIsVUFBVSxDQUFDLENBQUM7UUFDMUQsb0JBQWUsR0FBRyxNQUFNLENBQUMsY0FBYyxDQUFDLENBQUM7UUFFMUQsYUFBUSxHQUFHLE1BQU0sQ0FBQyxXQUFXLENBQUMsQ0FBQztRQUc3QixJQUFJLENBQUMsV0FBVyxFQUFFLHlCQUF5QixDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUM3RCxDQUFDO0lBRUQsUUFBUTtRQUNOLElBQUksQ0FBQyxJQUFJLENBQUMsV0FBVyxFQUFFLENBQUM7WUFDdEIsTUFBTSxVQUFVLEdBQUcsaUJBQWlCLENBQUMsSUFBSSxDQUFDLFdBQVcsRUFBRSxJQUFJLENBQUMsZUFBZSxDQUFDLFlBQVksQ0FBQyxDQUFDO1lBRTFGLElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQztnQkFDaEIsTUFBTSxLQUFLLENBQUMsc0JBQXNCLENBQUMsQ0FBQztZQUN0QyxDQUFDO1lBRUQsSUFBSSxDQUFDLFdBQVcsR0FBRyxVQUFVLENBQUM7WUFDOUIsSUFBSSxDQUFDLFdBQVcsQ0FBQyx5QkFBeUIsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDNUQsQ0FBQztJQUNILENBQUM7SUFFRCxXQUFXO1FBQ1QsSUFBSSxJQUFJLENBQUMsV0FBVyxFQUFFLGNBQWMsRUFBRSxLQUFLLElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQztZQUN6RCxJQUFJLENBQUMsV0FBVyxFQUFFLHlCQUF5QixDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ3BELENBQUM7SUFDSCxDQUFDOzhHQTVCVSw4QkFBOEI7a0dBQTlCLDhCQUE4QixtRkFQOUI7WUFDVDtnQkFDRSxPQUFPLEVBQUUsNkJBQTZCO2dCQUN0QyxXQUFXLEVBQUUsOEJBQThCO2FBQzVDO1NBQ0Y7OzJGQUVVLDhCQUE4QjtrQkFWMUMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsc0NBQXNDO29CQUNoRCxVQUFVLEVBQUUsSUFBSTtvQkFDaEIsU0FBUyxFQUFFO3dCQUNUOzRCQUNFLE9BQU8sRUFBRSw2QkFBNkI7NEJBQ3RDLFdBQVcsZ0NBQWdDO3lCQUM1QztxQkFDRjtpQkFDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgRWxlbWVudFJlZiwgSW5qZWN0aW9uVG9rZW4sIE9uRGVzdHJveSwgT25Jbml0LCBUZW1wbGF0ZVJlZiwgaW5qZWN0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBPdmVybGF5U2VydmljZSB9IGZyb20gJy4uLy4uL3NlcnZpY2VzJztcbmltcG9ydCB7IE92ZXJsYXlSZWYsIGdldENsb3Nlc3RPdmVybGF5IH0gZnJvbSAnLi4vLi4vdXRpbHMnO1xuXG5leHBvcnQgY29uc3QgT1ZFUkxBWV9IRUFERVJfVEVNUExBVEVfVE9LRU4gPSBuZXcgSW5qZWN0aW9uVG9rZW48T3ZlcmxheUhlYWRlclRlbXBsYXRlRGlyZWN0aXZlPihcbiAgJ09WRVJMQVlfSEVBREVSX1RFTVBMQVRFX1RPS0VOJyxcbik7XG5cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ25nLXRlbXBsYXRlW2V0T3ZlcmxheUhlYWRlclRlbXBsYXRlXScsXG4gIHN0YW5kYWxvbmU6IHRydWUsXG4gIHByb3ZpZGVyczogW1xuICAgIHtcbiAgICAgIHByb3ZpZGU6IE9WRVJMQVlfSEVBREVSX1RFTVBMQVRFX1RPS0VOLFxuICAgICAgdXNlRXhpc3Rpbmc6IE92ZXJsYXlIZWFkZXJUZW1wbGF0ZURpcmVjdGl2ZSxcbiAgICB9LFxuICBdLFxufSlcbmV4cG9ydCBjbGFzcyBPdmVybGF5SGVhZGVyVGVtcGxhdGVEaXJlY3RpdmUgaW1wbGVtZW50cyBPbkluaXQsIE9uRGVzdHJveSB7XG4gIHByaXZhdGUgX292ZXJsYXlSZWYgPSBpbmplY3QoT3ZlcmxheVJlZiwgeyBvcHRpb25hbDogdHJ1ZSB9KTtcbiAgcHJpdmF0ZSByZWFkb25seSBfZWxlbWVudFJlZiA9IGluamVjdDxFbGVtZW50UmVmPEhUTUxFbGVtZW50Pj4oRWxlbWVudFJlZik7XG4gIHByaXZhdGUgcmVhZG9ubHkgX292ZXJsYXlTZXJ2aWNlID0gaW5qZWN0KE92ZXJsYXlTZXJ2aWNlKTtcblxuICB0ZW1wbGF0ZSA9IGluamVjdChUZW1wbGF0ZVJlZik7XG5cbiAgY29uc3RydWN0b3IoKSB7XG4gICAgdGhpcy5fb3ZlcmxheVJlZj8uX3NldEN1cnJlbnRIZWFkZXJUZW1wbGF0ZSh0aGlzLnRlbXBsYXRlKTtcbiAgfVxuXG4gIG5nT25Jbml0KCkge1xuICAgIGlmICghdGhpcy5fb3ZlcmxheVJlZikge1xuICAgICAgY29uc3QgY2xvc2VzdFJlZiA9IGdldENsb3Nlc3RPdmVybGF5KHRoaXMuX2VsZW1lbnRSZWYsIHRoaXMuX292ZXJsYXlTZXJ2aWNlLm9wZW5PdmVybGF5cyk7XG5cbiAgICAgIGlmICghY2xvc2VzdFJlZikge1xuICAgICAgICB0aHJvdyBFcnJvcignTm8gY2xvc2VzdCByZWYgZm91bmQnKTtcbiAgICAgIH1cblxuICAgICAgdGhpcy5fb3ZlcmxheVJlZiA9IGNsb3Nlc3RSZWY7XG4gICAgICB0aGlzLl9vdmVybGF5UmVmLl9zZXRDdXJyZW50SGVhZGVyVGVtcGxhdGUodGhpcy50ZW1wbGF0ZSk7XG4gICAgfVxuICB9XG5cbiAgbmdPbkRlc3Ryb3koKTogdm9pZCB7XG4gICAgaWYgKHRoaXMuX292ZXJsYXlSZWY/LmhlYWRlclRlbXBsYXRlKCkgPT09IHRoaXMudGVtcGxhdGUpIHtcbiAgICAgIHRoaXMuX292ZXJsYXlSZWY/Ll9zZXRDdXJyZW50SGVhZGVyVGVtcGxhdGUobnVsbCk7XG4gICAgfVxuICB9XG59XG4iXX0=

package/esm2022/lib/components/overlay/components/overlay/partials/overlay-main/index.mjs

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

package/esm2022/lib/components/overlay/components/overlay/partials/overlay-main/overlay-main.directive.mjs

@@ -0,0 +1,51 @@
+import { Directive, ElementRef, InjectionToken, booleanAttribute, inject, input } from '@angular/core';
+import { signalHostClasses } from '@ethlete/core';
+import { OverlayService } from '../../services';
+import { OverlayRef, getClosestOverlay } from '../../utils';
+import * as i0 from "@angular/core";
+export const OVERLAY_MAIN_TOKEN = new InjectionToken('OVERLAY_MAIN_TOKEN');
+export class OverlayMainDirective {
+    constructor() {
+        this._parent = inject(OVERLAY_MAIN_TOKEN, { optional: true, skipSelf: true });
+        this._overlayRef = inject(OverlayRef, { optional: true });
+        this._elementRef = inject(ElementRef);
+        this._overlayService = inject(OverlayService);
+        this.enabled = input(true, { alias: 'etOverlayMain', transform: booleanAttribute });
+        this.hostClassBindings = signalHostClasses({
+            'et-overlay-main': this.enabled,
+        });
+    }
+    ngOnInit() {
+        if (this._parent) {
+            throw new Error('An overlay must not contain nested <et-overlay-main> elements or etOverlayMain directives.');
+        }
+        if (!this._overlayRef) {
+            const closestRef = getClosestOverlay(this._elementRef, this._overlayService.openOverlays);
+            if (!closestRef) {
+                throw new Error('No closest ref found');
+            }
+            this._overlayRef = closestRef;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: OverlayMainDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.0.6", type: OverlayMainDirective, isStandalone: true, selector: "[etOverlayMain], et-overlay-main", inputs: { enabled: { classPropertyName: "enabled", publicName: "etOverlayMain", isSignal: true, isRequired: false, transformFunction: null } }, providers: [
+            {
+                provide: OVERLAY_MAIN_TOKEN,
+                useExisting: OverlayMainDirective,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: OverlayMainDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[etOverlayMain], et-overlay-main',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: OVERLAY_MAIN_TOKEN,
+                            useExisting: OverlayMainDirective,
+                        },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/overlay/components/overlay/partials/overlay-route-header-template-outlet/index.mjs

@@ -0,0 +1,2 @@
+export * from './overlay-route-header-template-outlet.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2NvbXBvbmVudHMvb3ZlcmxheS9jb21wb25lbnRzL292ZXJsYXkvcGFydGlhbHMvb3ZlcmxheS1yb3V0ZS1oZWFkZXItdGVtcGxhdGUtb3V0bGV0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsa0RBQWtELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL292ZXJsYXktcm91dGUtaGVhZGVyLXRlbXBsYXRlLW91dGxldC5jb21wb25lbnQnO1xuIl19

package/esm2022/lib/components/overlay/components/overlay/partials/overlay-route-header-template-outlet/overlay-route-header-template-outlet.component.mjs

@@ -0,0 +1,41 @@
+import { NgTemplateOutlet } from '@angular/common';
+import { ChangeDetectionStrategy, Component, ViewEncapsulation, computed, inject, viewChild } from '@angular/core';
+import { ANIMATED_LIFECYCLE_TOKEN, AnimatedIfDirective, AnimatedLifecycleDirective, signalHostClasses, } from '@ethlete/core';
+import { OverlayRef, OverlayRouterService } from '../../utils';
+import * as i0 from "@angular/core";
+export class OverlayRouteHeaderTemplateOutletComponent {
+    constructor() {
+        this.router = inject(OverlayRouterService);
+        this.overlay = inject(OverlayRef);
+        this.animatedLifecycle = viewChild.required(ANIMATED_LIFECYCLE_TOKEN);
+        this.hostClassBindings = signalHostClasses({
+            'et-overlay-router-outlet-nav-dir--backward': computed(() => this.router.navigationDirection() === 'backward'),
+            'et-overlay-router-outlet-nav-dir--forward': computed(() => this.router.navigationDirection() === 'forward'),
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: OverlayRouteHeaderTemplateOutletComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.0.6", type: OverlayRouteHeaderTemplateOutletComponent, isStandalone: true, selector: "et-overlay-route-header-template-outlet", host: { classAttribute: "et-overlay-route-header-template-outlet-host" }, viewQueries: [{ propertyName: "animatedLifecycle", first: true, predicate: ANIMATED_LIFECYCLE_TOKEN, descendants: true, isSignal: true }], ngImport: i0, template: `
+    <div class="et-overlay-route-header-template-outlet">
+      <div [skipNextEnter]="true" class="et-overlay-route-header-template-outlet-item" etAnimatedLifecycle>
+        <ng-container *etAnimatedIf="overlay.headerTemplate()">
+          <ng-container *ngTemplateOutlet="overlay.headerTemplate()" />
+        </ng-container>
+      </div>
+    </div>
+  `, isInline: true, styles: [".et-overlay-route-header-template-outlet-host{--_et-overlay-router-transition-easing: var(--ease-in-out-5)}.et-overlay-route-header-template-outlet{display:grid;grid-template-columns:minmax(0,1fr);grid-template-rows:minmax(0,1fr);overflow-x:hidden}.et-overlay-route-header-template-outlet-item{grid-area:1 / 1 / 2 / 2;pointer-events:none}.et-overlay-route-header-template-outlet-item>*{pointer-events:auto}.et-overlay-route-header-template-outlet-item.et-animation-enter-from,.et-overlay-route-header-template-outlet-item.et-animation-leave-to{opacity:0}.et-overlay-route-header-template-outlet-item:is(.et-animation-enter-active,.et-animation-leave-active){transition:transform .3s var(--_et-overlay-router-transition-easing),opacity .3s var(--_et-overlay-router-transition-easing)}\n"], dependencies: [{ kind: "directive", type: AnimatedIfDirective, selector: "[etAnimatedIf]", inputs: ["etAnimatedIf"] }, { kind: "directive", type: AnimatedLifecycleDirective, selector: "[etAnimatedLifecycle]", inputs: ["skipNextEnter"], outputs: ["stateChange", "skipNextEnterChange"], exportAs: ["etAnimatedLifecycle"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: OverlayRouteHeaderTemplateOutletComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'et-overlay-route-header-template-outlet', template: `
+    <div class="et-overlay-route-header-template-outlet">
+      <div [skipNextEnter]="true" class="et-overlay-route-header-template-outlet-item" etAnimatedLifecycle>
+        <ng-container *etAnimatedIf="overlay.headerTemplate()">
+          <ng-container *ngTemplateOutlet="overlay.headerTemplate()" />
+        </ng-container>
+      </div>
+    </div>
+  `, standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, host: {
+                        class: 'et-overlay-route-header-template-outlet-host',
+                    }, imports: [AnimatedIfDirective, AnimatedLifecycleDirective, NgTemplateOutlet], styles: [".et-overlay-route-header-template-outlet-host{--_et-overlay-router-transition-easing: var(--ease-in-out-5)}.et-overlay-route-header-template-outlet{display:grid;grid-template-columns:minmax(0,1fr);grid-template-rows:minmax(0,1fr);overflow-x:hidden}.et-overlay-route-header-template-outlet-item{grid-area:1 / 1 / 2 / 2;pointer-events:none}.et-overlay-route-header-template-outlet-item>*{pointer-events:auto}.et-overlay-route-header-template-outlet-item.et-animation-enter-from,.et-overlay-route-header-template-outlet-item.et-animation-leave-to{opacity:0}.et-overlay-route-header-template-outlet-item:is(.et-animation-enter-active,.et-animation-leave-active){transition:transform .3s var(--_et-overlay-router-transition-easing),opacity .3s var(--_et-overlay-router-transition-easing)}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/overlay/components/overlay/partials/overlay-router-link/index.mjs

@@ -0,0 +1,2 @@
+export * from './overlay-router-link.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2NvbXBvbmVudHMvb3ZlcmxheS9jb21wb25lbnRzL292ZXJsYXkvcGFydGlhbHMvb3ZlcmxheS1yb3V0ZXItbGluay9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlDQUFpQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9vdmVybGF5LXJvdXRlci1saW5rLmRpcmVjdGl2ZSc7XG4iXX0=

package/esm2022/lib/components/overlay/components/overlay/partials/overlay-router-link/overlay-router-link.directive.mjs

@@ -0,0 +1,46 @@
+import { Directive, ElementRef, InjectionToken, booleanAttribute, computed, inject, input } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { signalHostClasses } from '@ethlete/core';
+import { filter, fromEvent, tap } from 'rxjs';
+import { OverlayRouterService } from '../../utils';
+import * as i0 from "@angular/core";
+export const OVERLAY_ROUTER_LINK_TOKEN = new InjectionToken('OVERLAY_ROUTER_LINK_TOKEN');
+export class OverlayRouterLinkDirective {
+    constructor() {
+        this.router = inject(OverlayRouterService);
+        this.path = input.required({ alias: 'etOverlayRouterLink' });
+        this.disabled = input(false, { transform: booleanAttribute });
+        this.navigationDirection = input(null);
+        this.hostClassBindings = signalHostClasses({
+            'et-overlay-router-link--active': computed(() => this.router.resolvePath(this.path()).route === this.router.currentRoute()),
+        });
+        fromEvent(inject(ElementRef).nativeElement, 'click')
+            .pipe(filter(() => !this.disabled()), tap(() => this.router.navigate(this.path(), { navigationDirection: this.navigationDirection() ?? undefined })), takeUntilDestroyed())
+            .subscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: OverlayRouterLinkDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.0.6", type: OverlayRouterLinkDirective, isStandalone: true, selector: "[etOverlayRouterLink]", inputs: { path: { classPropertyName: "path", publicName: "etOverlayRouterLink", isSignal: true, isRequired: true, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, navigationDirection: { classPropertyName: "navigationDirection", publicName: "navigationDirection", isSignal: true, isRequired: false, transformFunction: null } }, host: { attributes: { "type": "button" }, classAttribute: "et-overlay-router-link" }, providers: [
+            {
+                provide: OVERLAY_ROUTER_LINK_TOKEN,
+                useExisting: OverlayRouterLinkDirective,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: OverlayRouterLinkDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[etOverlayRouterLink]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: OVERLAY_ROUTER_LINK_TOKEN,
+                            useExisting: OverlayRouterLinkDirective,
+                        },
+                    ],
+                    host: {
+                        class: 'et-overlay-router-link',
+                        type: 'button',
+                    },
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/overlay/components/overlay/partials/overlay-router-outlet/index.mjs

@@ -0,0 +1,2 @@
+export * from './overlay-router-outlet.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2NvbXBvbmVudHMvb3ZlcmxheS9jb21wb25lbnRzL292ZXJsYXkvcGFydGlhbHMvb3ZlcmxheS1yb3V0ZXItb3V0bGV0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUNBQW1DLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL292ZXJsYXktcm91dGVyLW91dGxldC5jb21wb25lbnQnO1xuIl19