@ethlete/cdk 2.3.1 → 2.3.2

package/esm2022/lib/components/tabs/partials/nav-tabs/nav-tab-link/nav-tab-link.directive.mjs

@@ -0,0 +1,204 @@
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';
+import { SPACE } from '@angular/cdk/keycodes';
+import { Attribute, ChangeDetectorRef, Component, ElementRef, HostBinding, HostListener, Input, NgZone, Optional, } from '@angular/core';
+import { Router, RouterLink, RouterLinkActive } from '@angular/router';
+import { NavTabsComponent } from '../../../components/nav-tabs/nav-tabs.component';
+import { ActiveTabUnderlineDirective } from '../../../utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../components/nav-tabs/nav-tabs.component";
+import * as i2 from "@angular/cdk/a11y";
+import * as i3 from "@angular/router";
+import * as i4 from "../../../utils/active-tab-underline.util";
+let nextUniqueId = 0;
+class NavTabLinkComponent {
+    get active() {
+        const link = this._link || this._linkWithHref;
+        if (!link) {
+            return false;
+        }
+        const options = this._linkConfig
+            ? isActiveMatchOptions(this._linkConfig?.routerLinkActiveOptions)
+                ? this._linkConfig?.routerLinkActiveOptions
+                : this._linkConfig?.routerLinkActiveOptions.exact
+            : false;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        // Stolen from https://github.com/angular/angular/blob/main/packages/router/src/directives/router_link_active.ts#L217
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const isActive = link.urlTree ? this._router.isActive(link.urlTree, options) : false;
+        return isActive;
+    }
+    get tabIndex() {
+        return this.disabled ? -1 : this._tabIndex;
+    }
+    set tabIndex(value) {
+        this._tabIndex = value != null ? coerceNumberProperty(value) : 0;
+    }
+    get disabled() {
+        return this._disabled;
+    }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+    }
+    get _attrAriaControls() {
+        return this._getAriaControls();
+    }
+    get _attrAriaCurrent() {
+        return this._getAriaCurrent();
+    }
+    get _attrAriaDisabled() {
+        return this.disabled;
+    }
+    get _attrAriaSelected() {
+        return this._getAriaSelected();
+    }
+    get _attrTabIndex() {
+        return this._getTabIndex();
+    }
+    get _attrRole() {
+        return this._getRole();
+    }
+    constructor(_tabNavBar, elementRef, tabIndex, _focusMonitor, _router, _cdr, _ngZone, _link, _linkWithHref, _linkConfig) {
+        this._tabNavBar = _tabNavBar;
+        this.elementRef = elementRef;
+        this._focusMonitor = _focusMonitor;
+        this._router = _router;
+        this._cdr = _cdr;
+        this._ngZone = _ngZone;
+        this._link = _link;
+        this._linkWithHref = _linkWithHref;
+        this._linkConfig = _linkConfig;
+        this._tabIndex = 0;
+        this._disabled = false;
+        this.id = `et-nav-tab-link-${nextUniqueId++}`;
+        this._haltDisabledEvents = (event) => {
+            if (this.disabled) {
+                event.preventDefault();
+                event.stopImmediatePropagation();
+            }
+        };
+        this.tabIndex = parseInt(tabIndex) || 0;
+    }
+    ngOnInit() {
+        this._ngZone.runOutsideAngular(() => {
+            this.elementRef.nativeElement.addEventListener('click', this._haltDisabledEvents);
+        });
+    }
+    ngAfterViewInit() {
+        this._focusMonitor.monitor(this.elementRef);
+    }
+    ngOnDestroy() {
+        this._focusMonitor.stopMonitoring(this.elementRef);
+        this.elementRef.nativeElement.removeEventListener('click', this._haltDisabledEvents);
+    }
+    focus() {
+        this.elementRef.nativeElement.focus();
+    }
+    _handleFocus() {
+        this._tabNavBar.focusIndex = this._tabNavBar._items.toArray().indexOf(this);
+    }
+    _handleKeydown(event) {
+        if (this._tabNavBar.tabOutlet && event.keyCode === SPACE) {
+            this.elementRef.nativeElement.click();
+        }
+    }
+    _getAriaControls() {
+        return this._tabNavBar.tabOutlet
+            ? this._tabNavBar.tabOutlet?.id
+            : this.elementRef.nativeElement.getAttribute('aria-controls');
+    }
+    _getAriaSelected() {
+        if (this._tabNavBar.tabOutlet) {
+            return this.active ? 'true' : 'false';
+        }
+        else {
+            return this.elementRef.nativeElement.getAttribute('aria-selected');
+        }
+    }
+    _getAriaCurrent() {
+        return this.active && !this._tabNavBar.tabOutlet ? 'page' : null;
+    }
+    _getRole() {
+        return this._tabNavBar.tabOutlet ? 'tab' : this.elementRef.nativeElement.getAttribute('role');
+    }
+    _getTabIndex() {
+        if (this._tabNavBar.tabOutlet) {
+            return this.active && !this.disabled ? 0 : -1;
+        }
+        else {
+            return this.tabIndex;
+        }
+    }
+    _markForCheck() {
+        this._cdr.markForCheck();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NavTabLinkComponent, deps: [{ token: i1.NavTabsComponent }, { token: i0.ElementRef }, { token: 'tabindex', attribute: true }, { token: i2.FocusMonitor }, { token: i3.Router }, { token: i0.ChangeDetectorRef }, { token: i0.NgZone }, { token: i3.RouterLink, optional: true }, { token: i3.RouterLink, optional: true }, { token: i3.RouterLinkActive, optional: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NavTabLinkComponent, isStandalone: true, selector: "[et-nav-tab-link]", inputs: { tabIndex: "tabIndex", disabled: "disabled", id: "id" }, host: { listeners: { "focus": "_handleFocus()", "keydown": "_handleKeydown($event)" }, properties: { "attr.id": "this.id", "attr.aria-controls": "this._attrAriaControls", "attr.aria-current": "this._attrAriaCurrent", "attr.aria-disabled": "this._attrAriaDisabled", "attr.aria-selected": "this._attrAriaSelected", "attr.tabIndex": "this._attrTabIndex", "attr.role": "this._attrRole" }, classAttribute: "et-nav-tab-link" }, hostDirectives: [{ directive: i4.ActiveTabUnderlineDirective, inputs: ["fitUnderlineToContent", "fitUnderlineToContent"] }], ngImport: i0, template: `
+    <span class="et-tab-content">
+      <ng-content />
+    </span>
+  `, isInline: true }); }
+}
+export { NavTabLinkComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NavTabLinkComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: '[et-nav-tab-link]',
+                    template: `
+    <span class="et-tab-content">
+      <ng-content />
+    </span>
+  `,
+                    standalone: true,
+                    host: {
+                        class: 'et-nav-tab-link',
+                    },
+                    hostDirectives: [{ directive: ActiveTabUnderlineDirective, inputs: ['fitUnderlineToContent'] }],
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NavTabsComponent }, { type: i0.ElementRef }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['tabindex']
+                }] }, { type: i2.FocusMonitor }, { type: i3.Router }, { type: i0.ChangeDetectorRef }, { type: i0.NgZone }, { type: i3.RouterLink, decorators: [{
+                    type: Optional
+                }] }, { type: i3.RouterLink, decorators: [{
+                    type: Optional
+                }] }, { type: i3.RouterLinkActive, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { tabIndex: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['attr.id']
+            }], _attrAriaControls: [{
+                type: HostBinding,
+                args: ['attr.aria-controls']
+            }], _attrAriaCurrent: [{
+                type: HostBinding,
+                args: ['attr.aria-current']
+            }], _attrAriaDisabled: [{
+                type: HostBinding,
+                args: ['attr.aria-disabled']
+            }], _attrAriaSelected: [{
+                type: HostBinding,
+                args: ['attr.aria-selected']
+            }], _attrTabIndex: [{
+                type: HostBinding,
+                args: ['attr.tabIndex']
+            }], _attrRole: [{
+                type: HostBinding,
+                args: ['attr.role']
+            }], _handleFocus: [{
+                type: HostListener,
+                args: ['focus']
+            }], _handleKeydown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }] } });
+function isActiveMatchOptions(options) {
+    return !!options.paths;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nav-tab-link.directive.js","sourceRoot":"","sources":["../../../../../../../../../../libs/cdk/src/lib/components/tabs/partials/nav-tabs/nav-tab-link/nav-tab-link.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { FocusableOption, FocusMonitor } from '@angular/cdk/a11y';\nimport { BooleanInput, coerceBooleanProperty, coerceNumberProperty, NumberInput } from '@angular/cdk/coercion';\nimport { SPACE } from '@angular/cdk/keycodes';\nimport {\n  AfterViewInit,\n  Attribute,\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  HostBinding,\n  HostListener,\n  Input,\n  NgZone,\n  OnDestroy,\n  OnInit,\n  Optional,\n} from '@angular/core';\nimport { IsActiveMatchOptions, Router, RouterLink, RouterLinkActive } from '@angular/router';\nimport { NavTabsComponent } from '../../../components/nav-tabs/nav-tabs.component';\nimport { ActiveTabUnderlineDirective } from '../../../utils';\n\nlet nextUniqueId = 0;\n\n@Component({\n  selector: '[et-nav-tab-link]',\n  template: `\n    <span class=\"et-tab-content\">\n      <ng-content />\n    </span>\n  `,\n  standalone: true,\n  host: {\n    class: 'et-nav-tab-link',\n  },\n  hostDirectives: [{ directive: ActiveTabUnderlineDirective, inputs: ['fitUnderlineToContent'] }],\n})\nexport class NavTabLinkComponent implements OnInit, AfterViewInit, OnDestroy, FocusableOption {\n  get active(): boolean {\n    const link = this._link || this._linkWithHref;\n\n    if (!link) {\n      return false;\n    }\n\n    const options: boolean | IsActiveMatchOptions = this._linkConfig\n      ? isActiveMatchOptions(this._linkConfig?.routerLinkActiveOptions)\n        ? this._linkConfig?.routerLinkActiveOptions\n        : this._linkConfig?.routerLinkActiveOptions.exact\n      : false;\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    // Stolen from https://github.com/angular/angular/blob/main/packages/router/src/directives/router_link_active.ts#L217\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const isActive = link.urlTree ? this._router.isActive(link.urlTree, options as any) : false;\n\n    return isActive;\n  }\n\n  @Input()\n  get tabIndex(): number {\n    return this.disabled ? -1 : this._tabIndex;\n  }\n  set tabIndex(value: NumberInput) {\n    this._tabIndex = value != null ? coerceNumberProperty(value) : 0;\n  }\n  private _tabIndex = 0;\n\n  @Input()\n  get disabled(): boolean {\n    return this._disabled;\n  }\n  set disabled(value: BooleanInput) {\n    this._disabled = coerceBooleanProperty(value);\n  }\n  private _disabled = false;\n\n  @Input()\n  @HostBinding('attr.id')\n  id = `et-nav-tab-link-${nextUniqueId++}`;\n\n  @HostBinding('attr.aria-controls')\n  get _attrAriaControls() {\n    return this._getAriaControls();\n  }\n\n  @HostBinding('attr.aria-current')\n  get _attrAriaCurrent() {\n    return this._getAriaCurrent();\n  }\n\n  @HostBinding('attr.aria-disabled')\n  get _attrAriaDisabled() {\n    return this.disabled;\n  }\n\n  @HostBinding('attr.aria-selected')\n  get _attrAriaSelected() {\n    return this._getAriaSelected();\n  }\n\n  @HostBinding('attr.tabIndex')\n  get _attrTabIndex() {\n    return this._getTabIndex();\n  }\n\n  @HostBinding('attr.role')\n  get _attrRole() {\n    return this._getRole();\n  }\n\n  constructor(\n    private _tabNavBar: NavTabsComponent,\n    public elementRef: ElementRef,\n    @Attribute('tabindex') tabIndex: string,\n    private _focusMonitor: FocusMonitor,\n    private _router: Router,\n    private _cdr: ChangeDetectorRef,\n    private _ngZone: NgZone,\n    @Optional() public _link?: RouterLink,\n    @Optional() public _linkWithHref?: RouterLink,\n    @Optional() public _linkConfig?: RouterLinkActive,\n  ) {\n    this.tabIndex = parseInt(tabIndex) || 0;\n  }\n\n  ngOnInit(): void {\n    this._ngZone.runOutsideAngular(() => {\n      this.elementRef.nativeElement.addEventListener('click', this._haltDisabledEvents);\n    });\n  }\n\n  ngAfterViewInit() {\n    this._focusMonitor.monitor(this.elementRef);\n  }\n\n  ngOnDestroy() {\n    this._focusMonitor.stopMonitoring(this.elementRef);\n    this.elementRef.nativeElement.removeEventListener('click', this._haltDisabledEvents);\n  }\n\n  focus() {\n    this.elementRef.nativeElement.focus();\n  }\n\n  @HostListener('focus')\n  _handleFocus() {\n    this._tabNavBar.focusIndex = this._tabNavBar._items.toArray().indexOf(this);\n  }\n\n  @HostListener('keydown', ['$event'])\n  _handleKeydown(event: KeyboardEvent) {\n    if (this._tabNavBar.tabOutlet && event.keyCode === SPACE) {\n      this.elementRef.nativeElement.click();\n    }\n  }\n\n  _getAriaControls(): string | null {\n    return this._tabNavBar.tabOutlet\n      ? this._tabNavBar.tabOutlet?.id\n      : this.elementRef.nativeElement.getAttribute('aria-controls');\n  }\n\n  _getAriaSelected(): string | null {\n    if (this._tabNavBar.tabOutlet) {\n      return this.active ? 'true' : 'false';\n    } else {\n      return this.elementRef.nativeElement.getAttribute('aria-selected');\n    }\n  }\n\n  _getAriaCurrent(): string | null {\n    return this.active && !this._tabNavBar.tabOutlet ? 'page' : null;\n  }\n\n  _getRole(): string | null {\n    return this._tabNavBar.tabOutlet ? 'tab' : this.elementRef.nativeElement.getAttribute('role');\n  }\n\n  _getTabIndex(): number {\n    if (this._tabNavBar.tabOutlet) {\n      return this.active && !this.disabled ? 0 : -1;\n    } else {\n      return this.tabIndex;\n    }\n  }\n\n  _markForCheck() {\n    this._cdr.markForCheck();\n  }\n\n  private _haltDisabledEvents = (event: Event) => {\n    if (this.disabled) {\n      event.preventDefault();\n      event.stopImmediatePropagation();\n    }\n  };\n}\n\nfunction isActiveMatchOptions(options: { exact: boolean } | IsActiveMatchOptions): options is IsActiveMatchOptions {\n  return !!(options as IsActiveMatchOptions).paths;\n}\n"]}

package/esm2022/lib/components/tabs/partials/nav-tabs/nav-tabs-outlet/nav-tabs-outlet.component.mjs

@@ -0,0 +1,38 @@
+import { ChangeDetectionStrategy, Component, HostBinding, Input, ViewEncapsulation } from '@angular/core';
+import * as i0 from "@angular/core";
+let nextUniqueId = 0;
+class NavTabsOutletComponent {
+    constructor() {
+        this.id = `et-nav-tabs-outlet-${nextUniqueId++}`;
+    }
+    get _attrAriaLabelledBy() {
+        return this._activeTabId;
+    }
+    get _attrRole() {
+        return 'tabpanel';
+    }
+    get _attrId() {
+        return this.id;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NavTabsOutletComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NavTabsOutletComponent, isStandalone: true, selector: "et-nav-tabs-outlet", inputs: { id: "id" }, host: { properties: { "attr.aria-labelledby": "this._attrAriaLabelledBy", "attr.role": "this._attrRole", "attr.id": "this._attrId" }, classAttribute: "et-nav-tabs-outlet" }, ngImport: i0, template: '<ng-content />', isInline: true, styles: [".et-nav-tabs{display:block}.et-nav-tabs .et-nav-tab-link{white-space:nowrap}.et-nav-tabs .et-nav-tab-link:not([aria-disabled=true]){cursor:pointer}.et-nav-tabs .et-scrollable-container{position:relative}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+export { NavTabsOutletComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NavTabsOutletComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'et-nav-tabs-outlet', template: '<ng-content />', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, host: {
+                        class: 'et-nav-tabs-outlet',
+                    }, styles: [".et-nav-tabs{display:block}.et-nav-tabs .et-nav-tab-link{white-space:nowrap}.et-nav-tabs .et-nav-tab-link:not([aria-disabled=true]){cursor:pointer}.et-nav-tabs .et-scrollable-container{position:relative}\n"] }]
+        }], propDecorators: { id: [{
+                type: Input
+            }], _attrAriaLabelledBy: [{
+                type: HostBinding,
+                args: ['attr.aria-labelledby']
+            }], _attrRole: [{
+                type: HostBinding,
+                args: ['attr.role']
+            }], _attrId: [{
+                type: HostBinding,
+                args: ['attr.id']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/tabs/utils/active-tab-underline.util.mjs

@@ -0,0 +1,112 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { Directive, ElementRef, InjectionToken, Input, inject } from '@angular/core';
+import * as i0 from "@angular/core";
+const ACTIVE_CLASS = 'et-active-tab-underline--active';
+const NO_TRANSITION_CLASS = 'et-active-tab-underline--no-transition';
+export class ActiveTabUnderlineBarManager {
+    constructor(_items) {
+        this._items = _items;
+    }
+    hide() {
+        this._items.forEach((item) => item?.deactivateUnderline());
+    }
+    alignToElement(element) {
+        const correspondingItem = this._items.find((item) => item?.elementRef.nativeElement === element);
+        const currentItem = this._currentItem;
+        currentItem?.deactivateUnderline();
+        if (correspondingItem) {
+            const clientRect = currentItem?.elementRef.nativeElement.getBoundingClientRect?.();
+            correspondingItem.activateUnderline(clientRect);
+            this._currentItem = correspondingItem;
+        }
+    }
+}
+class ActiveTabUnderlineDirective {
+    constructor() {
+        this.elementRef = inject(ElementRef);
+        this._underlineElement = null;
+        this._underlineContentElement = null;
+        this._fitToContent = false;
+    }
+    get fitUnderlineToContent() {
+        return this._fitToContent;
+    }
+    set fitUnderlineToContent(v) {
+        const newValue = coerceBooleanProperty(v);
+        if (this._fitToContent !== newValue) {
+            this._fitToContent = newValue;
+            if (this._underlineElement) {
+                this._appendUnderlineElement();
+            }
+        }
+    }
+    activateUnderline(previousIndicatorClientRect) {
+        const element = this.elementRef.nativeElement;
+        if (!previousIndicatorClientRect || !element.getBoundingClientRect || !this._underlineContentElement) {
+            element.classList.add(ACTIVE_CLASS);
+            return;
+        }
+        const currentClientRect = element.getBoundingClientRect();
+        const widthDelta = previousIndicatorClientRect.width / currentClientRect.width;
+        const xPosition = previousIndicatorClientRect.left - currentClientRect.left;
+        element.classList.add(NO_TRANSITION_CLASS);
+        this._underlineContentElement.style.setProperty('transform', `translateX(${xPosition}px) scaleX(${widthDelta})`);
+        element.getBoundingClientRect();
+        element.classList.remove(NO_TRANSITION_CLASS);
+        element.classList.add(ACTIVE_CLASS);
+        this._underlineContentElement.style.setProperty('transform', '');
+    }
+    deactivateUnderline() {
+        this.elementRef.nativeElement.classList.remove(ACTIVE_CLASS);
+    }
+    ngOnInit() {
+        this._createUnderlineElement();
+    }
+    ngOnDestroy() {
+        this._underlineElement?.remove();
+        this._underlineElement = this._underlineContentElement = null;
+    }
+    _createUnderlineElement() {
+        const documentNode = this.elementRef.nativeElement.ownerDocument || document;
+        this._underlineElement = documentNode.createElement('span');
+        this._underlineContentElement = documentNode.createElement('span');
+        this._underlineElement.className = 'et-active-tab-underline';
+        this._underlineContentElement.className =
+            'et-active-tab-underline__content et-active-tab-underline__content--underline';
+        this._underlineElement.appendChild(this._underlineContentElement);
+        this._appendUnderlineElement();
+    }
+    _appendUnderlineElement() {
+        if (!this._underlineElement) {
+            return;
+        }
+        const parentElement = this._fitToContent
+            ? this.elementRef.nativeElement.querySelector('.et-tab-content')
+            : this.elementRef.nativeElement;
+        if (!parentElement) {
+            return;
+        }
+        parentElement.appendChild(this._underlineElement);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ActiveTabUnderlineDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: ActiveTabUnderlineDirective, isStandalone: true, inputs: { fitUnderlineToContent: "fitUnderlineToContent" }, ngImport: i0 }); }
+}
+export { ActiveTabUnderlineDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ActiveTabUnderlineDirective, decorators: [{
+            type: Directive,
+            args: [{ standalone: true }]
+        }], propDecorators: { fitUnderlineToContent: [{
+                type: Input
+            }] } });
+export function _MAT_INK_BAR_POSITIONER_FACTORY() {
+    const method = (element) => ({
+        left: element ? (element.offsetLeft || 0) + 'px' : '0',
+        width: element ? (element.offsetWidth || 0) + 'px' : '0',
+    });
+    return method;
+}
+export const _MAT_INK_BAR_POSITIONER = new InjectionToken('ET_ACTIVE_TAB_UNDERLINE_POSITIONER', {
+    providedIn: 'root',
+    factory: _MAT_INK_BAR_POSITIONER_FACTORY,
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"active-tab-underline.util.js","sourceRoot":"","sources":["../../../../../../../../libs/cdk/src/lib/components/tabs/utils/active-tab-underline.util.ts"],"names":[],"mappings":"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","sourcesContent":["import { BooleanInput, coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { Directive, ElementRef, InjectionToken, Input, OnDestroy, OnInit, inject } from '@angular/core';\nimport { TypedQueryList } from '@ethlete/core';\n\nexport interface ActiveTabUnderlineItem extends OnInit, OnDestroy {\n  elementRef: ElementRef<HTMLElement>;\n  activateUnderline(previousIndicatorClientRect?: DOMRect): void;\n  deactivateUnderline(): void;\n  fitUnderlineToContent: boolean;\n}\n\nconst ACTIVE_CLASS = 'et-active-tab-underline--active';\n\nconst NO_TRANSITION_CLASS = 'et-active-tab-underline--no-transition';\n\nexport class ActiveTabUnderlineBarManager {\n  private _currentItem: ActiveTabUnderlineItem | undefined;\n\n  constructor(private _items: TypedQueryList<ActiveTabUnderlineItem>) {}\n\n  hide() {\n    this._items.forEach((item) => item?.deactivateUnderline());\n  }\n\n  alignToElement(element: HTMLElement) {\n    const correspondingItem = this._items.find((item) => item?.elementRef.nativeElement === element);\n    const currentItem = this._currentItem;\n\n    currentItem?.deactivateUnderline();\n\n    if (correspondingItem) {\n      const clientRect = currentItem?.elementRef.nativeElement.getBoundingClientRect?.();\n\n      correspondingItem.activateUnderline(clientRect);\n      this._currentItem = correspondingItem;\n    }\n  }\n}\n\n@Directive({ standalone: true })\nexport class ActiveTabUnderlineDirective implements OnInit, OnDestroy {\n  readonly elementRef = inject<ElementRef<HTMLElement>>(ElementRef);\n\n  private _underlineElement: HTMLElement | null = null;\n  private _underlineContentElement: HTMLElement | null = null;\n\n  @Input()\n  get fitUnderlineToContent(): boolean {\n    return this._fitToContent;\n  }\n  set fitUnderlineToContent(v: BooleanInput) {\n    const newValue = coerceBooleanProperty(v);\n\n    if (this._fitToContent !== newValue) {\n      this._fitToContent = newValue;\n\n      if (this._underlineElement) {\n        this._appendUnderlineElement();\n      }\n    }\n  }\n  private _fitToContent = false;\n\n  activateUnderline(previousIndicatorClientRect?: DOMRect) {\n    const element = this.elementRef.nativeElement;\n\n    if (!previousIndicatorClientRect || !element.getBoundingClientRect || !this._underlineContentElement) {\n      element.classList.add(ACTIVE_CLASS);\n      return;\n    }\n\n    const currentClientRect = element.getBoundingClientRect();\n    const widthDelta = previousIndicatorClientRect.width / currentClientRect.width;\n    const xPosition = previousIndicatorClientRect.left - currentClientRect.left;\n    element.classList.add(NO_TRANSITION_CLASS);\n    this._underlineContentElement.style.setProperty('transform', `translateX(${xPosition}px) scaleX(${widthDelta})`);\n\n    element.getBoundingClientRect();\n\n    element.classList.remove(NO_TRANSITION_CLASS);\n    element.classList.add(ACTIVE_CLASS);\n    this._underlineContentElement.style.setProperty('transform', '');\n  }\n\n  deactivateUnderline() {\n    this.elementRef.nativeElement.classList.remove(ACTIVE_CLASS);\n  }\n\n  ngOnInit() {\n    this._createUnderlineElement();\n  }\n\n  ngOnDestroy() {\n    this._underlineElement?.remove();\n    this._underlineElement = this._underlineContentElement = null;\n  }\n\n  private _createUnderlineElement() {\n    const documentNode = this.elementRef.nativeElement.ownerDocument || document;\n    this._underlineElement = documentNode.createElement('span');\n    this._underlineContentElement = documentNode.createElement('span');\n\n    this._underlineElement.className = 'et-active-tab-underline';\n    this._underlineContentElement.className =\n      'et-active-tab-underline__content et-active-tab-underline__content--underline';\n\n    this._underlineElement.appendChild(this._underlineContentElement);\n    this._appendUnderlineElement();\n  }\n\n  private _appendUnderlineElement() {\n    if (!this._underlineElement) {\n      return;\n    }\n\n    const parentElement = this._fitToContent\n      ? this.elementRef.nativeElement.querySelector('.et-tab-content')\n      : this.elementRef.nativeElement;\n\n    if (!parentElement) {\n      return;\n    }\n\n    parentElement.appendChild(this._underlineElement);\n  }\n}\n\nexport interface _ActiveTabUnderlinePositioner {\n  (element: HTMLElement): { left: string; width: string };\n}\n\nexport function _MAT_INK_BAR_POSITIONER_FACTORY(): _ActiveTabUnderlinePositioner {\n  const method = (element: HTMLElement) => ({\n    left: element ? (element.offsetLeft || 0) + 'px' : '0',\n    width: element ? (element.offsetWidth || 0) + 'px' : '0',\n  });\n\n  return method;\n}\n\nexport const _MAT_INK_BAR_POSITIONER = new InjectionToken<_ActiveTabUnderlinePositioner>(\n  'ET_ACTIVE_TAB_UNDERLINE_POSITIONER',\n  {\n    providedIn: 'root',\n    factory: _MAT_INK_BAR_POSITIONER_FACTORY,\n  },\n);\n"]}