@ngrdt/tabs 0.0.1 → 0.0.2

package/esm2022/index.mjs

@@ -0,0 +1,9 @@
+export * from './lib/components/tab-container/rdt-tab-container.component';
+export * from './lib/components/tab/rdt-tab.component';
+export * from './lib/directives/rdt-destroy-inactive.directive';
+export * from './lib/directives/rdt-tab-controller.directive';
+export * from './lib/rdt-tabs-models';
+export * from './lib/rdt-tabs.module';
+export * from './lib/strategies/rdt-tabs-shortcut-strategy';
+export * from './lib/strategies/static-rdt-tabs-shortcut-strategy';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9AbmdyZHQvdGFicy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw0REFBNEQsQ0FBQztBQUMzRSxjQUFjLHdDQUF3QyxDQUFDO0FBQ3ZELGNBQWMsaURBQWlELENBQUM7QUFDaEUsY0FBYywrQ0FBK0MsQ0FBQztBQUM5RCxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyw2Q0FBNkMsQ0FBQztBQUM1RCxjQUFjLG9EQUFvRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy90YWItY29udGFpbmVyL3JkdC10YWItY29udGFpbmVyLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL3RhYi9yZHQtdGFiLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9kaXJlY3RpdmVzL3JkdC1kZXN0cm95LWluYWN0aXZlLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9kaXJlY3RpdmVzL3JkdC10YWItY29udHJvbGxlci5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvcmR0LXRhYnMtbW9kZWxzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3JkdC10YWJzLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zdHJhdGVnaWVzL3JkdC10YWJzLXNob3J0Y3V0LXN0cmF0ZWd5JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3N0cmF0ZWdpZXMvc3RhdGljLXJkdC10YWJzLXNob3J0Y3V0LXN0cmF0ZWd5JztcbiJdfQ==

package/esm2022/lib/components/tab/rdt-tab.component.mjs

@@ -0,0 +1,145 @@
+import { booleanAttribute, ChangeDetectionStrategy, Component, ContentChild, DestroyRef, inject, Injector, Input, TemplateRef, ViewChild, } from '@angular/core';
+import { RDT_GUARDED_COMPONENT, RdtContainerDirective, } from '@ngrdt/core';
+import { RdtDestroyInactiveDirective } from '../../directives/rdt-destroy-inactive.directive';
+import { RdtTabContainerComponent } from '../tab-container/rdt-tab-container.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrdt/core";
+export class RdtTabComponent {
+    injector = inject(Injector);
+    destroyRef = inject(DestroyRef);
+    _contDir;
+    get contDir() {
+        return this._contDir;
+    }
+    get stateId() {
+        if (this._stateId === null) {
+            if (this.label !== '') {
+                this._stateId = this.label;
+            }
+            else {
+                const index = this.tabContainer?.tabsList?.toArray().indexOf(this);
+                this._stateId = `tab-${index}`;
+            }
+        }
+        return this._stateId;
+    }
+    set stateId(value) {
+        this._stateId = value;
+    }
+    _stateId = null;
+    disabled = false;
+    visible = true;
+    label;
+    formAutofocus = true;
+    buttonClass = null;
+    implicitContent;
+    explicitContent;
+    get templateRef() {
+        return this.explicitContent ?? this.implicitContent;
+    }
+    tabContainer = inject(RdtTabContainerComponent);
+    //get forms() {
+    //  return this.getChildrenByClass(RdtBaseFormComponent);
+    //}
+    get childContainers() {
+        return this.contDir.getChildrenByClass(RdtTabContainerComponent);
+    }
+    rdtIsActive() {
+        return (this.visible && !this.disabled && this.tabContainer.activeTab === this);
+    }
+    ngOnInit() {
+        this._contDir = this.injector.get(RdtContainerDirective);
+    }
+    ngOnChanges(changes) {
+        if ('label' in changes ||
+            'value' in changes ||
+            'visible' in changes ||
+            'stateId' in changes) {
+            this.tabContainer.cd.markForCheck();
+        }
+    }
+    get isTopLevel() {
+        return this.tabContainer.isTopLevel;
+    }
+    getState() {
+        return {
+            id: this.stateId,
+            containerStates: this.childContainers.map((cont) => cont.getState()),
+        };
+    }
+    applyState(state) {
+        const states = [...state.containerStates];
+        const conts = this.childContainers;
+        const minLen = Math.min(states.length, conts.length);
+        for (let i = 0; i < minLen; i++) {
+            if (conts[i].stateId === states[i].id) {
+                conts[i].applyState(states[i]);
+                conts[i] = states[i] = null;
+            }
+        }
+        conts.forEach((cont, contI) => {
+            if (!cont) {
+                return;
+            }
+            for (let offset = 0; offset < states.length; offset++) {
+                const prev = contI - offset;
+                const next = contI + offset;
+                if (prev > 0 && states[prev]?.id === cont.stateId) {
+                    cont.applyState(states[prev]);
+                    states[prev] = null;
+                    return;
+                }
+                else if (next < states.length && states[next]?.id === cont.stateId) {
+                    cont.applyState(states[next]);
+                    states[next] = null;
+                    return;
+                }
+            }
+        });
+    }
+    focusForm() {
+        //TODO: getRdtAutofocusable(this.forms)?.rdtFocus();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: RdtTabComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "16.1.0", version: "18.2.7", type: RdtTabComponent, selector: "rdt-tab", inputs: { stateId: "stateId", disabled: ["disabled", "disabled", booleanAttribute], visible: ["visible", "visible", booleanAttribute], label: "label", formAutofocus: ["formAutofocus", "formAutofocus", booleanAttribute], buttonClass: "buttonClass" }, providers: [
+            {
+                provide: RDT_GUARDED_COMPONENT,
+                useExisting: RdtTabComponent,
+            },
+        ], queries: [{ propertyName: "explicitContent", first: true, predicate: RdtDestroyInactiveDirective, descendants: true, read: TemplateRef, static: true }], viewQueries: [{ propertyName: "implicitContent", first: true, predicate: TemplateRef, descendants: true, static: true }], usesOnChanges: true, hostDirectives: [{ directive: i1.RdtContainerDirective }], ngImport: i0, template: "<ng-template>\n  <ng-content></ng-content>\n</ng-template>\n", changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: RdtTabComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'rdt-tab', changeDetection: ChangeDetectionStrategy.OnPush, providers: [
+                        {
+                            provide: RDT_GUARDED_COMPONENT,
+                            useExisting: RdtTabComponent,
+                        },
+                    ], hostDirectives: [RdtContainerDirective], template: "<ng-template>\n  <ng-content></ng-content>\n</ng-template>\n" }]
+        }], propDecorators: { stateId: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], visible: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], label: [{
+                type: Input,
+                args: [{ required: true }]
+            }], formAutofocus: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], buttonClass: [{
+                type: Input
+            }], implicitContent: [{
+                type: ViewChild,
+                args: [TemplateRef, { static: true }]
+            }], explicitContent: [{
+                type: ContentChild,
+                args: [RdtDestroyInactiveDirective, {
+                        read: TemplateRef,
+                        static: true,
+                    }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rdt-tab.component.js","sourceRoot":"","sources":["../../../../../../../@ngrdt/tabs/src/lib/components/tab/rdt-tab.component.ts","../../../../../../../@ngrdt/tabs/src/lib/components/tab/rdt-tab.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  booleanAttribute,\n  ChangeDetectionStrategy,\n  Component,\n  ContentChild,\n  DestroyRef,\n  inject,\n  Injector,\n  Input,\n  OnChanges,\n  OnInit,\n  SimpleChanges,\n  TemplateRef,\n  ViewChild,\n} from '@angular/core';\nimport {\n  RDT_GUARDED_COMPONENT,\n  RdtContainerDirective,\n  RdtIsActive,\n} from '@ngrdt/core';\nimport { Nullable } from '@ngrdt/utils';\nimport { RdtDestroyInactiveDirective } from '../../directives/rdt-destroy-inactive.directive';\nimport { RdtTabContainerState, RdtTabState } from '../../rdt-tabs-models';\nimport { RdtTabContainerComponent } from '../tab-container/rdt-tab-container.component';\n\n@Component({\n  selector: 'rdt-tab',\n  templateUrl: './rdt-tab.component.html',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  providers: [\n    {\n      provide: RDT_GUARDED_COMPONENT,\n      useExisting: RdtTabComponent,\n    },\n  ],\n  hostDirectives: [RdtContainerDirective],\n})\nexport class RdtTabComponent implements OnChanges, OnInit, RdtIsActive {\n  private readonly injector = inject(Injector);\n  readonly destroyRef = inject(DestroyRef);\n\n  private _contDir!: RdtContainerDirective;\n  get contDir() {\n    return this._contDir;\n  }\n\n  @Input()\n  get stateId() {\n    if (this._stateId === null) {\n      if (this.label !== '') {\n        this._stateId = this.label;\n      } else {\n        const index = this.tabContainer?.tabsList?.toArray().indexOf(this);\n        this._stateId = `tab-${index}`;\n      }\n    }\n    return this._stateId;\n  }\n  set stateId(value: string) {\n    this._stateId = value;\n  }\n  private _stateId: string = null as unknown as string;\n\n  @Input({ transform: booleanAttribute })\n  disabled = false;\n\n  @Input({ transform: booleanAttribute })\n  visible = true;\n\n  @Input({ required: true })\n  label!: string;\n\n  @Input({ transform: booleanAttribute })\n  formAutofocus = true;\n\n  @Input()\n  buttonClass: Nullable<string> = null;\n\n  @ViewChild(TemplateRef, { static: true })\n  private readonly implicitContent!: TemplateRef<any>;\n\n  @ContentChild(RdtDestroyInactiveDirective, {\n    read: TemplateRef,\n    static: true,\n  })\n  private readonly explicitContent!: TemplateRef<any>;\n\n  get templateRef() {\n    return this.explicitContent ?? this.implicitContent;\n  }\n\n  readonly tabContainer = inject(RdtTabContainerComponent);\n\n  //get forms() {\n  //  return this.getChildrenByClass(RdtBaseFormComponent);\n  //}\n\n  get childContainers() {\n    return this.contDir.getChildrenByClass(RdtTabContainerComponent);\n  }\n\n  rdtIsActive(): boolean {\n    return (\n      this.visible && !this.disabled && this.tabContainer.activeTab === this\n    );\n  }\n\n  ngOnInit() {\n    this._contDir = this.injector.get(RdtContainerDirective);\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (\n      'label' in changes ||\n      'value' in changes ||\n      'visible' in changes ||\n      'stateId' in changes\n    ) {\n      this.tabContainer.cd.markForCheck();\n    }\n  }\n\n  get isTopLevel() {\n    return this.tabContainer.isTopLevel;\n  }\n\n  getState(): RdtTabState {\n    return {\n      id: this.stateId,\n      containerStates: this.childContainers.map((cont) => cont.getState()),\n    };\n  }\n\n  applyState(state: RdtTabState) {\n    const states: (RdtTabContainerState | null)[] = [...state.containerStates];\n    const conts: (RdtTabContainerComponent | null)[] = this.childContainers;\n    const minLen = Math.min(states.length, conts.length);\n\n    for (let i = 0; i < minLen; i++) {\n      if (conts[i]!.stateId === states[i]!.id) {\n        conts[i]!.applyState(states[i]!);\n        conts[i] = states[i] = null;\n      }\n    }\n    conts.forEach((cont, contI) => {\n      if (!cont) {\n        return;\n      }\n      for (let offset = 0; offset < states.length; offset++) {\n        const prev = contI - offset;\n        const next = contI + offset;\n        if (prev > 0 && states[prev]?.id === cont.stateId) {\n          cont.applyState(states[prev]!);\n          states[prev] = null;\n          return;\n        } else if (next < states.length && states[next]?.id === cont.stateId) {\n          cont.applyState(states[next]!);\n          states[next] = null;\n          return;\n        }\n      }\n    });\n  }\n\n  focusForm() {\n    //TODO: getRdtAutofocusable(this.forms)?.rdtFocus();\n  }\n}\n","<ng-template>\n  <ng-content></ng-content>\n</ng-template>\n"]}

package/esm2022/lib/components/tab-container/rdt-tab-container.component.mjs

@@ -0,0 +1,270 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChildren, DestroyRef, ElementRef, EventEmitter, HostBinding, HostListener, inject, Input, Output, QueryList, Renderer2, ViewChild, ViewChildren, ViewEncapsulation, } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { canTransition$, RDT_GUARDED_COMPONENT, RdtChildDirective, } from '@ngrdt/core';
+import { RdtHTMLUtils } from '@ngrdt/utils';
+import { firstValueFrom, timer } from 'rxjs';
+import { RdtTabControllerDirective } from '../../directives/rdt-tab-controller.directive';
+import { RdtTabComponent } from '../tab/rdt-tab.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrdt/core";
+import * as i2 from "@angular/common";
+export class RdtTabContainerComponent {
+    destroyRef = inject(DestroyRef);
+    stateId = null;
+    set value(val) {
+        if (this.activeTab && this.activeTab.stateId !== val) {
+            // TODO
+            //this.activeTab.onViewWillLeave();
+        }
+        this._value = val;
+        this.setCurrent();
+    }
+    get value() {
+        return this._value;
+    }
+    _value;
+    disabled = false;
+    formAutofocus = true;
+    panelPosition = 'top';
+    valueChange = new EventEmitter();
+    tabsList;
+    tabHeaderButtons;
+    tabContent;
+    _active = false;
+    get active() {
+        return this._active;
+    }
+    set active(value) {
+        this._active = value;
+        this.cd.markForCheck();
+    }
+    get isTopLevel() {
+        return !this.parentTab;
+    }
+    parentTab = inject(RdtTabComponent, { optional: true });
+    controller = inject(RdtTabControllerDirective, {
+        optional: true,
+    });
+    cd = inject(ChangeDetectorRef);
+    elRef = inject(ElementRef);
+    renderer = inject(Renderer2);
+    currentTemplate = null;
+    currentTab = null;
+    get classes() {
+        return `dp3-tab-container panel-${this.panelPosition}`;
+    }
+    get isHorizontal() {
+        return this.panelPosition === 'top' || this.panelPosition === 'bottom';
+    }
+    get isVertical() {
+        return !this.isHorizontal;
+    }
+    attrRole = 'tablist';
+    get hasNonDisabledTabs() {
+        return this.tabsList.some((tab) => !tab.disabled);
+    }
+    get activeTab() {
+        return this.getTabByValue(this.value);
+    }
+    getTabByValue(value) {
+        return this.tabsList?.find((tab) => tab.stateId === value);
+    }
+    ngAfterContentInit() {
+        this.controller?.onTabContainerChanges();
+        timer(0)
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe(() => this.setCurrent());
+        this.tabsList.changes
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe(() => {
+            this.controller?.onTabChanges();
+            this.setCurrent();
+            this.cd.markForCheck();
+        });
+        if (this.stateId === null && this.controller) {
+            const id = this.controller.getTabContainerIndex(this);
+            this.stateId = `tab-container-${id}`;
+        }
+    }
+    getState() {
+        return {
+            id: this.stateId,
+            value: this.value,
+            tabStates: this.tabsList.map((tab) => tab.getState()),
+        };
+    }
+    applyState(state) {
+        this.value = state.value;
+        this.scrollCurrentButtonIntoView();
+        const states = [...state.tabStates];
+        const tabs = this.tabsList.toArray();
+        const minLen = Math.min(states.length, tabs.length);
+        for (let i = 0; i < minLen; i++) {
+            if (tabs[i].stateId === states[i].id) {
+                tabs[i].applyState(states[i]);
+                tabs[i] = states[i] = null;
+            }
+        }
+        tabs.forEach((tab, tabI) => {
+            if (!tab) {
+                return;
+            }
+            for (let offset = 0; offset < states.length; offset++) {
+                const prev = tabI - offset;
+                const next = tabI + offset;
+                if (prev > 0 && states[prev]?.id === tab.stateId) {
+                    tab.applyState(states[prev]);
+                    states[prev] = null;
+                    return;
+                }
+                else if (next < states.length && states[next]?.id === tab.stateId) {
+                    tab.applyState(states[next]);
+                    states[next] = null;
+                    return;
+                }
+            }
+        });
+    }
+    scrollIntoView() {
+        this.elRef?.nativeElement?.scrollIntoView({ behavior: 'smooth' });
+    }
+    async activateTab(value) {
+        const nextTab = this.getTabByValue(value);
+        const can = await firstValueFrom(canTransition$(this.activeTab?.contDir, nextTab?.contDir));
+        if (can) {
+            this.value = value;
+            this.valueChange.emit(value);
+        }
+    }
+    scrollCurrentButtonIntoView() {
+        if (!this.tabsList || !this.tabHeaderButtons) {
+            return;
+        }
+        const tabIndex = this.tabsList
+            .toArray()
+            .findIndex((tab) => tab.stateId === this.value);
+        const buttonRef = this.tabHeaderButtons.get(tabIndex);
+        if (buttonRef) {
+            RdtHTMLUtils.scrollIntoViewHorizontallyWithinParent(buttonRef.nativeElement);
+        }
+    }
+    onClick(event) {
+        this.controller?.activateTabContainerFromClick(this, event.timeStamp);
+    }
+    setCurrent() {
+        if (!this.tabsList) {
+            return;
+        }
+        if (this.value == undefined) {
+            const firstEnabled = this.getFirstEnabledTab();
+            if (firstEnabled) {
+                this.value = firstEnabled.stateId;
+            }
+            else {
+                return;
+            }
+        }
+        const found = this.tabsList.find((tab) => tab.stateId === this.value);
+        if (!found) {
+            const first = this.getFirstEnabledTab();
+            if (first) {
+                this.activateTab(first.stateId);
+                return;
+            }
+            else {
+                console.error('Active tab not found.', this.tabsList.toArray(), this.value);
+                return;
+            }
+        }
+        this.setTab(found);
+    }
+    setTab(tab) {
+        if (this.currentTab !== tab) {
+            this.solidifyTabContentSize();
+            this.currentTab = tab;
+            this.currentTemplate = tab.templateRef;
+            this.cd.markForCheck();
+            //tab.onViewWillEnter();
+        }
+        if (this.formAutofocus && tab.formAutofocus) {
+            // Wait until template is attached to DOM
+            timer(0)
+                .pipe(takeUntilDestroyed(this.destroyRef), takeUntilDestroyed(tab.destroyRef))
+                .subscribe(() => tab.focusForm());
+        }
+        setTimeout(() => this.releaseTabContentSize());
+    }
+    // Swapping template in template outlet will cause large css recalc
+    // fix size to previous tab and in case they are the same size
+    // the recalc isn't noticable
+    solidifyTabContentSize() {
+        const el = this.tabContent.nativeElement;
+        const bb = el.getBoundingClientRect();
+        this.renderer.setStyle(el, 'width', bb.width + 'px');
+        this.renderer.setStyle(el, 'height', bb.height + 'px');
+    }
+    releaseTabContentSize() {
+        const el = this.tabContent.nativeElement;
+        this.renderer.removeStyle(el, 'width');
+        this.renderer.removeStyle(el, 'height');
+    }
+    getFirstEnabledTab() {
+        return this.tabsList.find((t) => !t.disabled);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: RdtTabContainerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.7", type: RdtTabContainerComponent, selector: "rdt-tab-container", inputs: { stateId: "stateId", value: "value", disabled: "disabled", formAutofocus: "formAutofocus", panelPosition: "panelPosition" }, outputs: { valueChange: "valueChange" }, host: { listeners: { "click": "onClick($event)" }, properties: { "class.active": "this._active", "class": "this.classes", "class.panel-horizontal": "this.isHorizontal", "class.panel-vertical": "this.isVertical", "attr.role": "this.attrRole" } }, providers: [
+            {
+                provide: RDT_GUARDED_COMPONENT,
+                useExisting: RdtTabContainerComponent,
+            },
+        ], queries: [{ propertyName: "tabsList", predicate: RdtTabComponent }], viewQueries: [{ propertyName: "tabContent", first: true, predicate: ["tabContent"], descendants: true, static: true }, { propertyName: "tabHeaderButtons", predicate: ["headerButton"], descendants: true }], hostDirectives: [{ directive: i1.RdtChildDirective }], ngImport: i0, template: "<div class=\"tab-header-panel\" *ngIf=\"tabsList\">\n  <button\n    *ngFor=\"let tab of tabsList\"\n    #headerButton\n    class=\"px-2 py-1 tab-header-button\"\n    (click)=\"activateTab(tab.stateId)\"\n    [class.active]=\"value === tab.stateId\"\n    [disabled]=\"tab.disabled\"\n    [hidden]=\"!tab.visible\"\n    role=\"tab\"\n    [attr.aria-selected]=\"value === tab.stateId\"\n    [attr.aria-controls]=\"'panel-' + tab.stateId\"\n    [attr.tabindex]=\"value === tab.stateId ? 0 : -1\"\n    [id]=\"'tab-' + tab.stateId\"\n    [class]=\"tab.buttonClass\"\n    type=\"button\"\n  >\n    {{ tab.label }}\n  </button>\n</div>\n<div\n  class=\"tab-content\"\n  role=\"tabpanel\"\n  [id]=\"'panel-' + value\"\n  [attr.aria-labelledby]=\"'tab-' + value\"\n  #tabContent\n>\n  <ng-template [ngTemplateOutlet]=\"currentTemplate\"></ng-template>\n</div>\n", styles: ["dp3-tab-container{--tab-header-border-height: 2px;--tab-header-border-color: #e2e8f0;--tab-text-color: rgb(100, 116, 139);--active-tab-text-color: var(--primary-blue);--active-tab-border-color: var(--primary-blue);--disabled-tab-text-color: #b1b9c5;--tab-vertical-button-width: 200px;display:block;position:relative}dp3-tab-container.active>.tab-header-panel{background-color:var(--hover-blue)}dp3-tab-container.panel-vertical{display:flex}dp3-tab-container.panel-vertical>.tab-header-panel{position:absolute;top:0;height:100%;width:var(--tab-vertical-button-width);overflow-y:auto}dp3-tab-container.panel-vertical>.tab-header-panel>button{text-align:left;width:100%;white-space:nowrap;overflow-x:hidden;text-overflow:ellipsis}dp3-tab-container.panel-vertical>.tab-content{width:calc(100% - var(--tab-vertical-button-width))}dp3-tab-container.panel-right{flex-direction:row-reverse}dp3-tab-container.panel-right>.tab-header-panel{right:0}dp3-tab-container.panel-left>.tab-header-panel{left:0}dp3-tab-container.panel-left>.tab-content{margin-left:var(--tab-vertical-button-width)}dp3-tab-container.panel-horizontal>.tab-header-panel{width:100%;white-space:nowrap;overflow-x:auto}dp3-tab-container.panel-bottom{display:flex;flex-direction:column-reverse}dp3-tab-container .tab-header-panel{position:relative;background-color:rgba(var(--primary-blue-rgb),.045)}dp3-tab-container .tab-header-panel:after{content:\"\";position:absolute;width:100%;height:var(--tab-header-border-height);background-color:var(--tab-header-border-color);margin-top:var(--tab-header-border-height);bottom:0;left:0;z-index:-1}dp3-tab-container .dot{position:absolute;width:.85rem;height:.85rem;padding:0 .1rem;background-color:var(--primary-blue);color:var(--white);font-size:x-small;border-radius:100%;top:.25rem;right:0rem}dp3-tab-container .tab-header-button{position:relative;background:none;font:inherit;outline:inherit;border:none;color:var(--tab-text-color);font-weight:700;font-size:1.1rem}dp3-tab-container .tab-header-button.active{position:relative;color:var(--active-tab-text-color)}dp3-tab-container .tab-header-button.active:after{content:\"\";position:absolute;width:100%;height:var(--tab-header-border-height);background-color:var(--active-tab-text-color);margin-top:var(--tab-header-border-height);bottom:0;left:0}dp3-tab-container .tab-header-button:disabled{color:var(--disabled-tab-text-color)}dp3-tab-container .tab-header-button.padding-small{padding-right:1.1rem!important}dp3-tab-container .tab-header-button.padding-large{padding-right:1.3rem!important}dp3-tab-container>.tab-content{min-width:0;width:100%;padding:.5rem}dp3-tab-container>.tab-content:has(>.dp3-tab-container){padding:0}dp3-tab-container>.tab-content>.dp3-tab-container{width:100%;height:100%}\n"], dependencies: [{ kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: RdtTabContainerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'rdt-tab-container', changeDetection: ChangeDetectionStrategy.OnPush, providers: [
+                        {
+                            provide: RDT_GUARDED_COMPONENT,
+                            useExisting: RdtTabContainerComponent,
+                        },
+                    ], hostDirectives: [RdtChildDirective], encapsulation: ViewEncapsulation.None, template: "<div class=\"tab-header-panel\" *ngIf=\"tabsList\">\n  <button\n    *ngFor=\"let tab of tabsList\"\n    #headerButton\n    class=\"px-2 py-1 tab-header-button\"\n    (click)=\"activateTab(tab.stateId)\"\n    [class.active]=\"value === tab.stateId\"\n    [disabled]=\"tab.disabled\"\n    [hidden]=\"!tab.visible\"\n    role=\"tab\"\n    [attr.aria-selected]=\"value === tab.stateId\"\n    [attr.aria-controls]=\"'panel-' + tab.stateId\"\n    [attr.tabindex]=\"value === tab.stateId ? 0 : -1\"\n    [id]=\"'tab-' + tab.stateId\"\n    [class]=\"tab.buttonClass\"\n    type=\"button\"\n  >\n    {{ tab.label }}\n  </button>\n</div>\n<div\n  class=\"tab-content\"\n  role=\"tabpanel\"\n  [id]=\"'panel-' + value\"\n  [attr.aria-labelledby]=\"'tab-' + value\"\n  #tabContent\n>\n  <ng-template [ngTemplateOutlet]=\"currentTemplate\"></ng-template>\n</div>\n", styles: ["dp3-tab-container{--tab-header-border-height: 2px;--tab-header-border-color: #e2e8f0;--tab-text-color: rgb(100, 116, 139);--active-tab-text-color: var(--primary-blue);--active-tab-border-color: var(--primary-blue);--disabled-tab-text-color: #b1b9c5;--tab-vertical-button-width: 200px;display:block;position:relative}dp3-tab-container.active>.tab-header-panel{background-color:var(--hover-blue)}dp3-tab-container.panel-vertical{display:flex}dp3-tab-container.panel-vertical>.tab-header-panel{position:absolute;top:0;height:100%;width:var(--tab-vertical-button-width);overflow-y:auto}dp3-tab-container.panel-vertical>.tab-header-panel>button{text-align:left;width:100%;white-space:nowrap;overflow-x:hidden;text-overflow:ellipsis}dp3-tab-container.panel-vertical>.tab-content{width:calc(100% - var(--tab-vertical-button-width))}dp3-tab-container.panel-right{flex-direction:row-reverse}dp3-tab-container.panel-right>.tab-header-panel{right:0}dp3-tab-container.panel-left>.tab-header-panel{left:0}dp3-tab-container.panel-left>.tab-content{margin-left:var(--tab-vertical-button-width)}dp3-tab-container.panel-horizontal>.tab-header-panel{width:100%;white-space:nowrap;overflow-x:auto}dp3-tab-container.panel-bottom{display:flex;flex-direction:column-reverse}dp3-tab-container .tab-header-panel{position:relative;background-color:rgba(var(--primary-blue-rgb),.045)}dp3-tab-container .tab-header-panel:after{content:\"\";position:absolute;width:100%;height:var(--tab-header-border-height);background-color:var(--tab-header-border-color);margin-top:var(--tab-header-border-height);bottom:0;left:0;z-index:-1}dp3-tab-container .dot{position:absolute;width:.85rem;height:.85rem;padding:0 .1rem;background-color:var(--primary-blue);color:var(--white);font-size:x-small;border-radius:100%;top:.25rem;right:0rem}dp3-tab-container .tab-header-button{position:relative;background:none;font:inherit;outline:inherit;border:none;color:var(--tab-text-color);font-weight:700;font-size:1.1rem}dp3-tab-container .tab-header-button.active{position:relative;color:var(--active-tab-text-color)}dp3-tab-container .tab-header-button.active:after{content:\"\";position:absolute;width:100%;height:var(--tab-header-border-height);background-color:var(--active-tab-text-color);margin-top:var(--tab-header-border-height);bottom:0;left:0}dp3-tab-container .tab-header-button:disabled{color:var(--disabled-tab-text-color)}dp3-tab-container .tab-header-button.padding-small{padding-right:1.1rem!important}dp3-tab-container .tab-header-button.padding-large{padding-right:1.3rem!important}dp3-tab-container>.tab-content{min-width:0;width:100%;padding:.5rem}dp3-tab-container>.tab-content:has(>.dp3-tab-container){padding:0}dp3-tab-container>.tab-content>.dp3-tab-container{width:100%;height:100%}\n"] }]
+        }], propDecorators: { stateId: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], formAutofocus: [{
+                type: Input
+            }], panelPosition: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }], tabsList: [{
+                type: ContentChildren,
+                args: [RdtTabComponent]
+            }], tabHeaderButtons: [{
+                type: ViewChildren,
+                args: ['headerButton']
+            }], tabContent: [{
+                type: ViewChild,
+                args: ['tabContent', { static: true }]
+            }], _active: [{
+                type: HostBinding,
+                args: ['class.active']
+            }], classes: [{
+                type: HostBinding,
+                args: ['class']
+            }], isHorizontal: [{
+                type: HostBinding,
+                args: ['class.panel-horizontal']
+            }], isVertical: [{
+                type: HostBinding,
+                args: ['class.panel-vertical']
+            }], attrRole: [{
+                type: HostBinding,
+                args: ['attr.role']
+            }], onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rdt-tab-container.component.js","sourceRoot":"","sources":["../../../../../../../@ngrdt/tabs/src/lib/components/tab-container/rdt-tab-container.component.ts","../../../../../../../@ngrdt/tabs/src/lib/components/tab-container/rdt-tab-container.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterContentInit,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ContentChildren,\n  DestroyRef,\n  ElementRef,\n  EventEmitter,\n  HostBinding,\n  HostListener,\n  inject,\n  Input,\n  Output,\n  QueryList,\n  Renderer2,\n  TemplateRef,\n  ViewChild,\n  ViewChildren,\n  ViewEncapsulation,\n} from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport {\n  canTransition$,\n  RDT_GUARDED_COMPONENT,\n  RdtChildDirective,\n} from '@ngrdt/core';\nimport { RdtHTMLUtils } from '@ngrdt/utils';\nimport { firstValueFrom, timer } from 'rxjs';\nimport { RdtTabControllerDirective } from '../../directives/rdt-tab-controller.directive';\nimport { RdtTabContainerState, RdtTabState } from '../../rdt-tabs-models';\nimport { RdtTabComponent } from '../tab/rdt-tab.component';\n\n@Component({\n  selector: 'rdt-tab-container',\n  templateUrl: './rdt-tab-container.component.html',\n  styleUrls: ['./rdt-tab-container.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  providers: [\n    {\n      provide: RDT_GUARDED_COMPONENT,\n      useExisting: RdtTabContainerComponent,\n    },\n  ],\n  hostDirectives: [RdtChildDirective],\n  encapsulation: ViewEncapsulation.None,\n})\nexport class RdtTabContainerComponent implements AfterContentInit {\n  readonly destroyRef = inject(DestroyRef);\n\n  @Input()\n  stateId: any = null;\n\n  @Input()\n  set value(val: string) {\n    if (this.activeTab && this.activeTab.stateId !== val) {\n      // TODO\n      //this.activeTab.onViewWillLeave();\n    }\n    this._value = val;\n    this.setCurrent();\n  }\n  get value() {\n    return this._value;\n  }\n  private _value!: string;\n\n  @Input()\n  disabled = false;\n\n  @Input()\n  formAutofocus = true;\n\n  @Input()\n  panelPosition: 'left' | 'right' | 'top' | 'bottom' = 'top';\n\n  @Output()\n  valueChange = new EventEmitter();\n\n  @ContentChildren(RdtTabComponent)\n  tabsList!: QueryList<RdtTabComponent>;\n\n  @ViewChildren('headerButton')\n  tabHeaderButtons?: QueryList<ElementRef<HTMLElement>>;\n\n  @ViewChild('tabContent', { static: true })\n  tabContent!: ElementRef<HTMLElement>;\n\n  @HostBinding('class.active')\n  private _active = false;\n  get active() {\n    return this._active;\n  }\n  set active(value: boolean) {\n    this._active = value;\n    this.cd.markForCheck();\n  }\n\n  get isTopLevel(): boolean {\n    return !this.parentTab;\n  }\n\n  readonly parentTab = inject(RdtTabComponent, { optional: true });\n  readonly controller = inject(RdtTabControllerDirective, {\n    optional: true,\n  });\n  readonly cd = inject(ChangeDetectorRef);\n  readonly elRef = inject(ElementRef);\n  protected readonly renderer = inject(Renderer2);\n\n  protected currentTemplate: TemplateRef<any> | null = null;\n  protected currentTab: RdtTabComponent | null = null;\n\n  @HostBinding('class')\n  get classes() {\n    return `dp3-tab-container panel-${this.panelPosition}`;\n  }\n\n  @HostBinding('class.panel-horizontal')\n  get isHorizontal() {\n    return this.panelPosition === 'top' || this.panelPosition === 'bottom';\n  }\n\n  @HostBinding('class.panel-vertical')\n  get isVertical() {\n    return !this.isHorizontal;\n  }\n\n  @HostBinding('attr.role')\n  private attrRole = 'tablist';\n\n  get hasNonDisabledTabs() {\n    return this.tabsList.some((tab) => !tab.disabled);\n  }\n\n  get activeTab() {\n    return this.getTabByValue(this.value);\n  }\n\n  getTabByValue(value: string) {\n    return this.tabsList?.find((tab) => tab.stateId === value);\n  }\n\n  ngAfterContentInit() {\n    this.controller?.onTabContainerChanges();\n    timer(0)\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe(() => this.setCurrent());\n\n    this.tabsList.changes\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe(() => {\n        this.controller?.onTabChanges();\n        this.setCurrent();\n        this.cd.markForCheck();\n      });\n\n    if (this.stateId === null && this.controller) {\n      const id = this.controller.getTabContainerIndex(this);\n      this.stateId = `tab-container-${id}`;\n    }\n  }\n\n  getState(): RdtTabContainerState {\n    return {\n      id: this.stateId,\n      value: this.value,\n      tabStates: this.tabsList.map((tab) => tab.getState()),\n    };\n  }\n\n  applyState(state: RdtTabContainerState) {\n    this.value = state.value;\n    this.scrollCurrentButtonIntoView();\n\n    const states: (RdtTabState | null)[] = [...state.tabStates];\n    const tabs: (RdtTabComponent | null)[] = this.tabsList.toArray();\n    const minLen = Math.min(states.length, tabs.length);\n\n    for (let i = 0; i < minLen; i++) {\n      if (tabs[i]!.stateId === states[i]!.id) {\n        tabs[i]!.applyState(states[i]!);\n        tabs[i] = states[i] = null;\n      }\n    }\n    tabs.forEach((tab, tabI) => {\n      if (!tab) {\n        return;\n      }\n      for (let offset = 0; offset < states.length; offset++) {\n        const prev = tabI - offset;\n        const next = tabI + offset;\n        if (prev > 0 && states[prev]?.id === tab.stateId) {\n          tab.applyState(states[prev]!);\n          states[prev] = null;\n          return;\n        } else if (next < states.length && states[next]?.id === tab.stateId) {\n          tab.applyState(states[next]!);\n          states[next] = null;\n          return;\n        }\n      }\n    });\n  }\n\n  scrollIntoView() {\n    this.elRef?.nativeElement?.scrollIntoView({ behavior: 'smooth' });\n  }\n\n  async activateTab(value: string) {\n    const nextTab = this.getTabByValue(value);\n\n    const can = await firstValueFrom(\n      canTransition$(this.activeTab?.contDir, nextTab?.contDir)\n    );\n    if (can) {\n      this.value = value;\n      this.valueChange.emit(value);\n    }\n  }\n\n  scrollCurrentButtonIntoView() {\n    if (!this.tabsList || !this.tabHeaderButtons) {\n      return;\n    }\n    const tabIndex = this.tabsList\n      .toArray()\n      .findIndex((tab) => tab.stateId === this.value);\n    const buttonRef = this.tabHeaderButtons.get(tabIndex);\n    if (buttonRef) {\n      RdtHTMLUtils.scrollIntoViewHorizontallyWithinParent(\n        buttonRef.nativeElement\n      );\n    }\n  }\n\n  @HostListener('click', ['$event'])\n  private onClick(event: PointerEvent) {\n    this.controller?.activateTabContainerFromClick(this, event.timeStamp);\n  }\n\n  private setCurrent() {\n    if (!this.tabsList) {\n      return;\n    }\n    if (this.value == undefined) {\n      const firstEnabled = this.getFirstEnabledTab();\n      if (firstEnabled) {\n        this.value = firstEnabled.stateId;\n      } else {\n        return;\n      }\n    }\n\n    const found = this.tabsList.find((tab) => tab.stateId === this.value);\n    if (!found) {\n      const first = this.getFirstEnabledTab();\n      if (first) {\n        this.activateTab(first.stateId);\n        return;\n      } else {\n        console.error(\n          'Active tab not found.',\n          this.tabsList.toArray(),\n          this.value\n        );\n        return;\n      }\n    }\n    this.setTab(found);\n  }\n\n  private setTab(tab: RdtTabComponent) {\n    if (this.currentTab !== tab) {\n      this.solidifyTabContentSize();\n      this.currentTab = tab;\n      this.currentTemplate = tab.templateRef;\n      this.cd.markForCheck();\n      //tab.onViewWillEnter();\n    }\n\n    if (this.formAutofocus && tab.formAutofocus) {\n      // Wait until template is attached to DOM\n      timer(0)\n        .pipe(\n          takeUntilDestroyed(this.destroyRef),\n          takeUntilDestroyed(tab.destroyRef)\n        )\n        .subscribe(() => tab.focusForm());\n    }\n\n    setTimeout(() => this.releaseTabContentSize());\n  }\n\n  // Swapping template in template outlet will cause large css recalc\n  // fix size to previous tab and in case they are the same size\n  // the recalc isn't noticable\n  private solidifyTabContentSize() {\n    const el = this.tabContent.nativeElement;\n    const bb = el.getBoundingClientRect();\n    this.renderer.setStyle(el, 'width', bb.width + 'px');\n    this.renderer.setStyle(el, 'height', bb.height + 'px');\n  }\n\n  private releaseTabContentSize() {\n    const el = this.tabContent.nativeElement;\n    this.renderer.removeStyle(el, 'width');\n    this.renderer.removeStyle(el, 'height');\n  }\n\n  private getFirstEnabledTab() {\n    return this.tabsList.find((t) => !t.disabled);\n  }\n}\n","<div class=\"tab-header-panel\" *ngIf=\"tabsList\">\n  <button\n    *ngFor=\"let tab of tabsList\"\n    #headerButton\n    class=\"px-2 py-1 tab-header-button\"\n    (click)=\"activateTab(tab.stateId)\"\n    [class.active]=\"value === tab.stateId\"\n    [disabled]=\"tab.disabled\"\n    [hidden]=\"!tab.visible\"\n    role=\"tab\"\n    [attr.aria-selected]=\"value === tab.stateId\"\n    [attr.aria-controls]=\"'panel-' + tab.stateId\"\n    [attr.tabindex]=\"value === tab.stateId ? 0 : -1\"\n    [id]=\"'tab-' + tab.stateId\"\n    [class]=\"tab.buttonClass\"\n    type=\"button\"\n  >\n    {{ tab.label }}\n  </button>\n</div>\n<div\n  class=\"tab-content\"\n  role=\"tabpanel\"\n  [id]=\"'panel-' + value\"\n  [attr.aria-labelledby]=\"'tab-' + value\"\n  #tabContent\n>\n  <ng-template [ngTemplateOutlet]=\"currentTemplate\"></ng-template>\n</div>\n"]}

package/esm2022/lib/directives/rdt-destroy-inactive.directive.mjs

@@ -0,0 +1,14 @@
+import { Directive, inject, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export class RdtDestroyInactiveDirective {
+    template = inject(TemplateRef);
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: RdtDestroyInactiveDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.7", type: RdtDestroyInactiveDirective, selector: "[rdtDestroyInactive]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: RdtDestroyInactiveDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[rdtDestroyInactive]',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmR0LWRlc3Ryb3ktaW5hY3RpdmUuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vQG5ncmR0L3RhYnMvc3JjL2xpYi9kaXJlY3RpdmVzL3JkdC1kZXN0cm95LWluYWN0aXZlLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sRUFBRSxXQUFXLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSy9ELE1BQU0sT0FBTywyQkFBMkI7SUFDdEIsUUFBUSxHQUFHLE1BQU0sQ0FBQyxXQUFXLENBQUMsQ0FBQzt1R0FEcEMsMkJBQTJCOzJGQUEzQiwyQkFBMkI7OzJGQUEzQiwyQkFBMkI7a0JBSHZDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLHNCQUFzQjtpQkFDakMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIGluamVjdCwgVGVtcGxhdGVSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQERpcmVjdGl2ZSh7XG4gIHNlbGVjdG9yOiAnW3JkdERlc3Ryb3lJbmFjdGl2ZV0nLFxufSlcbmV4cG9ydCBjbGFzcyBSZHREZXN0cm95SW5hY3RpdmVEaXJlY3RpdmUge1xuICBwdWJsaWMgcmVhZG9ubHkgdGVtcGxhdGUgPSBpbmplY3QoVGVtcGxhdGVSZWYpO1xufVxuIl19