primeng 18.0.0-beta.1 → 18.0.0-beta.3

package/esm2022/tabs/tab.mjs

@@ -0,0 +1,171 @@
+import { CommonModule } from '@angular/common';
+import { booleanAttribute, ChangeDetectionStrategy, Component, computed, forwardRef, HostListener, inject, input, model, ViewEncapsulation, } from '@angular/core';
+import { BaseComponent } from 'primeng/basecomponent';
+import { ObjectUtils } from 'primeng/utils';
+import { Ripple } from 'primeng/ripple';
+import { DomHandler } from 'primeng/dom';
+import { Tabs } from './tabs';
+import { TabList } from './tablist';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/ripple";
+/**
+ * Defines valid properties in Tab component.
+ * @group Components
+ */
+export class Tab extends BaseComponent {
+    /**
+     * Value of tab.
+     * @defaultValue undefined
+     * @group Props
+     */
+    value = model();
+    /**
+     * Whether the tab is disabled.
+     * @defaultValue false
+     * @group Props
+     */
+    disabled = input(false, { transform: booleanAttribute });
+    pcTabs = inject(forwardRef(() => Tabs));
+    pcTabList = inject(forwardRef(() => TabList));
+    ripple = computed(() => this.config.ripple());
+    id = computed(() => `${this.pcTabs.id()}_tab_${this.value()}`);
+    ariaControls = computed(() => `${this.pcTabs.id()}_tabpanel_${this.value()}`);
+    active = computed(() => ObjectUtils.equals(this.pcTabs.value(), this.value()));
+    tabindex = computed(() => (this.active() ? this.pcTabs.tabindex() : -1));
+    onFocus(event) {
+        this.pcTabs.selectOnFocus() && this.changeActiveValue();
+    }
+    onClick(event) {
+        this.changeActiveValue();
+    }
+    onKeyDown(event) {
+        switch (event.code) {
+            case 'ArrowRight':
+                this.onArrowRightKey(event);
+                break;
+            case 'ArrowLeft':
+                this.onArrowLeftKey(event);
+                break;
+            case 'Home':
+                this.onHomeKey(event);
+                break;
+            case 'End':
+                this.onEndKey(event);
+                break;
+            case 'PageDown':
+                this.onPageDownKey(event);
+                break;
+            case 'PageUp':
+                this.onPageUpKey(event);
+                break;
+            case 'Enter':
+            case 'NumpadEnter':
+            case 'Space':
+                this.onEnterKey(event);
+                break;
+            default:
+                break;
+        }
+        event.stopPropagation();
+    }
+    onArrowRightKey(event) {
+        const nextTab = this.findNextTab(event.currentTarget);
+        nextTab ? this.changeFocusedTab(event, nextTab) : this.onHomeKey(event);
+        event.preventDefault();
+    }
+    onArrowLeftKey(event) {
+        const prevTab = this.findPrevTab(event.currentTarget);
+        prevTab ? this.changeFocusedTab(event, prevTab) : this.onEndKey(event);
+        event.preventDefault();
+    }
+    onHomeKey(event) {
+        const firstTab = this.findFirstTab();
+        this.changeFocusedTab(event, firstTab);
+        event.preventDefault();
+    }
+    onEndKey(event) {
+        const lastTab = this.findLastTab();
+        this.changeFocusedTab(event, lastTab);
+        event.preventDefault();
+    }
+    onPageDownKey(event) {
+        this.scrollInView(this.findLastTab());
+        event.preventDefault();
+    }
+    onPageUpKey(event) {
+        this.scrollInView(this.findFirstTab());
+        event.preventDefault();
+    }
+    onEnterKey(event) {
+        this.changeActiveValue();
+        event.preventDefault();
+    }
+    findNextTab(tabElement, selfCheck = false) {
+        const element = selfCheck ? tabElement : tabElement.nextElementSibling;
+        return element
+            ? DomHandler.getAttribute(element, 'data-p-disabled') || DomHandler.getAttribute(element, 'data-pc-section') === 'inkbar'
+                ? this.findNextTab(element)
+                : element
+            : null;
+    }
+    findPrevTab(tabElement, selfCheck = false) {
+        const element = selfCheck ? tabElement : tabElement.previousElementSibling;
+        return element
+            ? DomHandler.getAttribute(element, 'data-p-disabled') || DomHandler.getAttribute(element, 'data-pc-section') === 'inkbar'
+                ? this.findPrevTab(element)
+                : element
+            : null;
+    }
+    findFirstTab() {
+        return this.findNextTab(this.pcTabList?.tabs?.nativeElement?.firstElementChild, true);
+    }
+    findLastTab() {
+        return this.findPrevTab(this.pcTabList?.tabs?.nativeElement?.lastElementChild, true);
+    }
+    changeActiveValue() {
+        this.pcTabs.updateValue(this.value());
+    }
+    changeFocusedTab(event, element) {
+        DomHandler.focus(element);
+        this.scrollInView(element);
+    }
+    scrollInView(element) {
+        element?.scrollIntoView?.({ block: 'nearest' });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: Tab, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.2", type: Tab, isStandalone: true, selector: "p-tab", inputs: { value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { value: "valueChange" }, host: { listeners: { "focus": "onFocus($event)", "click": "onClick($event)", "keydown": "onKeyDown($event)" }, properties: { "class.p-tab": "true", "class.p-component": "true", "attr.data-pc-name": "\"tab\"", "attr.id": "id()", "attr.aria-controls": "ariaControls()", "attr.role": "\"tab\"", "attr.aria-selected": "active()", "attr.data-p-disabled": "disabled()", "attr.data-p-active": "active()", "attr.tabindex": "tabindex()" } }, usesInheritance: true, hostDirectives: [{ directive: i1.Ripple }], ngImport: i0, template: ` <ng-content></ng-content>`, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: Tab, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'p-tab',
+                    standalone: true,
+                    imports: [CommonModule, Ripple],
+                    template: ` <ng-content></ng-content>`,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                    host: {
+                        '[class.p-tab]': 'true',
+                        '[class.p-component]': 'true',
+                        '[attr.data-pc-name]': '"tab"',
+                        '[attr.id]': 'id()',
+                        '[attr.aria-controls]': 'ariaControls()',
+                        '[attr.role]': '"tab"',
+                        '[attr.aria-selected]': 'active()',
+                        '[attr.data-p-disabled]': 'disabled()',
+                        '[attr.data-p-active]': 'active()',
+                        '[attr.tabindex]': 'tabindex()',
+                    },
+                    hostDirectives: [Ripple],
+                }]
+        }], propDecorators: { onFocus: [{
+                type: HostListener,
+                args: ['focus', ['$event']]
+            }], onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }], onKeyDown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tab.js","sourceRoot":"","sources":["../../../src/app/components/tabs/tab.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport {\n    booleanAttribute,\n    ChangeDetectionStrategy,\n    Component,\n    computed,\n    forwardRef,\n    HostListener,\n    inject,\n    input,\n    model,\n    ViewEncapsulation,\n} from '@angular/core';\n\nimport { BaseComponent } from 'primeng/basecomponent';\nimport { ObjectUtils } from 'primeng/utils';\nimport { Ripple } from 'primeng/ripple';\nimport { DomHandler } from 'primeng/dom';\nimport { Tabs } from './tabs';\nimport { TabList } from './tablist';\n\n/**\n * Defines valid properties in Tab component.\n * @group Components\n */\n@Component({\n    selector: 'p-tab',\n    standalone: true,\n    imports: [CommonModule, Ripple],\n    template: ` <ng-content></ng-content>`,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    encapsulation: ViewEncapsulation.None,\n    host: {\n        '[class.p-tab]': 'true',\n        '[class.p-component]': 'true',\n        '[attr.data-pc-name]': '\"tab\"',\n        '[attr.id]': 'id()',\n        '[attr.aria-controls]': 'ariaControls()',\n        '[attr.role]': '\"tab\"',\n        '[attr.aria-selected]': 'active()',\n        '[attr.data-p-disabled]': 'disabled()',\n        '[attr.data-p-active]': 'active()',\n        '[attr.tabindex]': 'tabindex()',\n    },\n    hostDirectives: [Ripple],\n})\nexport class Tab extends BaseComponent {\n    /**\n     * Value of tab.\n     * @defaultValue undefined\n     * @group Props\n     */\n    value = model<number | string | undefined>();\n    /**\n     * Whether the tab is disabled.\n     * @defaultValue false\n     * @group Props\n     */\n    disabled = input(false, { transform: booleanAttribute });\n\n    pcTabs = inject(forwardRef(() => Tabs));\n\n    pcTabList = inject(forwardRef(() => TabList));\n\n    ripple = computed(() => this.config.ripple());\n\n    id = computed(() => `${this.pcTabs.id()}_tab_${this.value()}`);\n\n    ariaControls = computed(() => `${this.pcTabs.id()}_tabpanel_${this.value()}`);\n\n    active = computed(() => ObjectUtils.equals(this.pcTabs.value(), this.value()));\n\n    tabindex = computed(() => (this.active() ? this.pcTabs.tabindex() : -1));\n\n    @HostListener('focus', ['$event']) onFocus(event: FocusEvent) {\n        this.pcTabs.selectOnFocus() && this.changeActiveValue();\n    }\n\n    @HostListener('click', ['$event']) onClick(event: MouseEvent) {\n        this.changeActiveValue();\n    }\n\n    @HostListener('keydown', ['$event']) onKeyDown(event: KeyboardEvent) {\n        switch (event.code) {\n            case 'ArrowRight':\n                this.onArrowRightKey(event);\n                break;\n\n            case 'ArrowLeft':\n                this.onArrowLeftKey(event);\n                break;\n\n            case 'Home':\n                this.onHomeKey(event);\n                break;\n\n            case 'End':\n                this.onEndKey(event);\n                break;\n\n            case 'PageDown':\n                this.onPageDownKey(event);\n                break;\n\n            case 'PageUp':\n                this.onPageUpKey(event);\n                break;\n\n            case 'Enter':\n            case 'NumpadEnter':\n            case 'Space':\n                this.onEnterKey(event);\n                break;\n\n            default:\n                break;\n        }\n\n        event.stopPropagation();\n    }\n\n    onArrowRightKey(event) {\n        const nextTab = this.findNextTab(event.currentTarget);\n        nextTab ? this.changeFocusedTab(event, nextTab) : this.onHomeKey(event);\n        event.preventDefault();\n    }\n\n    onArrowLeftKey(event) {\n        const prevTab = this.findPrevTab(event.currentTarget);\n\n        prevTab ? this.changeFocusedTab(event, prevTab) : this.onEndKey(event);\n        event.preventDefault();\n    }\n\n    onHomeKey(event) {\n        const firstTab = this.findFirstTab();\n\n        this.changeFocusedTab(event, firstTab);\n        event.preventDefault();\n    }\n\n    onEndKey(event) {\n        const lastTab = this.findLastTab();\n\n        this.changeFocusedTab(event, lastTab);\n        event.preventDefault();\n    }\n\n    onPageDownKey(event) {\n        this.scrollInView(this.findLastTab());\n        event.preventDefault();\n    }\n\n    onPageUpKey(event) {\n        this.scrollInView(this.findFirstTab());\n        event.preventDefault();\n    }\n\n    onEnterKey(event) {\n        this.changeActiveValue();\n        event.preventDefault();\n    }\n\n    findNextTab(tabElement, selfCheck = false) {\n        const element = selfCheck ? tabElement : tabElement.nextElementSibling;\n\n        return element\n            ? DomHandler.getAttribute(element, 'data-p-disabled') || DomHandler.getAttribute(element, 'data-pc-section') === 'inkbar'\n                ? this.findNextTab(element)\n                : element\n            : null;\n    }\n\n    findPrevTab(tabElement, selfCheck = false) {\n        const element = selfCheck ? tabElement : tabElement.previousElementSibling;\n\n        return element\n            ? DomHandler.getAttribute(element, 'data-p-disabled') || DomHandler.getAttribute(element, 'data-pc-section') === 'inkbar'\n                ? this.findPrevTab(element)\n                : element\n            : null;\n    }\n\n    findFirstTab() {\n        return this.findNextTab(this.pcTabList?.tabs?.nativeElement?.firstElementChild, true);\n    }\n\n    findLastTab() {\n        return this.findPrevTab(this.pcTabList?.tabs?.nativeElement?.lastElementChild, true);\n    }\n\n    changeActiveValue() {\n        this.pcTabs.updateValue(this.value());\n    }\n\n    changeFocusedTab(event, element) {\n        DomHandler.focus(element);\n        this.scrollInView(element);\n    }\n\n    scrollInView(element) {\n        element?.scrollIntoView?.({ block: 'nearest' });\n    }\n}\n"]}

package/esm2022/tabs/tablist.mjs

@@ -0,0 +1,256 @@
+import { ChangeDetectionStrategy, Component, computed, ContentChild, ContentChildren, effect, forwardRef, inject, signal, ViewChild, ViewEncapsulation, } from '@angular/core';
+import { CommonModule, isPlatformBrowser } from '@angular/common';
+import { ChevronLeftIcon } from 'primeng/icons/chevronleft';
+import { ChevronRightIcon } from 'primeng/icons/chevronright';
+import { RippleModule } from 'primeng/ripple';
+import { BaseComponent } from 'primeng/basecomponent';
+import { Tabs } from './tabs';
+import { DomHandler } from 'primeng/dom';
+import { PrimeTemplate } from 'primeng/api';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "primeng/ripple";
+/**
+ * TabList is a helper component for Tabs component.
+ * @group Components
+ */
+export class TabList extends BaseComponent {
+    /**
+     * A template reference variable that represents the previous icon in a UI component.
+     * @type {TemplateRef<any> | undefined}
+     * @group Templates
+     */
+    prevIconTemplate;
+    /**
+     * A template reference variable that represents the next icon in a UI component.
+     * @type {TemplateRef<any> | undefined}
+     * @group Templates
+     */
+    nextIconTemplate;
+    content;
+    prevButton;
+    nextButton;
+    inkbar;
+    tabs;
+    templates;
+    pcTabs = inject(forwardRef(() => Tabs));
+    isPrevButtonEnabled = signal(false);
+    isNextButtonEnabled = signal(false);
+    resizeObserver;
+    showNavigators = computed(() => this.pcTabs.showNavigators());
+    tabindex = computed(() => this.pcTabs.tabindex());
+    scrollable = computed(() => this.pcTabs.scrollable());
+    get prevButtonAriaLabel() {
+        return this.config.translation.aria.previous;
+    }
+    get nextButtonAriaLabel() {
+        return this.config.translation.aria.next;
+    }
+    constructor() {
+        super();
+        effect(() => {
+            this.pcTabs.value();
+            if (isPlatformBrowser(this.platformId)) {
+                setTimeout(() => {
+                    this.updateInkBar();
+                });
+            }
+        });
+    }
+    ngAfterViewInit() {
+        super.ngAfterViewInit();
+        if (this.showNavigators() && isPlatformBrowser(this.platformId)) {
+            this.updateButtonState();
+            this.bindResizeObserver();
+        }
+    }
+    ngAfterContentInit() {
+        this.templates.forEach((t) => {
+            switch (t.getType()) {
+                case 'previcon':
+                    this.prevIconTemplate = t.template;
+                    break;
+                case 'nexticon':
+                    this.nextIconTemplate = t.template;
+                    break;
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.unbindResizeObserver();
+        super.ngOnDestroy();
+    }
+    onScroll(event) {
+        this.showNavigators() && this.updateButtonState();
+        event.preventDefault();
+    }
+    onPrevButtonClick() {
+        const _content = this.content.nativeElement;
+        const width = DomHandler.getWidth(_content);
+        const pos = _content.scrollLeft - width;
+        _content.scrollLeft = pos <= 0 ? 0 : pos;
+    }
+    onNextButtonClick() {
+        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;
+    }
+    updateButtonState() {
+        const _content = this.content?.nativeElement;
+        const _list = this.el?.nativeElement;
+        const { scrollLeft, scrollTop, scrollWidth, scrollHeight, offsetWidth, offsetHeight } = _content;
+        const [width, height] = [DomHandler.getWidth(_content), DomHandler.getHeight(_content)];
+        this.isPrevButtonEnabled.set(scrollLeft !== 0);
+        this.isNextButtonEnabled.set(_list.offsetWidth >= offsetWidth && scrollLeft !== scrollWidth - width);
+    }
+    updateInkBar() {
+        const _content = this.content.nativeElement;
+        const _inkbar = this.inkbar.nativeElement;
+        const _tabs = this.tabs.nativeElement;
+        const activeTab = DomHandler.findSingle(_content, '[data-pc-name="tab"][data-p-active="true"]');
+        _inkbar.style.width = DomHandler.getOuterWidth(activeTab) + 'px';
+        _inkbar.style.left = DomHandler.getOffset(activeTab).left - DomHandler.getOffset(_tabs).left + 'px';
+    }
+    getVisibleButtonWidths() {
+        const _prevBtn = this.prevButton?.nativeElement;
+        const _nextBtn = this.nextButton?.nativeElement;
+        return [_prevBtn, _nextBtn].reduce((acc, el) => (el ? acc + DomHandler.getWidth(el) : acc), 0);
+    }
+    bindResizeObserver() {
+        this.resizeObserver = new ResizeObserver(() => this.updateButtonState());
+        this.resizeObserver.observe(this.el.nativeElement);
+    }
+    unbindResizeObserver() {
+        if (this.resizeObserver) {
+            this.resizeObserver.unobserve(this.el.nativeElement);
+            this.resizeObserver = null;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: TabList, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.2", type: TabList, isStandalone: true, selector: "p-tablist", host: { properties: { "class.p-tablist": "true", "class.p-component": "true", "attr.data-pc-name": "\"tablist\"" } }, queries: [{ propertyName: "prevIconTemplate", first: true, predicate: ["previcon"], descendants: true }, { propertyName: "nextIconTemplate", first: true, predicate: ["nexticon"], descendants: true }, { propertyName: "templates", predicate: PrimeTemplate }], viewQueries: [{ propertyName: "content", first: true, predicate: ["content"], descendants: true }, { propertyName: "prevButton", first: true, predicate: ["prevButton"], descendants: true }, { propertyName: "nextButton", first: true, predicate: ["nextButton"], descendants: true }, { propertyName: "inkbar", first: true, predicate: ["inkbar"], descendants: true }, { propertyName: "tabs", first: true, predicate: ["tabs"], descendants: true }], usesInheritance: true, ngImport: i0, template: `
+        @if (showNavigators() && isPrevButtonEnabled()) {
+            <button
+                #prevButton
+                pRipple
+                class="p-tablist-nav-button p-tablist-prev-button"
+                [attr.aria-label]="prevButtonAriaLabel"
+                [attr.tabindex]="tabindex"
+                [attr.data-pc-group-section]="'navigator'"
+                (click)="onPrevButtonClick()"
+            >
+                @if (prevIconTemplate) {
+                    <ng-container *ngTemplateOutlet="prevIconTemplate"></ng-container>
+                } @else {
+                    <ChevronLeftIcon />
+                }
+            </button>
+        }
+        <div #content class="p-tablist-content" [ngClass]="{ 'p-tablist-viewport': scrollable() }" (scroll)="onScroll($event)">
+            <div #tabs class="p-tablist-tab-list" role="tablist">
+                <ng-content></ng-content>
+                <span #inkbar role="presentation" class="p-tablist-active-bar" [attr.data-pc-section]="'inkbar'"></span>
+            </div>
+        </div>
+        @if (showNavigators() && isNextButtonEnabled()) {
+            <button
+                #nextButton
+                pRipple
+                class="p-tablist-nav-button p-tablist-next-button"
+                [attr.aria-label]="nextButtonAriaLabel"
+                [attr.tabindex]="tabindex"
+                [attr.data-pc-group-section]="'navigator'"
+                (click)="onNextButtonClick()"
+            >
+                @if (nextIconTemplate) {
+                    <ng-container *ngTemplateOutlet="nextIconTemplate"></ng-container>
+                } @else {
+                    <ChevronRightIcon />
+                }
+            </button>
+        }
+    `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: ChevronLeftIcon, selector: "ChevronLeftIcon" }, { kind: "component", type: ChevronRightIcon, selector: "ChevronRightIcon" }, { kind: "ngmodule", type: RippleModule }, { kind: "directive", type: i2.Ripple, selector: "[pRipple]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: TabList, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'p-tablist',
+                    standalone: true,
+                    imports: [CommonModule, ChevronLeftIcon, ChevronRightIcon, RippleModule],
+                    template: `
+        @if (showNavigators() && isPrevButtonEnabled()) {
+            <button
+                #prevButton
+                pRipple
+                class="p-tablist-nav-button p-tablist-prev-button"
+                [attr.aria-label]="prevButtonAriaLabel"
+                [attr.tabindex]="tabindex"
+                [attr.data-pc-group-section]="'navigator'"
+                (click)="onPrevButtonClick()"
+            >
+                @if (prevIconTemplate) {
+                    <ng-container *ngTemplateOutlet="prevIconTemplate"></ng-container>
+                } @else {
+                    <ChevronLeftIcon />
+                }
+            </button>
+        }
+        <div #content class="p-tablist-content" [ngClass]="{ 'p-tablist-viewport': scrollable() }" (scroll)="onScroll($event)">
+            <div #tabs class="p-tablist-tab-list" role="tablist">
+                <ng-content></ng-content>
+                <span #inkbar role="presentation" class="p-tablist-active-bar" [attr.data-pc-section]="'inkbar'"></span>
+            </div>
+        </div>
+        @if (showNavigators() && isNextButtonEnabled()) {
+            <button
+                #nextButton
+                pRipple
+                class="p-tablist-nav-button p-tablist-next-button"
+                [attr.aria-label]="nextButtonAriaLabel"
+                [attr.tabindex]="tabindex"
+                [attr.data-pc-group-section]="'navigator'"
+                (click)="onNextButtonClick()"
+            >
+                @if (nextIconTemplate) {
+                    <ng-container *ngTemplateOutlet="nextIconTemplate"></ng-container>
+                } @else {
+                    <ChevronRightIcon />
+                }
+            </button>
+        }
+    `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                    host: {
+                        '[class.p-tablist]': 'true',
+                        '[class.p-component]': 'true',
+                        '[attr.data-pc-name]': '"tablist"',
+                    },
+                }]
+        }], ctorParameters: () => [], propDecorators: { prevIconTemplate: [{
+                type: ContentChild,
+                args: ['previcon']
+            }], nextIconTemplate: [{
+                type: ContentChild,
+                args: ['nexticon']
+            }], content: [{
+                type: ViewChild,
+                args: ['content']
+            }], prevButton: [{
+                type: ViewChild,
+                args: ['prevButton']
+            }], nextButton: [{
+                type: ViewChild,
+                args: ['nextButton']
+            }], inkbar: [{
+                type: ViewChild,
+                args: ['inkbar']
+            }], tabs: [{
+                type: ViewChild,
+                args: ['tabs']
+            }], templates: [{
+                type: ContentChildren,
+                args: [PrimeTemplate]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tablist.js","sourceRoot":"","sources":["../../../src/app/components/tabs/tablist.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterContentInit,\n    AfterViewInit,\n    ChangeDetectionStrategy,\n    Component,\n    computed,\n    ContentChild,\n    ContentChildren,\n    effect,\n    ElementRef,\n    forwardRef,\n    inject,\n    QueryList,\n    signal,\n    TemplateRef,\n    ViewChild,\n    ViewEncapsulation,\n} from '@angular/core';\nimport { CommonModule, isPlatformBrowser } from '@angular/common';\nimport { ChevronLeftIcon } from 'primeng/icons/chevronleft';\nimport { ChevronRightIcon } from 'primeng/icons/chevronright';\nimport { RippleModule } from 'primeng/ripple';\nimport { BaseComponent } from 'primeng/basecomponent';\nimport { Tabs } from './tabs';\nimport { DomHandler } from 'primeng/dom';\nimport { PrimeTemplate } from 'primeng/api';\n\n/**\n * TabList is a helper component for Tabs component.\n * @group Components\n */\n@Component({\n    selector: 'p-tablist',\n    standalone: true,\n    imports: [CommonModule, ChevronLeftIcon, ChevronRightIcon, RippleModule],\n    template: `\n        @if (showNavigators() && isPrevButtonEnabled()) {\n            <button\n                #prevButton\n                pRipple\n                class=\"p-tablist-nav-button p-tablist-prev-button\"\n                [attr.aria-label]=\"prevButtonAriaLabel\"\n                [attr.tabindex]=\"tabindex\"\n                [attr.data-pc-group-section]=\"'navigator'\"\n                (click)=\"onPrevButtonClick()\"\n            >\n                @if (prevIconTemplate) {\n                    <ng-container *ngTemplateOutlet=\"prevIconTemplate\"></ng-container>\n                } @else {\n                    <ChevronLeftIcon />\n                }\n            </button>\n        }\n        <div #content class=\"p-tablist-content\" [ngClass]=\"{ 'p-tablist-viewport': scrollable() }\" (scroll)=\"onScroll($event)\">\n            <div #tabs class=\"p-tablist-tab-list\" role=\"tablist\">\n                <ng-content></ng-content>\n                <span #inkbar role=\"presentation\" class=\"p-tablist-active-bar\" [attr.data-pc-section]=\"'inkbar'\"></span>\n            </div>\n        </div>\n        @if (showNavigators() && isNextButtonEnabled()) {\n            <button\n                #nextButton\n                pRipple\n                class=\"p-tablist-nav-button p-tablist-next-button\"\n                [attr.aria-label]=\"nextButtonAriaLabel\"\n                [attr.tabindex]=\"tabindex\"\n                [attr.data-pc-group-section]=\"'navigator'\"\n                (click)=\"onNextButtonClick()\"\n            >\n                @if (nextIconTemplate) {\n                    <ng-container *ngTemplateOutlet=\"nextIconTemplate\"></ng-container>\n                } @else {\n                    <ChevronRightIcon />\n                }\n            </button>\n        }\n    `,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    encapsulation: ViewEncapsulation.None,\n    host: {\n        '[class.p-tablist]': 'true',\n        '[class.p-component]': 'true',\n        '[attr.data-pc-name]': '\"tablist\"',\n    },\n})\nexport class TabList extends BaseComponent implements AfterViewInit, AfterContentInit {\n    /**\n     * A template reference variable that represents the previous icon in a UI component.\n     * @type {TemplateRef<any> | undefined}\n     * @group Templates\n     */\n    @ContentChild('previcon') prevIconTemplate: TemplateRef<any> | undefined;\n    /**\n     * A template reference variable that represents the next icon in a UI component.\n     * @type {TemplateRef<any> | undefined}\n     * @group Templates\n     */\n    @ContentChild('nexticon') nextIconTemplate: TemplateRef<any> | undefined;\n\n    @ViewChild('content') content: ElementRef<HTMLDivElement>;\n\n    @ViewChild('prevButton') prevButton: ElementRef<HTMLButtonElement>;\n\n    @ViewChild('nextButton') nextButton: ElementRef<HTMLButtonElement>;\n\n    @ViewChild('inkbar') inkbar: ElementRef<HTMLSpanElement>;\n\n    @ViewChild('tabs') tabs: ElementRef<HTMLDivElement>;\n\n    @ContentChildren(PrimeTemplate) templates: QueryList<PrimeTemplate>;\n\n    pcTabs = inject(forwardRef(() => Tabs));\n\n    isPrevButtonEnabled = signal<boolean>(false);\n\n    isNextButtonEnabled = signal<boolean>(false);\n\n    resizeObserver!: ResizeObserver;\n\n    showNavigators = computed(() => this.pcTabs.showNavigators());\n\n    tabindex = computed(() => this.pcTabs.tabindex());\n\n    scrollable = computed(() => this.pcTabs.scrollable());\n\n    get prevButtonAriaLabel() {\n        return this.config.translation.aria.previous;\n    }\n\n    get nextButtonAriaLabel() {\n        return this.config.translation.aria.next;\n    }\n\n    constructor() {\n        super();\n        effect(() => {\n            this.pcTabs.value();\n            if (isPlatformBrowser(this.platformId)) {\n                setTimeout(() => {\n                    this.updateInkBar();\n                });\n            }\n        });\n    }\n\n    ngAfterViewInit() {\n        super.ngAfterViewInit();\n        if (this.showNavigators() && isPlatformBrowser(this.platformId)) {\n            this.updateButtonState();\n            this.bindResizeObserver();\n        }\n    }\n\n    ngAfterContentInit() {\n        this.templates.forEach((t) => {\n            switch (t.getType()) {\n                case 'previcon':\n                    this.prevIconTemplate = t.template;\n                    break;\n                case 'nexticon':\n                    this.nextIconTemplate = t.template;\n                    break;\n            }\n        });\n    }\n\n    ngOnDestroy() {\n        this.unbindResizeObserver();\n        super.ngOnDestroy();\n    }\n\n    onScroll(event) {\n        this.showNavigators() && this.updateButtonState();\n\n        event.preventDefault();\n    }\n\n    onPrevButtonClick() {\n        const _content = this.content.nativeElement;\n        const width = DomHandler.getWidth(_content);\n\n        const pos = _content.scrollLeft - width;\n\n        _content.scrollLeft = pos <= 0 ? 0 : pos;\n    }\n\n    onNextButtonClick() {\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\n        _content.scrollLeft = pos >= lastPos ? lastPos : pos;\n    }\n\n    updateButtonState() {\n        const _content = this.content?.nativeElement;\n        const _list = this.el?.nativeElement;\n\n        const { scrollLeft, scrollTop, scrollWidth, scrollHeight, offsetWidth, offsetHeight } = _content;\n        const [width, height] = [DomHandler.getWidth(_content), DomHandler.getHeight(_content)];\n\n        this.isPrevButtonEnabled.set(scrollLeft !== 0);\n        this.isNextButtonEnabled.set(_list.offsetWidth >= offsetWidth && scrollLeft !== scrollWidth - width);\n    }\n\n    updateInkBar() {\n        const _content = this.content.nativeElement;\n        const _inkbar = this.inkbar.nativeElement;\n        const _tabs = this.tabs.nativeElement;\n\n        const activeTab = DomHandler.findSingle(_content, '[data-pc-name=\"tab\"][data-p-active=\"true\"]');\n\n        _inkbar.style.width = DomHandler.getOuterWidth(activeTab) + 'px';\n        _inkbar.style.left = DomHandler.getOffset(activeTab).left - DomHandler.getOffset(_tabs).left + 'px';\n    }\n\n    getVisibleButtonWidths() {\n        const _prevBtn = this.prevButton?.nativeElement;\n        const _nextBtn = this.nextButton?.nativeElement;\n\n        return [_prevBtn, _nextBtn].reduce((acc, el) => (el ? acc + DomHandler.getWidth(el) : acc), 0);\n    }\n\n    bindResizeObserver() {\n        this.resizeObserver = new ResizeObserver(() => this.updateButtonState());\n        this.resizeObserver.observe(this.el.nativeElement);\n    }\n\n    unbindResizeObserver() {\n        if (this.resizeObserver) {\n            this.resizeObserver.unobserve(this.el.nativeElement);\n            this.resizeObserver = null;\n        }\n    }\n}\n"]}

package/esm2022/tabs/tabpanel.mjs

@@ -0,0 +1,49 @@
+import { ChangeDetectionStrategy, Component, computed, forwardRef, inject, model, ViewEncapsulation } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { BaseComponent } from 'primeng/basecomponent';
+import { ObjectUtils } from 'primeng/utils';
+import { Tabs } from './tabs';
+import * as i0 from "@angular/core";
+/**
+ * TabPanel is a helper component for Tabs component.
+ * @group Components
+ */
+export class TabPanel extends BaseComponent {
+    pcTabs = inject(forwardRef(() => Tabs));
+    /**
+     * Value of the active tab.
+     * @defaultValue undefined
+     * @group Props
+     */
+    value = model(undefined);
+    id = computed(() => `${this.pcTabs.id()}_tabpanel_${this.value()}`);
+    ariaLabelledby = computed(() => `${this.pcTabs.id()}_tab_${this.value()}`);
+    active = computed(() => ObjectUtils.equals(this.pcTabs.value(), this.value()));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: TabPanel, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.2", type: TabPanel, isStandalone: true, selector: "p-tabpanel", inputs: { value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { value: "valueChange" }, host: { properties: { "class.p-tabpanel": "true", "class.p-component": "true", "attr.data-pc-name": "\"tabpanel\"", "attr.id": "id()", "attr.role": "\"tabpanel\"", "attr.aria-labelledby": "ariaLabelledby()", "attr.data-p-active": "active()" } }, usesInheritance: true, ngImport: i0, template: `@if (active()) {
+        <ng-content></ng-content>
+    }`, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: TabPanel, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'p-tabpanel',
+                    standalone: true,
+                    imports: [CommonModule],
+                    template: `@if (active()) {
+        <ng-content></ng-content>
+    }`,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                    host: {
+                        '[class.p-tabpanel]': 'true',
+                        '[class.p-component]': 'true',
+                        '[attr.data-pc-name]': '"tabpanel"',
+                        '[attr.id]': 'id()',
+                        '[attr.role]': '"tabpanel"',
+                        '[attr.aria-labelledby]': 'ariaLabelledby()',
+                        '[attr.data-p-active]': 'active()',
+                    },
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/tabs/tabpanels.mjs

@@ -0,0 +1,30 @@
+import { ChangeDetectionStrategy, Component, ViewEncapsulation } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { BaseComponent } from 'primeng/basecomponent';
+import * as i0 from "@angular/core";
+/**
+ * TabPanels is a helper component for Tabs component.
+ * @group Components
+ */
+export class TabPanels extends BaseComponent {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: TabPanels, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.2", type: TabPanels, isStandalone: true, selector: "p-tabpanels", host: { properties: { "class.p-tabpanels": "true", "class.p-component": "true", "attr.data-pc-name": "\"tabpanels\"", "attr.role": "\"presentation\"" } }, usesInheritance: true, ngImport: i0, template: ` <ng-content></ng-content>`, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: TabPanels, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'p-tabpanels',
+                    standalone: true,
+                    imports: [CommonModule],
+                    template: ` <ng-content></ng-content>`,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                    host: {
+                        '[class.p-tabpanels]': 'true',
+                        '[class.p-component]': 'true',
+                        '[attr.data-pc-name]': '"tabpanels"',
+                        '[attr.role]': '"presentation"',
+                    },
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFicGFuZWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FwcC9jb21wb25lbnRzL3RhYnMvdGFicGFuZWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxTQUFTLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDdEYsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQzs7QUFFdEQ7OztHQUdHO0FBZUgsTUFBTSxPQUFPLFNBQVUsU0FBUSxhQUFhO3VHQUEvQixTQUFTOzJGQUFULFNBQVMseVBBVlIsNEJBQTRCLDJEQUQ1QixZQUFZOzsyRkFXYixTQUFTO2tCQWRyQixTQUFTO21CQUFDO29CQUNQLFFBQVEsRUFBRSxhQUFhO29CQUN2QixVQUFVLEVBQUUsSUFBSTtvQkFDaEIsT0FBTyxFQUFFLENBQUMsWUFBWSxDQUFDO29CQUN2QixRQUFRLEVBQUUsNEJBQTRCO29CQUN0QyxlQUFlLEVBQUUsdUJBQXVCLENBQUMsTUFBTTtvQkFDL0MsYUFBYSxFQUFFLGlCQUFpQixDQUFDLElBQUk7b0JBQ3JDLElBQUksRUFBRTt3QkFDRixxQkFBcUIsRUFBRSxNQUFNO3dCQUM3QixxQkFBcUIsRUFBRSxNQUFNO3dCQUM3QixxQkFBcUIsRUFBRSxhQUFhO3dCQUNwQyxhQUFhLEVBQUUsZ0JBQWdCO3FCQUNsQztpQkFDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENoYW5nZURldGVjdGlvblN0cmF0ZWd5LCBDb21wb25lbnQsIFZpZXdFbmNhcHN1bGF0aW9uIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgQmFzZUNvbXBvbmVudCB9IGZyb20gJ3ByaW1lbmcvYmFzZWNvbXBvbmVudCc7XG5cbi8qKlxuICogVGFiUGFuZWxzIGlzIGEgaGVscGVyIGNvbXBvbmVudCBmb3IgVGFicyBjb21wb25lbnQuXG4gKiBAZ3JvdXAgQ29tcG9uZW50c1xuICovXG5AQ29tcG9uZW50KHtcbiAgICBzZWxlY3RvcjogJ3AtdGFicGFuZWxzJyxcbiAgICBzdGFuZGFsb25lOiB0cnVlLFxuICAgIGltcG9ydHM6IFtDb21tb25Nb2R1bGVdLFxuICAgIHRlbXBsYXRlOiBgIDxuZy1jb250ZW50PjwvbmctY29udGVudD5gLFxuICAgIGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoLFxuICAgIGVuY2Fwc3VsYXRpb246IFZpZXdFbmNhcHN1bGF0aW9uLk5vbmUsXG4gICAgaG9zdDoge1xuICAgICAgICAnW2NsYXNzLnAtdGFicGFuZWxzXSc6ICd0cnVlJyxcbiAgICAgICAgJ1tjbGFzcy5wLWNvbXBvbmVudF0nOiAndHJ1ZScsXG4gICAgICAgICdbYXR0ci5kYXRhLXBjLW5hbWVdJzogJ1widGFicGFuZWxzXCInLFxuICAgICAgICAnW2F0dHIucm9sZV0nOiAnXCJwcmVzZW50YXRpb25cIicsXG4gICAgfSxcbn0pXG5leHBvcnQgY2xhc3MgVGFiUGFuZWxzIGV4dGVuZHMgQmFzZUNvbXBvbmVudCB7fVxuIl19