@odx/angular 12.19.2 → 12.20.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @odx/angular
 
+## 12.20.0
+
+### Minor Changes
+
+- 0bff895: Added scroll for tab bar, z-index fixed for action buttons click event handling
+
 ## 12.19.2
 
 ### Patch Changes

package/cdk/scrollable/README.md

@@ -0,0 +1,3 @@
+# @odx/angular/cdk/scrollable
+
+Secondary entry point of `@odx/angular`. It can be used by importing from `@odx/angular/cdk/scrollable`.

package/cdk/scrollable/index.d.ts

@@ -0,0 +1 @@
+export * from './lib/scrollable.service';

package/cdk/scrollable/lib/scrollable.service.d.ts

@@ -0,0 +1,53 @@
+import { ElementRef, OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export interface ScrollableItem {
+    element: ElementRef<HTMLElement>;
+}
+/**
+ * Service to manage scrollable items within a container, providing functionality to observe item visibility
+ * and navigate through them.
+ */
+export declare class ScrollableService implements OnDestroy {
+    private intersectionObserver?;
+    private scrollContainer?;
+    /**
+     * References to the next and previous scrollable items.
+     *
+     * @type {HTMLElement | null}
+     */
+    readonly nextItem: import("@angular/core").WritableSignal<HTMLElement | null>;
+    /**
+     * References to the previous scrollable item.
+     *
+     * @type {HTMLElement | null}
+     */
+    readonly prevItem: import("@angular/core").WritableSignal<HTMLElement | null>;
+    /** List of currently visible items within the scroll container.
+     *
+     * @type {HTMLElement[]}
+     */
+    readonly visibleItems: import("@angular/core").WritableSignal<HTMLElement[]>;
+    ngOnDestroy(): void;
+    /**
+     * Starts observing the scrollable items within the specified container.
+     *
+     * @param {ElementRef<HTMLElement>} scrollContainer - The container element that holds the scrollable items.
+     * @param {readonly ScrollableItem[]} items - The list of scrollable items to observe.
+     */
+    observe(scrollContainer: ElementRef<HTMLElement>, items: readonly ScrollableItem[]): void;
+    /**
+     * Scrolls the container in the specified direction.
+     *
+     * @param {'next' | 'prev'} direction - The direction to scroll ('next' for right, 'prev' for left).
+     */
+    scroll(direction?: 1 | -1): void;
+    /**
+     * Scrolls the active item into view within the scroll container.
+     *
+     * @param {HTMLElement | null} activeItem - The currently active item to scroll into view.
+     */
+    scrollActiveItemIntoView(activeItem: HTMLElement | null): void;
+    private observeVisibility;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollableService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScrollableService>;
+}

package/components/tab-bar/lib/components/tab-bar-item/tab-bar-item.component.d.ts

@@ -1,5 +1,5 @@
 import { Highlightable } from '@angular/cdk/a11y';
-import { ElementRef, EventEmitter, OnInit } from '@angular/core';
+import { ElementRef, OnInit } from '@angular/core';
 import * as i0 from "@angular/core";
 /**
  * Represents an individual tab item in a tab bar interface, providing functionalities
@@ -27,13 +27,13 @@ export declare class TabBarItemComponent implements Highlightable, OnInit {
      * @type {boolean}
      * @default false
      */
-    closable: boolean;
+    closable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
     /**
      * Event emitter that fires when the tab is closed. It emits the instance of the tab item component.
      *
      * @emits {TabBarItemComponent}
      */
-    tabClose: EventEmitter<TabBarItemComponent>;
+    tabClose: import("@angular/core").OutputEmitterRef<TabBarItemComponent>;
     ngOnInit(): void;
     /**
      * Sets the tab as active and applies corresponding styles. This method is part of the
@@ -48,6 +48,5 @@ export declare class TabBarItemComponent implements Highlightable, OnInit {
     protected onClick(): void;
     protected handleClose(event: Event): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TabBarItemComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TabBarItemComponent, "odx-tab-bar-item", never, { "closable": { "alias": "closable"; "required": false; }; }, { "tabClose": "tabClose"; }, never, ["odx-icon", "*"], true, never>;
-    static ngAcceptInputType_closable: unknown;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabBarItemComponent, "odx-tab-bar-item", never, { "closable": { "alias": "closable"; "required": false; "isSignal": true; }; }, { "tabClose": "tabClose"; }, never, ["odx-icon", "*"], true, never>;
 }

package/components/tab-bar/lib/tab-bar.component.d.ts

@@ -1,5 +1,5 @@
 import { ActiveDescendantKeyManager } from '@angular/cdk/a11y';
-import { AfterViewInit, ElementRef, EventEmitter, QueryList } from '@angular/core';
+import { ElementRef } from '@angular/core';
 import { TabBarItemComponent } from './components';
 import { TabChangeEvent } from './models';
 import * as i0 from "@angular/core";
@@ -13,30 +13,18 @@ import * as i0 from "@angular/core";
  * making it accessible and user-friendly. Additionally, it handles overflow with navigational arrows,
  * allowing for a smooth user experience even with a large number of tabs.
  */
-export declare class TabBarComponent implements AfterViewInit {
-    private readonly changeDetector;
+export declare class TabBarComponent {
     private readonly takeUntilDestroyed;
-    private readonly selectedIndex$$;
-    protected activeItem: TabBarItemComponent | null;
-    protected keyManager?: ActiveDescendantKeyManager<TabBarItemComponent>;
-    protected tabBarPanelElement: ElementRef<HTMLElement>;
-    protected tabActionElements: QueryList<ElementRef<HTMLElement>>;
-    protected tabs: QueryList<TabBarItemComponent>;
+    private readonly scrollableService;
+    protected readonly nextTab: import("@angular/core").WritableSignal<HTMLElement | null>;
+    protected readonly prevTab: import("@angular/core").WritableSignal<HTMLElement | null>;
+    protected readonly tabs: import("@angular/core").Signal<readonly TabBarItemComponent[]>;
+    protected readonly activeItem: import("@angular/core").Signal<TabBarItemComponent | null>;
+    protected readonly keyManager: ActiveDescendantKeyManager<TabBarItemComponent>;
+    protected readonly scrollContainerElement: import("@angular/core").Signal<ElementRef<HTMLElement>>;
     readonly element: ElementRef<HTMLElement>;
     /**
-     * Indicates whether the tab bar has overflowed to the left.
-     *
-     * @type {boolean}
-     */
-    overflowLeft: boolean;
-    /**
-     * Indicates whether the tab bar has overflowed to the right.
-     *
-     * @type {boolean}
-     */
-    overflowRight: boolean;
-    /**
-     * Gets or sets the index of the currently selected tab. Use this property to programmatically
+     * Index of the currently selected tab. Use this property to programmatically
      * change the active tab. It responds to changes by updating the active state of the corresponding
      * tab item and adjusting the view if necessary.
      *
@@ -47,7 +35,7 @@ export declare class TabBarComponent implements AfterViewInit {
      * <odx-tab-bar [selectedIndex]="1"></odx-tab-bar>
      * ```
      */
-    set selectedIndex(value: number);
+    selectedIndex: import("@angular/core").ModelSignal<number>;
     /**
      * An EventEmitter that emits whenever a new tab is selected. It provides the `TabChangeEvent`
      * which contains the index of the newly selected tab and the instance of the corresponding
@@ -65,35 +53,25 @@ export declare class TabBarComponent implements AfterViewInit {
      * }
      * ```
      */
-    selectedTabChanged: EventEmitter<TabChangeEvent>;
-    ngAfterViewInit(): void;
+    selectedTabChanged: import("@angular/core").OutputEmitterRef<TabChangeEvent>;
+    constructor();
     /**
-     * Activates the specified tab item.
+     * Activates the specified tab item, making it the currently selected tab.
+     * If the item is already active, no action is taken.
      *
-     * @param {TabBarItemComponent | null} item - The tab item to activate. If not provided or null, the active item will be cleared.
-     *
-     * @example
-     * ```ts
-     * // Activate the first tab item
-     * tabBar.activateItem(tabItems[0]);
-     *
-     * // Clear the active item
-     * tabBar.activateItem(null);
-     * ```
+     * @param {TabBarItemComponent | null} item - The tab item to activate.
      */
     activateItem(item?: TabBarItemComponent | null): void;
     /**
-     * Removes the specified item from the tab bar.
-     * If the removed item is the active item, it sets the previous item as the new active item.
+     * Fires when the specified tab item is removed from the tab bar.
+     * If the item is currently active, the previous tab is activated.
      *
-     * @param {TabBarItemComponent} item - The item to be removed from the tab bar.
+     * @param {TabBarItemComponent} item - The tab item to remove.
      */
     removeItem(item: TabBarItemComponent): void;
     protected onKeydown(event: KeyboardEvent): void;
-    private updatePanelPosition;
-    private updateActionVisbility;
-    private activeItemChange;
+    protected onFocused(): void;
+    protected scrollTabs(direction?: 1 | -1): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TabBarComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TabBarComponent, "odx-tab-bar", never, { "selectedIndex": { "alias": "selectedIndex"; "required": false; }; }, { "selectedTabChanged": "selectedTabChanged"; }, ["tabs"], ["*"], true, never>;
-    static ngAcceptInputType_selectedIndex: unknown;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabBarComponent, "odx-tab-bar", never, { "selectedIndex": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; }, { "selectedIndex": "selectedIndexChange"; "selectedTabChanged": "selectedTabChanged"; }, ["tabs"], ["*"], true, never>;
 }

package/esm2022/cdk/scrollable/index.mjs

@@ -0,0 +1,2 @@
+export * from './lib/scrollable.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY2RrL3Njcm9sbGFibGUvc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9zY3JvbGxhYmxlLnNlcnZpY2UnO1xuIl19

package/esm2022/cdk/scrollable/lib/scrollable.service.mjs

@@ -0,0 +1,108 @@
+import { Injectable, signal } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Service to manage scrollable items within a container, providing functionality to observe item visibility
+ * and navigate through them.
+ */
+export class ScrollableService {
+    constructor() {
+        /**
+         * References to the next and previous scrollable items.
+         *
+         * @type {HTMLElement | null}
+         */
+        this.nextItem = signal(null);
+        /**
+         * References to the previous scrollable item.
+         *
+         * @type {HTMLElement | null}
+         */
+        this.prevItem = signal(null);
+        /** List of currently visible items within the scroll container.
+         *
+         * @type {HTMLElement[]}
+         */
+        this.visibleItems = signal([]);
+    }
+    ngOnDestroy() {
+        this.intersectionObserver?.disconnect();
+    }
+    /**
+     * Starts observing the scrollable items within the specified container.
+     *
+     * @param {ElementRef<HTMLElement>} scrollContainer - The container element that holds the scrollable items.
+     * @param {readonly ScrollableItem[]} items - The list of scrollable items to observe.
+     */
+    observe(scrollContainer, items) {
+        this.scrollContainer = scrollContainer;
+        if (this.intersectionObserver) {
+            this.intersectionObserver.disconnect();
+        }
+        const allItems = items.map((item) => item.element.nativeElement);
+        if (!this.scrollContainer || allItems.length === 0) {
+            this.nextItem.set(null);
+            this.prevItem.set(null);
+            return;
+        }
+        this.intersectionObserver = this.observeVisibility(allItems, (visible) => {
+            let prevItem = null;
+            let nextItem = null;
+            if (visible.length > 0 && allItems.length > visible.length) {
+                const firstVisibleIndex = allItems.indexOf(visible[0]);
+                if (firstVisibleIndex > 0) {
+                    prevItem = allItems[firstVisibleIndex - 1];
+                }
+                const lastVisibleIndex = allItems.indexOf(visible[visible.length - 1]);
+                if (lastVisibleIndex < allItems.length - 1) {
+                    nextItem = allItems[lastVisibleIndex + 1];
+                }
+            }
+            this.nextItem.set(nextItem);
+            this.prevItem.set(prevItem);
+        });
+    }
+    /**
+     * Scrolls the container in the specified direction.
+     *
+     * @param {'next' | 'prev'} direction - The direction to scroll ('next' for right, 'prev' for left).
+     */
+    scroll(direction = 1) {
+        const container = this.scrollContainer?.nativeElement;
+        if (!container)
+            return;
+        container.scrollBy({ left: (container.clientWidth * direction) / 2 });
+    }
+    /**
+     * Scrolls the active item into view within the scroll container.
+     *
+     * @param {HTMLElement | null} activeItem - The currently active item to scroll into view.
+     */
+    scrollActiveItemIntoView(activeItem) {
+        if (activeItem) {
+            activeItem.scrollIntoView({ behavior: 'smooth', block: 'nearest', inline: 'center' });
+        }
+    }
+    observeVisibility(items, callback) {
+        const visibleMap = new Map();
+        const observer = new IntersectionObserver((entries) => {
+            for (const entry of entries) {
+                const isVisible = entry.isIntersecting && entry.intersectionRatio >= 0.75;
+                visibleMap.set(entry.target, isVisible);
+            }
+            const visible = items.filter((item) => visibleMap.get(item));
+            this.visibleItems.set(visible);
+            callback(visible);
+        }, {
+            root: this.scrollContainer.nativeElement,
+            threshold: 1,
+        });
+        items.forEach((item) => observer.observe(item));
+        return observer;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ScrollableService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ScrollableService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ScrollableService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scrollable.service.js","sourceRoot":"","sources":["../../../../../../../libs/angular/cdk/scrollable/src/lib/scrollable.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ElementRef, Injectable, OnDestroy, signal } from '@angular/core';\n\nexport interface ScrollableItem {\n  element: ElementRef<HTMLElement>;\n}\n\n/**\n * Service to manage scrollable items within a container, providing functionality to observe item visibility\n * and navigate through them.\n */\n@Injectable()\nexport class ScrollableService implements OnDestroy {\n  private intersectionObserver?: IntersectionObserver;\n  private scrollContainer?: ElementRef<HTMLElement>;\n\n  /**\n   * References to the next and previous scrollable items.\n   *\n   * @type {HTMLElement | null}\n   */\n  public readonly nextItem = signal<HTMLElement | null>(null);\n\n  /**\n   * References to the previous scrollable item.\n   *\n   * @type {HTMLElement | null}\n   */\n  public readonly prevItem = signal<HTMLElement | null>(null);\n\n  /** List of currently visible items within the scroll container.\n   *\n   * @type {HTMLElement[]}\n   */\n  public readonly visibleItems = signal<HTMLElement[]>([]);\n\n  public ngOnDestroy(): void {\n    this.intersectionObserver?.disconnect();\n  }\n\n  /**\n   * Starts observing the scrollable items within the specified container.\n   *\n   * @param {ElementRef<HTMLElement>} scrollContainer - The container element that holds the scrollable items.\n   * @param {readonly ScrollableItem[]} items - The list of scrollable items to observe.\n   */\n  public observe(scrollContainer: ElementRef<HTMLElement>, items: readonly ScrollableItem[]): void {\n    this.scrollContainer = scrollContainer;\n    if (this.intersectionObserver) {\n      this.intersectionObserver.disconnect();\n    }\n\n    const allItems = items.map((item) => item.element.nativeElement);\n    if (!this.scrollContainer || allItems.length === 0) {\n      this.nextItem.set(null);\n      this.prevItem.set(null);\n      return;\n    }\n\n    this.intersectionObserver = this.observeVisibility(allItems, (visible) => {\n      let prevItem: HTMLElement | null = null;\n      let nextItem: HTMLElement | null = null;\n\n      if (visible.length > 0 && allItems.length > visible.length) {\n        const firstVisibleIndex = allItems.indexOf(visible[0]);\n        if (firstVisibleIndex > 0) {\n          prevItem = allItems[firstVisibleIndex - 1];\n        }\n\n        const lastVisibleIndex = allItems.indexOf(visible[visible.length - 1]);\n        if (lastVisibleIndex < allItems.length - 1) {\n          nextItem = allItems[lastVisibleIndex + 1];\n        }\n      }\n\n      this.nextItem.set(nextItem);\n      this.prevItem.set(prevItem);\n    });\n  }\n\n  /**\n   * Scrolls the container in the specified direction.\n   *\n   * @param {'next' | 'prev'} direction - The direction to scroll ('next' for right, 'prev' for left).\n   */\n  public scroll(direction: 1 | -1 = 1): void {\n    const container = this.scrollContainer?.nativeElement;\n    if (!container) return;\n\n    container.scrollBy({ left: (container.clientWidth * direction) / 2 });\n  }\n\n  /**\n   * Scrolls the active item into view within the scroll container.\n   *\n   * @param {HTMLElement | null} activeItem - The currently active item to scroll into view.\n   */\n  public scrollActiveItemIntoView(activeItem: HTMLElement | null): void {\n    if (activeItem) {\n      activeItem.scrollIntoView({ behavior: 'smooth', block: 'nearest', inline: 'center' });\n    }\n  }\n\n  private observeVisibility(items: HTMLElement[], callback: (visible: HTMLElement[]) => void): IntersectionObserver {\n    const visibleMap = new Map<HTMLElement, boolean>();\n    const observer = new IntersectionObserver(\n      (entries) => {\n        for (const entry of entries) {\n          const isVisible = entry.isIntersecting && entry.intersectionRatio >= 0.75;\n          visibleMap.set(entry.target as HTMLElement, isVisible);\n        }\n        const visible = items.filter((item) => visibleMap.get(item));\n        this.visibleItems.set(visible);\n        callback(visible);\n      },\n      {\n        root: this.scrollContainer!.nativeElement,\n        threshold: 1,\n      },\n    );\n\n    items.forEach((item) => observer.observe(item));\n    return observer;\n  }\n}\n"]}

package/esm2022/cdk/scrollable/odx-angular-cdk-scrollable.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2R4LWFuZ3VsYXItY2RrLXNjcm9sbGFibGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY2RrL3Njcm9sbGFibGUvc3JjL29keC1hbmd1bGFyLWNkay1zY3JvbGxhYmxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19

package/esm2022/components/tab-bar/lib/components/tab-bar-item/tab-bar-item.component.mjs

@@ -1,6 +1,6 @@
 import { __decorate } from "tslib";
 import { CommonModule } from '@angular/common';
-import { booleanAttribute, ChangeDetectionStrategy, Component, ElementRef, EventEmitter, HostListener, inject, Input, Output, ViewEncapsulation, } from '@angular/core';
+import { booleanAttribute, ChangeDetectionStrategy, Component, ElementRef, inject, input, output, ViewEncapsulation } from '@angular/core';
 import { RouterLinkActive } from '@angular/router';
 import { DisabledController } from '@odx/angular';
 import { IconComponent } from '@odx/angular/components/icon';
@@ -35,13 +35,13 @@ let TabBarItemComponent = class TabBarItemComponent {
          * @type {boolean}
          * @default false
          */
-        this.closable = false;
+        this.closable = input(false, { transform: booleanAttribute });
         /**
          * Event emitter that fires when the tab is closed. It emits the instance of the tab item component.
          *
          * @emits {TabBarItemComponent}
          */
-        this.tabClose = new EventEmitter();
+        this.tabClose = output();
     }
     get disabled() {
         return !!this.disabledController?.disabled;
@@ -72,13 +72,13 @@ let TabBarItemComponent = class TabBarItemComponent {
     }
     handleClose(event) {
         event.stopPropagation();
-        if (this.disabled || !this.closable)
+        if (this.disabled || !this.closable())
             return;
         this.tabBar.removeItem(this);
         this.tabClose.emit(this);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TabBarItemComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: TabBarItemComponent, isStandalone: true, selector: "odx-tab-bar-item", inputs: { closable: ["closable", "closable", booleanAttribute] }, outputs: { tabClose: "tabClose" }, host: { attributes: { "role": "tab" }, listeners: { "click": "onClick()" }, properties: { "class.is-disabled": "disabled", "class.is-active": "isActive", "attr.aria-selected": "isActive", "class.is-closable": "closable" } }, providers: [DisabledController.connect()], ngImport: i0, template: "<ng-content select=\"odx-icon\" />\n<div class=\"odx-tab-bar-item__label\"><ng-content /></div>\n@if (closable) {\n  <odx-icon name=\"close\" iconSet=\"core\" size=\"small\" (click)=\"handleClose($event)\" />\n}\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: IconComponent, selector: "odx-icon", inputs: ["inline", "size", "name", "iconSet", "identifier"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: TabBarItemComponent, isStandalone: true, selector: "odx-tab-bar-item", inputs: { closable: { classPropertyName: "closable", publicName: "closable", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { tabClose: "tabClose" }, host: { attributes: { "role": "tab" }, listeners: { "click": "onClick()" }, properties: { "class.is-disabled": "disabled", "class.is-active": "isActive", "attr.aria-selected": "isActive", "class.is-closable": "closable()" } }, providers: [DisabledController.connect()], ngImport: i0, template: "<ng-content select=\"odx-icon\" />\n<div class=\"odx-tab-bar-item__label\"><ng-content /></div>\n@if (closable()) {\n  <odx-icon name=\"close\" iconSet=\"core\" size=\"small\" (click)=\"handleClose($event)\" />\n}\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: IconComponent, selector: "odx-icon", inputs: ["inline", "size", "name", "iconSet", "identifier"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
 };
 TabBarItemComponent = __decorate([
     CSSComponent('tab-bar-item')
@@ -90,16 +90,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                         '[class.is-disabled]': 'disabled',
                         '[class.is-active]': 'isActive',
                         '[attr.aria-selected]': 'isActive',
-                        '[class.is-closable]': 'closable',
+                        '[class.is-closable]': 'closable()',
                         role: 'tab',
-                    }, template: "<ng-content select=\"odx-icon\" />\n<div class=\"odx-tab-bar-item__label\"><ng-content /></div>\n@if (closable) {\n  <odx-icon name=\"close\" iconSet=\"core\" size=\"small\" (click)=\"handleClose($event)\" />\n}\n" }]
-        }], propDecorators: { closable: [{
-                type: Input,
-                args: [{ transform: booleanAttribute }]
-            }], tabClose: [{
-                type: Output
-            }], onClick: [{
-                type: HostListener,
-                args: ['click']
-            }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tab-bar-item.component.js","sourceRoot":"","sources":["../../../../../../../../../libs/angular/components/tab-bar/src/lib/components/tab-bar-item/tab-bar-item.component.ts","../../../../../../../../../libs/angular/components/tab-bar/src/lib/components/tab-bar-item/tab-bar-item.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Highlightable } from '@angular/cdk/a11y';\nimport { CommonModule } from '@angular/common';\nimport {\n  booleanAttribute,\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  EventEmitter,\n  HostListener,\n  inject,\n  Input,\n  OnInit,\n  Output,\n  ViewEncapsulation,\n} from '@angular/core';\nimport { RouterLinkActive } from '@angular/router';\nimport { DisabledController } from '@odx/angular';\nimport { IconComponent } from '@odx/angular/components/icon';\nimport { CSSComponent } from '@odx/angular/internal';\nimport { deferFn, untilDestroyed } from '@odx/angular/utils';\nimport { filter } from 'rxjs';\nimport { TAB_BAR } from '../../tab-bar.config';\n\n/**\n * Represents an individual tab item in a tab bar interface, providing functionalities\n * for activation, deactivation, and optional closing of the tab. This component is designed\n * to be used within a `TabBarComponent` to create a complete tabbed interface.\n *\n * It supports disabled state management through `DisabledController`, allowing the tab to be\n * disabled based on parent component states or its own `disabled` input property.\n *\n * The component integrates with Angular's `RouterLinkActive` to automatically set active\n * styles based on the current router state, enhancing SPA navigation experiences.\n */\n@CSSComponent('tab-bar-item')\n@Component({\n  selector: 'odx-tab-bar-item',\n  standalone: true,\n  imports: [CommonModule, IconComponent],\n  templateUrl: './tab-bar-item.component.html',\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  providers: [DisabledController.connect()],\n  host: {\n    '[class.is-disabled]': 'disabled',\n    '[class.is-active]': 'isActive',\n    '[attr.aria-selected]': 'isActive',\n    '[class.is-closable]': 'closable',\n    role: 'tab',\n  },\n})\nexport class TabBarItemComponent implements Highlightable, OnInit {\n  private readonly disabledController = DisabledController.inject();\n  private readonly tabBar = inject(TAB_BAR);\n  private readonly routerLinkActive = inject(RouterLinkActive, { optional: true, self: true });\n  private readonly takeUntilDestroyed = untilDestroyed();\n\n  protected isActive = false;\n\n  public readonly element: ElementRef<HTMLElement> = inject(ElementRef);\n\n  public get disabled(): boolean {\n    return !!this.disabledController?.disabled;\n  }\n\n  /**\n   * Indicates if the tab can be closed. This controls the visibility of the close button\n   * and enables the emission of the `tabClose` event when the tab is closed.\n   *\n   * @type {boolean}\n   * @default false\n   */\n  @Input({ transform: booleanAttribute })\n  public closable = false;\n\n  /**\n   * Event emitter that fires when the tab is closed. It emits the instance of the tab item component.\n   *\n   * @emits {TabBarItemComponent}\n   */\n  @Output()\n  public tabClose = new EventEmitter<TabBarItemComponent>();\n\n  public ngOnInit(): void {\n    this.routerLinkActive?.isActiveChange.pipe(this.takeUntilDestroyed(), filter(Boolean)).subscribe(() => {\n      this.onClick();\n    });\n  }\n\n  /**\n   * Sets the tab as active and applies corresponding styles. This method is part of the\n   * `Highlightable` interface, allowing the tab bar to manage active states.\n   */\n  public setActiveStyles(): void {\n    deferFn(() => (this.isActive = true));\n  }\n\n  /**\n   * Sets the tab as inactive and removes corresponding active styles. This method is part of the\n   * `Highlightable` interface.\n   */\n  public setInactiveStyles(): void {\n    deferFn(() => (this.isActive = false));\n  }\n\n  @HostListener('click')\n  protected onClick(): void {\n    if (this.disabled) return;\n    this.tabBar.activateItem(this);\n  }\n\n  protected handleClose(event: Event): void {\n    event.stopPropagation();\n    if (this.disabled || !this.closable) return;\n    this.tabBar.removeItem(this);\n    this.tabClose.emit(this);\n  }\n}\n","<ng-content select=\"odx-icon\" />\n<div class=\"odx-tab-bar-item__label\"><ng-content /></div>\n@if (closable) {\n  <odx-icon name=\"close\" iconSet=\"core\" size=\"small\" (click)=\"handleClose($event)\" />\n}\n"]}
+                        '(click)': 'onClick()',
+                    }, template: "<ng-content select=\"odx-icon\" />\n<div class=\"odx-tab-bar-item__label\"><ng-content /></div>\n@if (closable()) {\n  <odx-icon name=\"close\" iconSet=\"core\" size=\"small\" (click)=\"handleClose($event)\" />\n}\n" }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tab-bar-item.component.js","sourceRoot":"","sources":["../../../../../../../../../libs/angular/components/tab-bar/src/lib/components/tab-bar-item/tab-bar-item.component.ts","../../../../../../../../../libs/angular/components/tab-bar/src/lib/components/tab-bar-item/tab-bar-item.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Highlightable } from '@angular/cdk/a11y';\nimport { CommonModule } from '@angular/common';\nimport { booleanAttribute, ChangeDetectionStrategy, Component, ElementRef, inject, input, OnInit, output, ViewEncapsulation } from '@angular/core';\nimport { RouterLinkActive } from '@angular/router';\nimport { DisabledController } from '@odx/angular';\nimport { IconComponent } from '@odx/angular/components/icon';\nimport { CSSComponent } from '@odx/angular/internal';\nimport { deferFn, untilDestroyed } from '@odx/angular/utils';\nimport { filter } from 'rxjs';\nimport { TAB_BAR } from '../../tab-bar.config';\n\n/**\n * Represents an individual tab item in a tab bar interface, providing functionalities\n * for activation, deactivation, and optional closing of the tab. This component is designed\n * to be used within a `TabBarComponent` to create a complete tabbed interface.\n *\n * It supports disabled state management through `DisabledController`, allowing the tab to be\n * disabled based on parent component states or its own `disabled` input property.\n *\n * The component integrates with Angular's `RouterLinkActive` to automatically set active\n * styles based on the current router state, enhancing SPA navigation experiences.\n */\n@CSSComponent('tab-bar-item')\n@Component({\n  selector: 'odx-tab-bar-item',\n  standalone: true,\n  imports: [CommonModule, IconComponent],\n  templateUrl: './tab-bar-item.component.html',\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  providers: [DisabledController.connect()],\n  host: {\n    '[class.is-disabled]': 'disabled',\n    '[class.is-active]': 'isActive',\n    '[attr.aria-selected]': 'isActive',\n    '[class.is-closable]': 'closable()',\n    role: 'tab',\n    '(click)': 'onClick()',\n  },\n})\nexport class TabBarItemComponent implements Highlightable, OnInit {\n  private readonly disabledController = DisabledController.inject();\n  private readonly tabBar = inject(TAB_BAR);\n  private readonly routerLinkActive = inject(RouterLinkActive, { optional: true, self: true });\n  private readonly takeUntilDestroyed = untilDestroyed();\n\n  protected isActive = false;\n\n  public readonly element: ElementRef<HTMLElement> = inject(ElementRef);\n\n  public get disabled(): boolean {\n    return !!this.disabledController?.disabled;\n  }\n\n  /**\n   * Indicates if the tab can be closed. This controls the visibility of the close button\n   * and enables the emission of the `tabClose` event when the tab is closed.\n   *\n   * @type {boolean}\n   * @default false\n   */\n  public closable = input(false, { transform: booleanAttribute });\n\n  /**\n   * Event emitter that fires when the tab is closed. It emits the instance of the tab item component.\n   *\n   * @emits {TabBarItemComponent}\n   */\n  public tabClose = output<TabBarItemComponent>();\n\n  public ngOnInit(): void {\n    this.routerLinkActive?.isActiveChange.pipe(this.takeUntilDestroyed(), filter(Boolean)).subscribe(() => {\n      this.onClick();\n    });\n  }\n\n  /**\n   * Sets the tab as active and applies corresponding styles. This method is part of the\n   * `Highlightable` interface, allowing the tab bar to manage active states.\n   */\n  public setActiveStyles(): void {\n    deferFn(() => (this.isActive = true));\n  }\n\n  /**\n   * Sets the tab as inactive and removes corresponding active styles. This method is part of the\n   * `Highlightable` interface.\n   */\n  public setInactiveStyles(): void {\n    deferFn(() => (this.isActive = false));\n  }\n\n  protected onClick(): void {\n    if (this.disabled) return;\n    this.tabBar.activateItem(this);\n  }\n\n  protected handleClose(event: Event): void {\n    event.stopPropagation();\n    if (this.disabled || !this.closable()) return;\n    this.tabBar.removeItem(this);\n    this.tabClose.emit(this);\n  }\n}\n","<ng-content select=\"odx-icon\" />\n<div class=\"odx-tab-bar-item__label\"><ng-content /></div>\n@if (closable()) {\n  <odx-icon name=\"close\" iconSet=\"core\" size=\"small\" (click)=\"handleClose($event)\" />\n}\n"]}