cax-design-system 1.0.0

package/esm2022/tabmenu/tabmenu.mjs

@@ -0,0 +1,576 @@
+import { CommonModule, isPlatformBrowser } from '@angular/common';
+import { ChangeDetectionStrategy, Component, ContentChildren, EventEmitter, Inject, Input, NgModule, Output, PLATFORM_ID, ViewChild, ViewChildren, ViewEncapsulation, booleanAttribute, signal } from '@angular/core';
+import { NavigationEnd, RouterModule } from '@angular/router';
+import { CaxTemplate, SharedModule } from 'cax-design-system/api';
+import { DomHandler } from 'cax-design-system/dom';
+import { ChevronLeftIcon } from 'cax-design-system/icons/chevronleft';
+import { ChevronRightIcon } from 'cax-design-system/icons/chevronright';
+import { RippleModule } from 'cax-design-system/ripple';
+import { TooltipModule } from 'cax-design-system/tooltip';
+import { ObjectUtils } from 'cax-design-system/utils';
+import { filter } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@angular/common";
+import * as i3 from "cax-design-system/tooltip";
+/**
+ * TabMenu is a navigation component that displays items as tab headers.
+ * @group Components
+ */
+export class TabMenu {
+    platformId;
+    router;
+    route;
+    cd;
+    /**
+     * An array of menuitems.
+     * @group Props
+     */
+    set model(value) {
+        this._model = value;
+        this._focusableItems = (this._model || []).reduce((result, item) => {
+            result.push(item);
+            return result;
+        }, []);
+    }
+    get model() {
+        return this._model;
+    }
+    /**
+     * Defines the default active menuitem
+     * @group Props
+     */
+    set activeItem(value) {
+        this._activeItem = value;
+        this.activeItemChange.emit(value);
+        this.tabChanged = true;
+    }
+    get activeItem() {
+        return this._activeItem;
+    }
+    /**
+     * When enabled displays buttons at each side of the tab headers to scroll the tab list.
+     * @group Props
+     */
+    scrollable;
+    /**
+     * Defines if popup mode enabled.
+     */
+    popup;
+    /**
+     * Inline style of the element.
+     * @group Props
+     */
+    style;
+    /**
+     * Class of the element.
+     * @group Props
+     */
+    styleClass;
+    /**
+     * Defines a string value that labels an interactive element.
+     * @group Props
+     */
+    ariaLabel;
+    /**
+     * Identifier of the underlying input element.
+     * @group Props
+     */
+    ariaLabelledBy;
+    /**
+     * Event fired when a tab is selected.
+     * @param {MenuItem} item - Menu item.
+     * @group Emits
+     */
+    activeItemChange = new EventEmitter();
+    content;
+    navbar;
+    inkbar;
+    prevBtn;
+    nextBtn;
+    tabLink;
+    tab;
+    templates;
+    itemTemplate;
+    previousIconTemplate;
+    nextIconTemplate;
+    tabChanged;
+    backwardIsDisabled = true;
+    forwardIsDisabled = false;
+    timerIdForAutoScroll = null;
+    _focusableItems;
+    _model;
+    _activeItem;
+    focusedItemInfo = signal(null);
+    get focusableItems() {
+        if (!this._focusableItems || !this._focusableItems.length) {
+            this._focusableItems = (this.model || []).reduce((result, item) => {
+                result.push(item);
+                return result;
+            }, []);
+        }
+        return this._focusableItems;
+    }
+    constructor(platformId, router, route, cd) {
+        this.platformId = platformId;
+        this.router = router;
+        this.route = route;
+        this.cd = cd;
+        this.router.events.pipe(filter((event) => event instanceof NavigationEnd)).subscribe((event) => {
+            this.cd.markForCheck();
+        });
+    }
+    ngOnChanges(simpleChange) {
+        if (simpleChange.activeItem) {
+            this.autoScrollForActiveItem();
+        }
+    }
+    ngAfterContentInit() {
+        this.templates?.forEach((item) => {
+            switch (item.getType()) {
+                case 'item':
+                    this.itemTemplate = item.template;
+                    break;
+                case 'nexticon':
+                    this.nextIconTemplate = item.template;
+                    break;
+                case 'previousicon':
+                    this.previousIconTemplate = item.template;
+                    break;
+                default:
+                    this.itemTemplate = item.template;
+                    break;
+            }
+        });
+    }
+    ngAfterViewInit() {
+        if (isPlatformBrowser(this.platformId)) {
+            this.updateInkBar();
+            this.autoScrollForActiveItem();
+            this.initButtonState();
+        }
+    }
+    ngAfterViewChecked() {
+        if (isPlatformBrowser(this.platformId)) {
+            this.updateInkBar();
+            this.tabChanged = false;
+        }
+    }
+    ngOnDestroy() {
+        this.clearAutoScrollHandler();
+    }
+    isActive(item) {
+        if (item.routerLink) {
+            const routerLink = Array.isArray(item.routerLink) ? item.routerLink : [item.routerLink];
+            return this.router.isActive(this.router.createUrlTree(routerLink, { relativeTo: this.route }).toString(), item.routerLinkActiveOptions?.exact ?? item.routerLinkActiveOptions ?? false);
+        }
+        return item === this.activeItem;
+    }
+    getItemProp(item, name) {
+        return item ? ObjectUtils.getItemValue(item[name]) : undefined;
+    }
+    visible(item) {
+        return typeof item.visible === 'function' ? item.visible() : item.visible !== false;
+    }
+    disabled(item) {
+        return typeof item.disabled === 'function' ? item.disabled() : item.disabled;
+    }
+    onMenuItemFocus(item) {
+        this.focusedItemInfo.set(item);
+    }
+    itemClick(event, item) {
+        if (item.disabled) {
+            event.preventDefault();
+            return;
+        }
+        if (!item.url && !item.routerLink) {
+            event.preventDefault();
+        }
+        if (item.command) {
+            item.command({
+                originalEvent: event,
+                item: item
+            });
+        }
+        this.activeItem = item;
+        this.tabChanged = true;
+        this.cd.markForCheck();
+    }
+    onKeydownItem(event, index, item) {
+        let i = index;
+        let foundElement = {};
+        const tabLinks = this.tabLink.toArray();
+        const tabs = this.tab.toArray();
+        switch (event.code) {
+            case 'ArrowRight':
+                foundElement = this.findNextItem(tabs, i);
+                i = foundElement['i'];
+                break;
+            case 'ArrowLeft':
+                foundElement = this.findPrevItem(tabs, i);
+                i = foundElement['i'];
+                break;
+            case 'End':
+                foundElement = this.findPrevItem(tabs, this.model.length);
+                i = foundElement['i'];
+                event.preventDefault();
+                break;
+            case 'Home':
+                foundElement = this.findNextItem(tabs, -1);
+                i = foundElement['i'];
+                event.preventDefault();
+                break;
+            case 'Space':
+            case 'Enter':
+                this.itemClick(event, item);
+                break;
+            case 'Tab':
+                this.onTabKeyDown(tabLinks);
+                break;
+            default:
+                break;
+        }
+        if (tabLinks[i] && tabLinks[index]) {
+            tabLinks[index].nativeElement.tabIndex = '-1';
+            tabLinks[i].nativeElement.tabIndex = '0';
+            tabLinks[i].nativeElement.focus();
+        }
+        this.cd.markForCheck();
+    }
+    onTabKeyDown(tabLinks) {
+        tabLinks.forEach((item) => {
+            item.nativeElement.tabIndex = DomHandler.getAttribute(item.nativeElement.parentElement, 'data-p-highlight') ? '0' : '-1';
+        });
+    }
+    findNextItem(items, index) {
+        let i = index + 1;
+        if (i >= items.length) {
+            return { nextItem: items[items.length], i: items.length };
+        }
+        let nextItem = items[i];
+        if (nextItem)
+            return DomHandler.getAttribute(nextItem.nativeElement, 'data-p-disabled') ? this.findNextItem(items, i) : { nextItem: nextItem.nativeElement, i };
+        else
+            return null;
+    }
+    findPrevItem(items, index) {
+        let i = index - 1;
+        if (i < 0) {
+            return { prevItem: items[0], i: 0 };
+        }
+        let prevItem = items[i];
+        if (prevItem)
+            return DomHandler.getAttribute(prevItem.nativeElement, 'data-p-disabled') ? this.findPrevItem(items, i) : { prevItem: prevItem.nativeElement, i };
+        else
+            return null;
+    }
+    updateInkBar() {
+        const tabHeader = DomHandler.findSingle(this.navbar?.nativeElement, 'li.p-highlight');
+        if (tabHeader) {
+            this.inkbar.nativeElement.style.width = DomHandler.getWidth(tabHeader) + 'px';
+            this.inkbar.nativeElement.style.left = DomHandler.getOffset(tabHeader).left - DomHandler.getOffset(this.navbar?.nativeElement).left + 'px';
+        }
+    }
+    getVisibleButtonWidths() {
+        return [this.prevBtn?.nativeElement, this.nextBtn?.nativeElement].reduce((acc, el) => (el ? acc + DomHandler.getWidth(el) : acc), 0);
+    }
+    updateButtonState() {
+        const content = this.content?.nativeElement;
+        const { scrollLeft, scrollWidth } = content;
+        const width = DomHandler.getWidth(content);
+        this.backwardIsDisabled = scrollLeft === 0;
+        this.forwardIsDisabled = parseInt(scrollLeft) === scrollWidth - width;
+    }
+    updateScrollBar(index) {
+        const tabHeader = this.navbar?.nativeElement.children[index];
+        if (!tabHeader) {
+            return;
+        }
+        if (tabHeader && typeof tabHeader.scrollIntoView === 'function') {
+            tabHeader.scrollIntoView({ block: 'nearest', inline: 'center' });
+        }
+    }
+    onScroll(event) {
+        this.scrollable && this.updateButtonState();
+        event.preventDefault();
+    }
+    navBackward() {
+        const content = this.content?.nativeElement;
+        const width = DomHandler.getWidth(content) - this.getVisibleButtonWidths();
+        const pos = content.scrollLeft - width;
+        content.scrollLeft = pos <= 0 ? 0 : pos;
+    }
+    navForward() {
+        const content = this.content?.nativeElement;
+        const width = DomHandler.getWidth(content) - this.getVisibleButtonWidths();
+        const pos = content.scrollLeft + width;
+        const lastPos = content.scrollWidth - width;
+        content.scrollLeft = pos >= lastPos ? lastPos : pos;
+    }
+    autoScrollForActiveItem() {
+        if (!this.scrollable) {
+            return;
+        }
+        this.clearAutoScrollHandler();
+        // We have to wait for the rendering and then can scroll to element.
+        this.timerIdForAutoScroll = setTimeout(() => {
+            const activeItem = this.model.findIndex((menuItem) => this.isActive(menuItem));
+            if (activeItem !== -1) {
+                this.updateScrollBar(activeItem);
+            }
+        });
+    }
+    clearAutoScrollHandler() {
+        if (this.timerIdForAutoScroll) {
+            clearTimeout(this.timerIdForAutoScroll);
+            this.timerIdForAutoScroll = null;
+        }
+    }
+    initButtonState() {
+        if (this.scrollable) {
+            // We have to wait for the rendering and then retrieve the actual size element from the DOM.
+            // in future `Promise.resolve` can be changed to `queueMicrotask` (if ie11 support will be dropped)
+            Promise.resolve().then(() => {
+                this.updateButtonState();
+                this.cd.markForCheck();
+            });
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: TabMenu, deps: [{ token: PLATFORM_ID }, { token: i1.Router }, { token: i1.ActivatedRoute }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "16.1.0", version: "18.2.9", type: TabMenu, selector: "p-tabMenu", inputs: { model: "model", activeItem: "activeItem", scrollable: ["scrollable", "scrollable", booleanAttribute], popup: ["popup", "popup", booleanAttribute], style: "style", styleClass: "styleClass", ariaLabel: "ariaLabel", ariaLabelledBy: "ariaLabelledBy" }, outputs: { activeItemChange: "activeItemChange" }, host: { classAttribute: "cax-element" }, queries: [{ propertyName: "templates", predicate: CaxTemplate }], viewQueries: [{ propertyName: "content", first: true, predicate: ["content"], descendants: true }, { propertyName: "navbar", first: true, predicate: ["navbar"], descendants: true }, { propertyName: "inkbar", first: true, predicate: ["inkbar"], descendants: true }, { propertyName: "prevBtn", first: true, predicate: ["prevBtn"], descendants: true }, { propertyName: "nextBtn", first: true, predicate: ["nextBtn"], descendants: true }, { propertyName: "tabLink", predicate: ["tabLink"], descendants: true }, { propertyName: "tab", predicate: ["tab"], descendants: true }], usesOnChanges: true, ngImport: i0, template: `
+        <div [ngClass]="{ 'p-tabmenu p-component': true, 'p-tabmenu-scrollable': scrollable }" [ngStyle]="style" [class]="styleClass">
+            <div class="p-tabmenu-nav-container">
+                <button *ngIf="scrollable && !backwardIsDisabled" #prevBtn class="p-tabmenu-nav-prev p-tabmenu-nav-btn p-link" (click)="navBackward()" type="button" role="navigation" pRipple>
+                    <ChevronLeftIcon *ngIf="!previousIconTemplate" [attr.aria-hidden]="true" />
+                    <ng-template *ngTemplateOutlet="previousIconTemplate"></ng-template>
+                </button>
+                <div #content class="p-tabmenu-nav-content" (scroll)="onScroll($event)">
+                    <ul #navbar class="p-tabmenu-nav p-reset" role="menubar" [attr.aria-labelledby]="ariaLabelledBy" [attr.aria-label]="ariaLabel">
+                        <li
+                            #tab
+                            *ngFor="let item of focusableItems; let i = index"
+                            role="presentation"
+                            [ngStyle]="item.style"
+                            [class]="item.styleClass"
+                            [attr.data-p-disabled]="disabled(item)"
+                            [attr.data-p-highlight]="focusedItemInfo() === item"
+                            (click)="itemClick($event, item)"
+                            (keydown)="onKeydownItem($event, i, item)"
+                            (focus)="onMenuItemFocus(item)"
+                            [ngClass]="{ 'p-tabmenuitem': true, 'p-disabled': getItemProp(item, 'disabled'), 'p-highlight': isActive(item), 'p-hidden': item.visible === false }"
+                            caxTooltip
+                            [tooltipOptions]="item.tooltipOptions"
+                        >
+                            <a
+                                #tabLink
+                                *ngIf="!item.routerLink && !itemTemplate"
+                                class="p-menuitem-link"
+                                role="menuitem"
+                                [attr.href]="getItemProp(item, 'url')"
+                                [attr.id]="getItemProp(item, 'id')"
+                                [attr.aria-disabled]="disabled(item)"
+                                [attr.aria-label]="getItemProp(item, 'label')"
+                                [attr.tabindex]="disabled(item) ? -1 : 0"
+                                [target]="getItemProp(item, 'target')"
+                                pRipple
+                            >
+                                <ng-container>
+                                    <span class="p-menuitem-icon" [ngClass]="item.icon" *ngIf="item.icon" [ngStyle]="item.iconStyle"></span>
+                                    <span class="p-menuitem-text" *ngIf="item.escape !== false; else htmlLabel">{{ getItemProp(item, 'label') }}</span>
+                                    <ng-template #htmlLabel><span class="p-menuitem-text" [innerHTML]="getItemProp(item, 'label')"></span></ng-template>
+                                    <span class="p-menuitem-badge" *ngIf="item.badge" [ngClass]="item.badgeStyleClass">{{ getItemProp(item, 'badge') }}</span>
+                                </ng-container>
+                            </a>
+                            <a
+                                #tabLink
+                                *ngIf="item.routerLink && !itemTemplate"
+                                [routerLink]="item.routerLink"
+                                [queryParams]="item.queryParams"
+                                [routerLinkActive]="'p-menuitem-link-active'"
+                                [routerLinkActiveOptions]="item.routerLinkActiveOptions || { exact: false }"
+                                role="menuitem"
+                                class="p-menuitem-link"
+                                [target]="item.target"
+                                [attr.id]="getItemProp(item, 'id')"
+                                [attr.aria-disabled]="disabled(item)"
+                                [attr.aria-label]="getItemProp(item, 'label')"
+                                [attr.tabindex]="disabled(item) ? -1 : 0"
+                                [fragment]="item.fragment"
+                                [queryParamsHandling]="item.queryParamsHandling"
+                                [preserveFragment]="item.preserveFragment"
+                                [skipLocationChange]="item.skipLocationChange"
+                                [replaceUrl]="item.replaceUrl"
+                                [state]="item.state"
+                                pRipple
+                            >
+                                <ng-container>
+                                    <span class="p-menuitem-icon" [attr.aria-hidden]="true" [ngClass]="item.icon" *ngIf="item.icon" [ngStyle]="item.iconStyle"></span>
+                                    <span class="p-menuitem-text" *ngIf="item.escape !== false; else htmlRouteLabel">{{ getItemProp(item, 'label') }}</span>
+                                    <ng-template #htmlRouteLabel><span class="p-menuitem-text" [innerHTML]="getItemProp(item, 'label')"></span></ng-template>
+                                    <span class="p-menuitem-badge" *ngIf="item.badge" [ngClass]="item.badgeStyleClass">{{ getItemProp(item, 'badge') }}</span>
+                                </ng-container>
+                            </a>
+                            <ng-container *ngTemplateOutlet="itemTemplate; context: { $implicit: item, index: i }"></ng-container>
+                        </li>
+                        <li #inkbar class="p-tabmenu-ink-bar" role="none"></li>
+                    </ul>
+                </div>
+                <button *ngIf="scrollable && !forwardIsDisabled" #nextBtn class="p-tabmenu-nav-next p-tabmenu-nav-btn p-link" (click)="navForward()" type="button" role="navigation" pRipple>
+                    <ChevronRightIcon *ngIf="!previousIconTemplate" [attr.aria-hidden]="true" />
+                    <ng-template *ngTemplateOutlet="nextIconTemplate"></ng-template>
+                </button>
+            </div>
+        </div>
+    `, isInline: true, styles: ["@layer cax{.p-tabmenu-nav-container{position:relative}.p-tabmenu-scrollable .p-tabmenu-nav-container{overflow:hidden}.p-tabmenu-nav-content{overflow-x:auto;overflow-y:hidden;scroll-behavior:smooth;scrollbar-width:none;overscroll-behavior:contain auto}.p-tabmenu-nav-btn{position:absolute;top:0;z-index:2;height:100%;display:flex;align-items:center;justify-content:center}.p-tabmenu-nav-prev{left:0}.p-tabmenu-nav-next{right:0}.p-tabview-nav-content::-webkit-scrollbar{display:none}.p-tabmenu-nav{display:flex;margin:0;padding:0;list-style-type:none;flex-wrap:nowrap}.p-tabmenu-nav a{cursor:pointer;-webkit-user-select:none;user-select:none;display:flex;align-items:center;position:relative;text-decoration:none;overflow:hidden}.p-tabmenu-nav a:focus{z-index:1}.p-tabmenu-nav .p-menuitem-text{line-height:1;white-space:nowrap}.p-tabmenu-ink-bar{display:none;z-index:1}.p-tabmenu-nav-content::-webkit-scrollbar{display:none}.p-tabmenuitem:not(.p-hidden){display:flex}}\n"], dependencies: [{ kind: "directive", type: i0.forwardRef(() => i2.NgClass), selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i0.forwardRef(() => i2.NgForOf), selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i0.forwardRef(() => i2.NgIf), selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i0.forwardRef(() => i2.NgTemplateOutlet), selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i0.forwardRef(() => i2.NgStyle), selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "directive", type: i0.forwardRef(() => i1.RouterLink), selector: "[routerLink]", inputs: ["target", "queryParams", "fragment", "queryParamsHandling", "state", "info", "relativeTo", "preserveFragment", "skipLocationChange", "replaceUrl", "routerLink"] }, { kind: "directive", type: i0.forwardRef(() => i1.RouterLinkActive), selector: "[routerLinkActive]", inputs: ["routerLinkActiveOptions", "ariaCurrentWhenActive", "routerLinkActive"], outputs: ["isActiveChange"], exportAs: ["routerLinkActive"] }, { kind: "directive", type: i0.forwardRef(() => i3.Tooltip), selector: "[caxTooltip]", inputs: ["tooltipPosition", "tooltipEvent", "appendTo", "positionStyle", "tooltipStyleClass", "tooltipZIndex", "escape", "showDelay", "hideDelay", "life", "positionTop", "positionLeft", "autoHide", "fitContent", "hideOnEscape", "caxTooltip", "tooltipDisabled", "tooltipOptions", "linkUrl", "linkText"] }, { kind: "component", type: i0.forwardRef(() => ChevronLeftIcon), selector: "ChevronLeftIcon" }, { kind: "component", type: i0.forwardRef(() => ChevronRightIcon), selector: "ChevronRightIcon" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: TabMenu, decorators: [{
+            type: Component,
+            args: [{ selector: 'p-tabMenu', template: `
+        <div [ngClass]="{ 'p-tabmenu p-component': true, 'p-tabmenu-scrollable': scrollable }" [ngStyle]="style" [class]="styleClass">
+            <div class="p-tabmenu-nav-container">
+                <button *ngIf="scrollable && !backwardIsDisabled" #prevBtn class="p-tabmenu-nav-prev p-tabmenu-nav-btn p-link" (click)="navBackward()" type="button" role="navigation" pRipple>
+                    <ChevronLeftIcon *ngIf="!previousIconTemplate" [attr.aria-hidden]="true" />
+                    <ng-template *ngTemplateOutlet="previousIconTemplate"></ng-template>
+                </button>
+                <div #content class="p-tabmenu-nav-content" (scroll)="onScroll($event)">
+                    <ul #navbar class="p-tabmenu-nav p-reset" role="menubar" [attr.aria-labelledby]="ariaLabelledBy" [attr.aria-label]="ariaLabel">
+                        <li
+                            #tab
+                            *ngFor="let item of focusableItems; let i = index"
+                            role="presentation"
+                            [ngStyle]="item.style"
+                            [class]="item.styleClass"
+                            [attr.data-p-disabled]="disabled(item)"
+                            [attr.data-p-highlight]="focusedItemInfo() === item"
+                            (click)="itemClick($event, item)"
+                            (keydown)="onKeydownItem($event, i, item)"
+                            (focus)="onMenuItemFocus(item)"
+                            [ngClass]="{ 'p-tabmenuitem': true, 'p-disabled': getItemProp(item, 'disabled'), 'p-highlight': isActive(item), 'p-hidden': item.visible === false }"
+                            caxTooltip
+                            [tooltipOptions]="item.tooltipOptions"
+                        >
+                            <a
+                                #tabLink
+                                *ngIf="!item.routerLink && !itemTemplate"
+                                class="p-menuitem-link"
+                                role="menuitem"
+                                [attr.href]="getItemProp(item, 'url')"
+                                [attr.id]="getItemProp(item, 'id')"
+                                [attr.aria-disabled]="disabled(item)"
+                                [attr.aria-label]="getItemProp(item, 'label')"
+                                [attr.tabindex]="disabled(item) ? -1 : 0"
+                                [target]="getItemProp(item, 'target')"
+                                pRipple
+                            >
+                                <ng-container>
+                                    <span class="p-menuitem-icon" [ngClass]="item.icon" *ngIf="item.icon" [ngStyle]="item.iconStyle"></span>
+                                    <span class="p-menuitem-text" *ngIf="item.escape !== false; else htmlLabel">{{ getItemProp(item, 'label') }}</span>
+                                    <ng-template #htmlLabel><span class="p-menuitem-text" [innerHTML]="getItemProp(item, 'label')"></span></ng-template>
+                                    <span class="p-menuitem-badge" *ngIf="item.badge" [ngClass]="item.badgeStyleClass">{{ getItemProp(item, 'badge') }}</span>
+                                </ng-container>
+                            </a>
+                            <a
+                                #tabLink
+                                *ngIf="item.routerLink && !itemTemplate"
+                                [routerLink]="item.routerLink"
+                                [queryParams]="item.queryParams"
+                                [routerLinkActive]="'p-menuitem-link-active'"
+                                [routerLinkActiveOptions]="item.routerLinkActiveOptions || { exact: false }"
+                                role="menuitem"
+                                class="p-menuitem-link"
+                                [target]="item.target"
+                                [attr.id]="getItemProp(item, 'id')"
+                                [attr.aria-disabled]="disabled(item)"
+                                [attr.aria-label]="getItemProp(item, 'label')"
+                                [attr.tabindex]="disabled(item) ? -1 : 0"
+                                [fragment]="item.fragment"
+                                [queryParamsHandling]="item.queryParamsHandling"
+                                [preserveFragment]="item.preserveFragment"
+                                [skipLocationChange]="item.skipLocationChange"
+                                [replaceUrl]="item.replaceUrl"
+                                [state]="item.state"
+                                pRipple
+                            >
+                                <ng-container>
+                                    <span class="p-menuitem-icon" [attr.aria-hidden]="true" [ngClass]="item.icon" *ngIf="item.icon" [ngStyle]="item.iconStyle"></span>
+                                    <span class="p-menuitem-text" *ngIf="item.escape !== false; else htmlRouteLabel">{{ getItemProp(item, 'label') }}</span>
+                                    <ng-template #htmlRouteLabel><span class="p-menuitem-text" [innerHTML]="getItemProp(item, 'label')"></span></ng-template>
+                                    <span class="p-menuitem-badge" *ngIf="item.badge" [ngClass]="item.badgeStyleClass">{{ getItemProp(item, 'badge') }}</span>
+                                </ng-container>
+                            </a>
+                            <ng-container *ngTemplateOutlet="itemTemplate; context: { $implicit: item, index: i }"></ng-container>
+                        </li>
+                        <li #inkbar class="p-tabmenu-ink-bar" role="none"></li>
+                    </ul>
+                </div>
+                <button *ngIf="scrollable && !forwardIsDisabled" #nextBtn class="p-tabmenu-nav-next p-tabmenu-nav-btn p-link" (click)="navForward()" type="button" role="navigation" pRipple>
+                    <ChevronRightIcon *ngIf="!previousIconTemplate" [attr.aria-hidden]="true" />
+                    <ng-template *ngTemplateOutlet="nextIconTemplate"></ng-template>
+                </button>
+            </div>
+        </div>
+    `, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, host: {
+                        class: 'cax-element'
+                    }, styles: ["@layer cax{.p-tabmenu-nav-container{position:relative}.p-tabmenu-scrollable .p-tabmenu-nav-container{overflow:hidden}.p-tabmenu-nav-content{overflow-x:auto;overflow-y:hidden;scroll-behavior:smooth;scrollbar-width:none;overscroll-behavior:contain auto}.p-tabmenu-nav-btn{position:absolute;top:0;z-index:2;height:100%;display:flex;align-items:center;justify-content:center}.p-tabmenu-nav-prev{left:0}.p-tabmenu-nav-next{right:0}.p-tabview-nav-content::-webkit-scrollbar{display:none}.p-tabmenu-nav{display:flex;margin:0;padding:0;list-style-type:none;flex-wrap:nowrap}.p-tabmenu-nav a{cursor:pointer;-webkit-user-select:none;user-select:none;display:flex;align-items:center;position:relative;text-decoration:none;overflow:hidden}.p-tabmenu-nav a:focus{z-index:1}.p-tabmenu-nav .p-menuitem-text{line-height:1;white-space:nowrap}.p-tabmenu-ink-bar{display:none;z-index:1}.p-tabmenu-nav-content::-webkit-scrollbar{display:none}.p-tabmenuitem:not(.p-hidden){display:flex}}\n"] }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: i1.Router }, { type: i1.ActivatedRoute }, { type: i0.ChangeDetectorRef }], propDecorators: { model: [{
+                type: Input
+            }], activeItem: [{
+                type: Input
+            }], scrollable: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], popup: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], style: [{
+                type: Input
+            }], styleClass: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], ariaLabelledBy: [{
+                type: Input
+            }], activeItemChange: [{
+                type: Output
+            }], content: [{
+                type: ViewChild,
+                args: ['content']
+            }], navbar: [{
+                type: ViewChild,
+                args: ['navbar']
+            }], inkbar: [{
+                type: ViewChild,
+                args: ['inkbar']
+            }], prevBtn: [{
+                type: ViewChild,
+                args: ['prevBtn']
+            }], nextBtn: [{
+                type: ViewChild,
+                args: ['nextBtn']
+            }], tabLink: [{
+                type: ViewChildren,
+                args: ['tabLink']
+            }], tab: [{
+                type: ViewChildren,
+                args: ['tab']
+            }], templates: [{
+                type: ContentChildren,
+                args: [CaxTemplate]
+            }] } });
+export class TabMenuModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: TabMenuModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.9", ngImport: i0, type: TabMenuModule, declarations: [TabMenu], imports: [CommonModule, RouterModule, SharedModule, RippleModule, TooltipModule, ChevronLeftIcon, ChevronRightIcon], exports: [TabMenu, RouterModule, SharedModule, TooltipModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: TabMenuModule, imports: [CommonModule, RouterModule, SharedModule, RippleModule, TooltipModule, ChevronLeftIcon, ChevronRightIcon, RouterModule, SharedModule, TooltipModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: TabMenuModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, RouterModule, SharedModule, RippleModule, TooltipModule, ChevronLeftIcon, ChevronRightIcon],
+                    exports: [TabMenu, RouterModule, SharedModule, TooltipModule],
+                    declarations: [TabMenu]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tabmenu.js","sourceRoot":"","sources":["../../../src/app/components/tabmenu/tabmenu.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule, isPlatformBrowser } from '@angular/common';\nimport {\n    AfterContentInit,\n    AfterViewChecked,\n    AfterViewInit,\n    ChangeDetectionStrategy,\n    ChangeDetectorRef,\n    Component,\n    ContentChildren,\n    ElementRef,\n    EventEmitter,\n    Inject,\n    Input,\n    NgModule,\n    OnDestroy,\n    Output,\n    PLATFORM_ID,\n    QueryList,\n    SimpleChanges,\n    TemplateRef,\n    ViewChild,\n    ViewChildren,\n    ViewEncapsulation,\n    booleanAttribute,\n    signal\n} from '@angular/core';\nimport { ActivatedRoute, NavigationEnd, Router, RouterModule } from '@angular/router';\nimport { MenuItem, CaxTemplate, SharedModule } from 'cax-design-system/api';\nimport { DomHandler } from 'cax-design-system/dom';\nimport { ChevronLeftIcon } from 'cax-design-system/icons/chevronleft';\nimport { ChevronRightIcon } from 'cax-design-system/icons/chevronright';\nimport { RippleModule } from 'cax-design-system/ripple';\nimport { TooltipModule } from 'cax-design-system/tooltip';\nimport { Nullable } from 'cax-design-system/ts-helpers';\nimport { ObjectUtils } from 'cax-design-system/utils';\nimport { filter } from 'rxjs/operators';\n\n/**\n * TabMenu is a navigation component that displays items as tab headers.\n * @group Components\n */\n@Component({\n    selector: 'p-tabMenu',\n    template: `\n        <div [ngClass]=\"{ 'p-tabmenu p-component': true, 'p-tabmenu-scrollable': scrollable }\" [ngStyle]=\"style\" [class]=\"styleClass\">\n            <div class=\"p-tabmenu-nav-container\">\n                <button *ngIf=\"scrollable && !backwardIsDisabled\" #prevBtn class=\"p-tabmenu-nav-prev p-tabmenu-nav-btn p-link\" (click)=\"navBackward()\" type=\"button\" role=\"navigation\" pRipple>\n                    <ChevronLeftIcon *ngIf=\"!previousIconTemplate\" [attr.aria-hidden]=\"true\" />\n                    <ng-template *ngTemplateOutlet=\"previousIconTemplate\"></ng-template>\n                </button>\n                <div #content class=\"p-tabmenu-nav-content\" (scroll)=\"onScroll($event)\">\n                    <ul #navbar class=\"p-tabmenu-nav p-reset\" role=\"menubar\" [attr.aria-labelledby]=\"ariaLabelledBy\" [attr.aria-label]=\"ariaLabel\">\n                        <li\n                            #tab\n                            *ngFor=\"let item of focusableItems; let i = index\"\n                            role=\"presentation\"\n                            [ngStyle]=\"item.style\"\n                            [class]=\"item.styleClass\"\n                            [attr.data-p-disabled]=\"disabled(item)\"\n                            [attr.data-p-highlight]=\"focusedItemInfo() === item\"\n                            (click)=\"itemClick($event, item)\"\n                            (keydown)=\"onKeydownItem($event, i, item)\"\n                            (focus)=\"onMenuItemFocus(item)\"\n                            [ngClass]=\"{ 'p-tabmenuitem': true, 'p-disabled': getItemProp(item, 'disabled'), 'p-highlight': isActive(item), 'p-hidden': item.visible === false }\"\n                            caxTooltip\n                            [tooltipOptions]=\"item.tooltipOptions\"\n                        >\n                            <a\n                                #tabLink\n                                *ngIf=\"!item.routerLink && !itemTemplate\"\n                                class=\"p-menuitem-link\"\n                                role=\"menuitem\"\n                                [attr.href]=\"getItemProp(item, 'url')\"\n                                [attr.id]=\"getItemProp(item, 'id')\"\n                                [attr.aria-disabled]=\"disabled(item)\"\n                                [attr.aria-label]=\"getItemProp(item, 'label')\"\n                                [attr.tabindex]=\"disabled(item) ? -1 : 0\"\n                                [target]=\"getItemProp(item, 'target')\"\n                                pRipple\n                            >\n                                <ng-container>\n                                    <span class=\"p-menuitem-icon\" [ngClass]=\"item.icon\" *ngIf=\"item.icon\" [ngStyle]=\"item.iconStyle\"></span>\n                                    <span class=\"p-menuitem-text\" *ngIf=\"item.escape !== false; else htmlLabel\">{{ getItemProp(item, 'label') }}</span>\n                                    <ng-template #htmlLabel><span class=\"p-menuitem-text\" [innerHTML]=\"getItemProp(item, 'label')\"></span></ng-template>\n                                    <span class=\"p-menuitem-badge\" *ngIf=\"item.badge\" [ngClass]=\"item.badgeStyleClass\">{{ getItemProp(item, 'badge') }}</span>\n                                </ng-container>\n                            </a>\n                            <a\n                                #tabLink\n                                *ngIf=\"item.routerLink && !itemTemplate\"\n                                [routerLink]=\"item.routerLink\"\n                                [queryParams]=\"item.queryParams\"\n                                [routerLinkActive]=\"'p-menuitem-link-active'\"\n                                [routerLinkActiveOptions]=\"item.routerLinkActiveOptions || { exact: false }\"\n                                role=\"menuitem\"\n                                class=\"p-menuitem-link\"\n                                [target]=\"item.target\"\n                                [attr.id]=\"getItemProp(item, 'id')\"\n                                [attr.aria-disabled]=\"disabled(item)\"\n                                [attr.aria-label]=\"getItemProp(item, 'label')\"\n                                [attr.tabindex]=\"disabled(item) ? -1 : 0\"\n                                [fragment]=\"item.fragment\"\n                                [queryParamsHandling]=\"item.queryParamsHandling\"\n                                [preserveFragment]=\"item.preserveFragment\"\n                                [skipLocationChange]=\"item.skipLocationChange\"\n                                [replaceUrl]=\"item.replaceUrl\"\n                                [state]=\"item.state\"\n                                pRipple\n                            >\n                                <ng-container>\n                                    <span class=\"p-menuitem-icon\" [attr.aria-hidden]=\"true\" [ngClass]=\"item.icon\" *ngIf=\"item.icon\" [ngStyle]=\"item.iconStyle\"></span>\n                                    <span class=\"p-menuitem-text\" *ngIf=\"item.escape !== false; else htmlRouteLabel\">{{ getItemProp(item, 'label') }}</span>\n                                    <ng-template #htmlRouteLabel><span class=\"p-menuitem-text\" [innerHTML]=\"getItemProp(item, 'label')\"></span></ng-template>\n                                    <span class=\"p-menuitem-badge\" *ngIf=\"item.badge\" [ngClass]=\"item.badgeStyleClass\">{{ getItemProp(item, 'badge') }}</span>\n                                </ng-container>\n                            </a>\n                            <ng-container *ngTemplateOutlet=\"itemTemplate; context: { $implicit: item, index: i }\"></ng-container>\n                        </li>\n                        <li #inkbar class=\"p-tabmenu-ink-bar\" role=\"none\"></li>\n                    </ul>\n                </div>\n                <button *ngIf=\"scrollable && !forwardIsDisabled\" #nextBtn class=\"p-tabmenu-nav-next p-tabmenu-nav-btn p-link\" (click)=\"navForward()\" type=\"button\" role=\"navigation\" pRipple>\n                    <ChevronRightIcon *ngIf=\"!previousIconTemplate\" [attr.aria-hidden]=\"true\" />\n                    <ng-template *ngTemplateOutlet=\"nextIconTemplate\"></ng-template>\n                </button>\n            </div>\n        </div>\n    `,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    encapsulation: ViewEncapsulation.None,\n    styleUrls: ['./tabmenu.css'],\n    host: {\n        class: 'cax-element'\n    }\n})\nexport class TabMenu implements AfterContentInit, AfterViewInit, AfterViewChecked, OnDestroy {\n    /**\n     * An array of menuitems.\n     * @group Props\n     */\n    @Input() set model(value: MenuItem[] | undefined) {\n        this._model = value;\n        this._focusableItems = (this._model || []).reduce((result, item) => {\n            result.push(item);\n\n            return result;\n        }, []);\n    }\n    get model(): MenuItem[] | undefined {\n        return this._model;\n    }\n    /**\n     * Defines the default active menuitem\n     * @group Props\n     */\n    @Input() set activeItem(value: MenuItem | undefined) {\n        this._activeItem = value;\n        this.activeItemChange.emit(value);\n        this.tabChanged = true;\n    }\n\n    get activeItem(): MenuItem | undefined {\n        return this._activeItem;\n    }\n    /**\n     * When enabled displays buttons at each side of the tab headers to scroll the tab list.\n     * @group Props\n     */\n    @Input({ transform: booleanAttribute }) scrollable: boolean | undefined;\n    /**\n     * Defines if popup mode enabled.\n     */\n    @Input({ transform: booleanAttribute }) popup: boolean | undefined;\n    /**\n     * Inline style of the element.\n     * @group Props\n     */\n    @Input() style: { [klass: string]: any } | null | undefined;\n    /**\n     * Class of the element.\n     * @group Props\n     */\n    @Input() styleClass: string | undefined;\n    /**\n     * Defines a string value that labels an interactive element.\n     * @group Props\n     */\n    @Input() ariaLabel: string | undefined;\n    /**\n     * Identifier of the underlying input element.\n     * @group Props\n     */\n    @Input() ariaLabelledBy: string | undefined;\n    /**\n     * Event fired when a tab is selected.\n     * @param {MenuItem} item - Menu item.\n     * @group Emits\n     */\n    @Output() activeItemChange: EventEmitter<MenuItem> = new EventEmitter<MenuItem>();\n\n    @ViewChild('content') content: Nullable<ElementRef>;\n\n    @ViewChild('navbar') navbar: Nullable<ElementRef>;\n\n    @ViewChild('inkbar') inkbar: Nullable<ElementRef>;\n\n    @ViewChild('prevBtn') prevBtn: Nullable<ElementRef>;\n\n    @ViewChild('nextBtn') nextBtn: Nullable<ElementRef>;\n\n    @ViewChildren('tabLink') tabLink: Nullable<QueryList<ElementRef>>;\n\n    @ViewChildren('tab') tab: Nullable<QueryList<ElementRef>>;\n\n    @ContentChildren(CaxTemplate) templates: QueryList<CaxTemplate> | undefined;\n\n    itemTemplate: Nullable<TemplateRef<any>>;\n\n    previousIconTemplate: Nullable<TemplateRef<any>>;\n\n    nextIconTemplate: Nullable<TemplateRef<any>>;\n\n    tabChanged: boolean | undefined;\n\n    backwardIsDisabled: boolean = true;\n\n    forwardIsDisabled: boolean = false;\n\n    private timerIdForAutoScroll: any = null;\n\n    _focusableItems: MenuItem[] | undefined | any;\n\n    _model: MenuItem[] | undefined;\n\n    _activeItem: MenuItem | undefined;\n\n    focusedItemInfo = signal<any>(null);\n\n    get focusableItems() {\n        if (!this._focusableItems || !this._focusableItems.length) {\n            this._focusableItems = (this.model || []).reduce((result, item) => {\n                result.push(item);\n\n                return result;\n            }, []);\n        }\n        return this._focusableItems;\n    }\n\n    constructor(\n        @Inject(PLATFORM_ID) private platformId: any,\n        private router: Router,\n        private route: ActivatedRoute,\n        private cd: ChangeDetectorRef\n    ) {\n        this.router.events.pipe(filter((event) => event instanceof NavigationEnd)).subscribe((event: NavigationEnd) => {\n            this.cd.markForCheck();\n        });\n    }\n\n    ngOnChanges(simpleChange: SimpleChanges) {\n        if (simpleChange.activeItem) {\n            this.autoScrollForActiveItem();\n        }\n    }\n\n    ngAfterContentInit() {\n        this.templates?.forEach((item) => {\n            switch (item.getType()) {\n                case 'item':\n                    this.itemTemplate = item.template;\n                    break;\n\n                case 'nexticon':\n                    this.nextIconTemplate = item.template;\n                    break;\n\n                case 'previousicon':\n                    this.previousIconTemplate = item.template;\n                    break;\n\n                default:\n                    this.itemTemplate = item.template;\n                    break;\n            }\n        });\n    }\n\n    ngAfterViewInit(): void {\n        if (isPlatformBrowser(this.platformId)) {\n            this.updateInkBar();\n            this.autoScrollForActiveItem();\n            this.initButtonState();\n        }\n    }\n\n    ngAfterViewChecked() {\n        if (isPlatformBrowser(this.platformId)) {\n            this.updateInkBar();\n            this.tabChanged = false;\n        }\n    }\n\n    ngOnDestroy(): void {\n        this.clearAutoScrollHandler();\n    }\n\n    isActive(item: MenuItem) {\n        if (item.routerLink) {\n            const routerLink = Array.isArray(item.routerLink) ? item.routerLink : [item.routerLink];\n\n            return this.router.isActive(this.router.createUrlTree(routerLink, { relativeTo: this.route }).toString(), item.routerLinkActiveOptions?.exact ?? item.routerLinkActiveOptions ?? false);\n        }\n\n        return item === this.activeItem;\n    }\n\n    getItemProp(item: any, name: string) {\n        return item ? ObjectUtils.getItemValue(item[name]) : undefined;\n    }\n\n    visible(item) {\n        return typeof item.visible === 'function' ? item.visible() : item.visible !== false;\n    }\n\n    disabled(item) {\n        return typeof item.disabled === 'function' ? item.disabled() : item.disabled;\n    }\n\n    onMenuItemFocus(item) {\n        this.focusedItemInfo.set(item);\n    }\n\n    itemClick(event: Event, item: MenuItem) {\n        if (item.disabled) {\n            event.preventDefault();\n            return;\n        }\n\n        if (!item.url && !item.routerLink) {\n            event.preventDefault();\n        }\n\n        if (item.command) {\n            item.command({\n                originalEvent: event,\n                item: item\n            });\n        }\n\n        this.activeItem = item;\n        this.tabChanged = true;\n        this.cd.markForCheck();\n    }\n\n    onKeydownItem(event, index, item) {\n        let i = index;\n\n        let foundElement = {};\n        const tabLinks = this.tabLink.toArray();\n        const tabs = this.tab.toArray();\n\n        switch (event.code) {\n            case 'ArrowRight':\n                foundElement = this.findNextItem(tabs, i);\n                i = foundElement['i'];\n                break;\n\n            case 'ArrowLeft':\n                foundElement = this.findPrevItem(tabs, i);\n                i = foundElement['i'];\n                break;\n\n            case 'End':\n                foundElement = this.findPrevItem(tabs, this.model.length);\n                i = foundElement['i'];\n\n                event.preventDefault();\n                break;\n\n            case 'Home':\n                foundElement = this.findNextItem(tabs, -1);\n                i = foundElement['i'];\n\n                event.preventDefault();\n                break;\n\n            case 'Space':\n            case 'Enter':\n                this.itemClick(event, item);\n                break;\n\n            case 'Tab':\n                this.onTabKeyDown(tabLinks);\n                break;\n\n            default:\n                break;\n        }\n\n        if (tabLinks[i] && tabLinks[index]) {\n            tabLinks[index].nativeElement.tabIndex = '-1';\n            tabLinks[i].nativeElement.tabIndex = '0';\n            tabLinks[i].nativeElement.focus();\n        }\n        this.cd.markForCheck();\n    }\n\n    onTabKeyDown(tabLinks) {\n        tabLinks.forEach((item) => {\n            item.nativeElement.tabIndex = DomHandler.getAttribute(item.nativeElement.parentElement, 'data-p-highlight') ? '0' : '-1';\n        });\n    }\n\n    findNextItem(items, index) {\n        let i = index + 1;\n\n        if (i >= items.length) {\n            return { nextItem: items[items.length], i: items.length };\n        }\n\n        let nextItem = items[i];\n\n        if (nextItem) return DomHandler.getAttribute(nextItem.nativeElement, 'data-p-disabled') ? this.findNextItem(items, i) : { nextItem: nextItem.nativeElement, i };\n        else return null;\n    }\n\n    findPrevItem(items, index) {\n        let i = index - 1;\n\n        if (i < 0) {\n            return { prevItem: items[0], i: 0 };\n        }\n\n        let prevItem = items[i];\n\n        if (prevItem) return DomHandler.getAttribute(prevItem.nativeElement, 'data-p-disabled') ? this.findPrevItem(items, i) : { prevItem: prevItem.nativeElement, i };\n        else return null;\n    }\n\n    updateInkBar() {\n        const tabHeader = DomHandler.findSingle(this.navbar?.nativeElement, 'li.p-highlight');\n        if (tabHeader) {\n            (this.inkbar as ElementRef).nativeElement.style.width = DomHandler.getWidth(tabHeader) + 'px';\n            (this.inkbar as ElementRef).nativeElement.style.left = DomHandler.getOffset(tabHeader).left - DomHandler.getOffset(this.navbar?.nativeElement).left + 'px';\n        }\n    }\n\n    getVisibleButtonWidths() {\n        return [this.prevBtn?.nativeElement, this.nextBtn?.nativeElement].reduce((acc, el) => (el ? acc + DomHandler.getWidth(el) : acc), 0);\n    }\n\n    updateButtonState() {\n        const content = this.content?.nativeElement;\n        const { scrollLeft, scrollWidth } = content;\n        const width = DomHandler.getWidth(content);\n\n        this.backwardIsDisabled = scrollLeft === 0;\n        this.forwardIsDisabled = parseInt(scrollLeft) === scrollWidth - width;\n    }\n\n    updateScrollBar(index: number): void {\n        const tabHeader = this.navbar?.nativeElement.children[index];\n\n        if (!tabHeader) {\n            return;\n        }\n\n        if (tabHeader && typeof tabHeader.scrollIntoView === 'function') {\n            tabHeader.scrollIntoView({ block: 'nearest', inline: 'center' });\n        }\n    }\n\n    onScroll(event: Event) {\n        this.scrollable && this.updateButtonState();\n\n        event.preventDefault();\n    }\n\n    navBackward() {\n        const content = this.content?.nativeElement;\n        const width = DomHandler.getWidth(content) - this.getVisibleButtonWidths();\n        const pos = content.scrollLeft - width;\n        content.scrollLeft = pos <= 0 ? 0 : pos;\n    }\n\n    navForward() {\n        const content = this.content?.nativeElement;\n        const width = DomHandler.getWidth(content) - this.getVisibleButtonWidths();\n        const pos = content.scrollLeft + width;\n        const lastPos = content.scrollWidth - width;\n        content.scrollLeft = pos >= lastPos ? lastPos : pos;\n    }\n\n    private autoScrollForActiveItem(): void {\n        if (!this.scrollable) {\n            return;\n        }\n\n        this.clearAutoScrollHandler();\n        // We have to wait for the rendering and then can scroll to element.\n        this.timerIdForAutoScroll = setTimeout(() => {\n            const activeItem = (this.model as MenuItem[]).findIndex((menuItem) => this.isActive(menuItem));\n\n            if (activeItem !== -1) {\n                this.updateScrollBar(activeItem);\n            }\n        });\n    }\n\n    private clearAutoScrollHandler(): void {\n        if (this.timerIdForAutoScroll) {\n            clearTimeout(this.timerIdForAutoScroll);\n            this.timerIdForAutoScroll = null;\n        }\n    }\n\n    private initButtonState(): void {\n        if (this.scrollable) {\n            // We have to wait for the rendering and then retrieve the actual size element from the DOM.\n            // in future `Promise.resolve` can be changed to `queueMicrotask` (if ie11 support will be dropped)\n            Promise.resolve().then(() => {\n                this.updateButtonState();\n                this.cd.markForCheck();\n            });\n        }\n    }\n}\n\n@NgModule({\n    imports: [CommonModule, RouterModule, SharedModule, RippleModule, TooltipModule, ChevronLeftIcon, ChevronRightIcon],\n    exports: [TabMenu, RouterModule, SharedModule, TooltipModule],\n    declarations: [TabMenu]\n})\nexport class TabMenuModule {}\n"]}