@db-ux/ngx-core-components 1.0.0-test-13b991d

package/esm2022/components/tab-panel/tab-panel.mjs

@@ -0,0 +1,96 @@
+import { Component, ViewChild, Input } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { cls } from "../../utils";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+const defaultProps = {};
+export class DBTabPanel {
+    constructor() {
+        this.cls = cls;
+    }
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    enableAttributePassing(element, customElementSelector) {
+        const parent = element?.closest(customElementSelector);
+        if (element && parent) {
+            const attributes = parent.attributes;
+            for (let i = 0; i < attributes.length; i++) {
+                const attr = attributes.item(i);
+                if (attr &&
+                    (attr.name.startsWith("data-") || attr.name.startsWith("aria-"))) {
+                    element.setAttribute(attr.name, attr.value);
+                    parent.removeAttribute(attr.name);
+                }
+                if (attr && attr.name === "class") {
+                    const isWebComponent = attr.value.includes("hydrated");
+                    const value = attr.value.replace("hydrated", "").trim();
+                    const currentClass = element.getAttribute("class");
+                    element.setAttribute(attr.name, `${currentClass ? `${currentClass} ` : ""}${value}`);
+                    if (isWebComponent) {
+                        // Stencil is using this class for lazy loading component
+                        parent.setAttribute("class", "hydrated");
+                    }
+                    else {
+                        parent.removeAttribute(attr.name);
+                    }
+                }
+            }
+        }
+    }
+    ngOnInit() {
+        if (typeof window !== "undefined") {
+        }
+    }
+    ngAfterViewInit() {
+        const element = this._ref?.nativeElement;
+        this.enableAttributePassing(element, "db-tab-panel");
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DBTabPanel, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: DBTabPanel, isStandalone: true, selector: "db-tab-panel", inputs: { className: "className", id: "id", labelledBy: "labelledBy", content: "content" }, viewQueries: [{ propertyName: "_ref", first: true, predicate: ["_ref"], descendants: true }], ngImport: i0, template: `
+    <section
+      role="tabpanel"
+      #_ref
+      [class]="cls('db-tab-panel', className)"
+      [attr.id]="id"
+      [attr.aria-labelledby]="labelledBy"
+    >
+      <ng-container *ngIf="content">{{content}}</ng-container>
+      <ng-content></ng-content>
+    </section>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DBTabPanel, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "db-tab-panel",
+                    template: `
+    <section
+      role="tabpanel"
+      #_ref
+      [class]="cls('db-tab-panel', className)"
+      [attr.id]="id"
+      [attr.aria-labelledby]="labelledBy"
+    >
+      <ng-container *ngIf="content">{{content}}</ng-container>
+      <ng-content></ng-content>
+    </section>
+  `,
+                    standalone: true,
+                    imports: [CommonModule],
+                }]
+        }], propDecorators: { className: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], labelledBy: [{
+                type: Input
+            }], content: [{
+                type: Input
+            }], _ref: [{
+                type: ViewChild,
+                args: ["_ref"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/tabs/index.mjs

@@ -0,0 +1,2 @@
+export { DBTabs } from './tabs';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9vdXRwdXQvYW5ndWxhci9zcmMvY29tcG9uZW50cy90YWJzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxRQUFRLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBEQlRhYnMgfSBmcm9tICcuL3RhYnMnIl19

package/esm2022/components/tabs/model.mjs

@@ -0,0 +1,3 @@
+export const TabsBehaviorList = ['scrollbar', 'arrows'];
+export const TabsInitialSelectedModeList = ['auto', 'manually'];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/tabs/tabs.mjs

@@ -0,0 +1,322 @@
+import { Component, ViewChild, Input, } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { cls, uuid } from "../../utils";
+import { DBButton } from "../button/button";
+import { DBTabList } from "../tab-list/tab-list";
+import { DBTabItem } from "../tab-item/tab-item";
+import { DBTabPanel } from "../tab-panel/tab-panel";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+const defaultProps = {};
+export class DBTabs {
+    constructor() {
+        this.cls = cls;
+        this._id = "tabs-" + uuid();
+        this._name = "";
+        this.initialized = false;
+        this.showScrollLeft = false;
+        this.showScrollRight = false;
+        this.scrollContainer = null;
+    }
+    convertTabs(tabs) {
+        try {
+            if (typeof tabs === "string") {
+                return JSON.parse(tabs);
+            }
+            return tabs;
+        }
+        catch (error) {
+            console.error(error);
+        }
+        return [];
+    }
+    evaluateScrollButtons(tList) {
+        const needsScroll = tList.scrollWidth > tList.clientWidth;
+        this.showScrollLeft = needsScroll && tList.scrollLeft > 1;
+        this.showScrollRight =
+            needsScroll && tList.scrollLeft < tList.scrollWidth - tList.clientWidth;
+    }
+    scroll(left) {
+        let step = this.arrowScrollDistance || 100;
+        if (left) {
+            step *= -1;
+        }
+        this.scrollContainer?.scrollBy({
+            top: 0,
+            left: step,
+            behavior: "smooth",
+        });
+    }
+    initTabList() {
+        if (this._ref?.nativeElement) {
+            const tabList = this._ref.nativeElement.querySelector(".db-tab-list");
+            if (tabList) {
+                const container = tabList.querySelector('[role="tablist"]');
+                if (container) {
+                    container.setAttribute("aria-orientation", this.orientation || "horizontal");
+                    if (this.behavior === "arrows") {
+                        this.scrollContainer = container;
+                        this.evaluateScrollButtons(container);
+                        container.addEventListener("scroll", () => {
+                            this.evaluateScrollButtons(container);
+                        });
+                    }
+                }
+            }
+        }
+    }
+    initTabs(init) {
+        if (this._ref?.nativeElement) {
+            const tabItems = Array.from(this._ref?.nativeElement.getElementsByClassName("db-tab-item"));
+            for (const tabItem of tabItems) {
+                const index = tabItems.indexOf(tabItem);
+                const label = tabItem.querySelector("label");
+                const input = tabItem.querySelector("input");
+                if (input && label) {
+                    if (!input.id) {
+                        const tabId = `${this._name}-tab-${index}`;
+                        label.setAttribute("for", tabId);
+                        input.setAttribute("aria-controls", `${this._name}-tab-panel-${index}`);
+                        input.id = tabId;
+                        input.setAttribute("name", this._name);
+                    }
+                    if (init) {
+                        // Auto select
+                        const autoSelect = !this.initialSelectedMode || this.initialSelectedMode === "auto";
+                        const shouldAutoSelect = (this.initialSelectedIndex == null && index === 0) ||
+                            this.initialSelectedIndex === index;
+                        if (autoSelect && shouldAutoSelect) {
+                            input.click();
+                        }
+                    }
+                }
+            }
+            const tabPanels = Array.from(this._ref?.nativeElement.querySelectorAll(":is(:scope > .db-tab-panel, :scope > db-tab-panel > .db-tab-panel)"));
+            for (const panel of tabPanels) {
+                if (panel.id)
+                    continue;
+                const index = tabPanels.indexOf(panel);
+                panel.id = `${this._name}-tab-panel-${index}`;
+                panel.setAttribute("aria-labelledby", `${this._name}-tab-${index}`);
+            }
+        }
+    }
+    trackByTab0(index, tab) {
+        return this.name + "tab-item" + index;
+    }
+    trackByTab1(index, tab) {
+        return this.name + "tab-panel" + index;
+    }
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    enableAttributePassing(element, customElementSelector) {
+        const parent = element?.closest(customElementSelector);
+        if (element && parent) {
+            const attributes = parent.attributes;
+            for (let i = 0; i < attributes.length; i++) {
+                const attr = attributes.item(i);
+                if (attr &&
+                    (attr.name.startsWith("data-") || attr.name.startsWith("aria-"))) {
+                    element.setAttribute(attr.name, attr.value);
+                    parent.removeAttribute(attr.name);
+                }
+                if (attr && attr.name === "class") {
+                    const isWebComponent = attr.value.includes("hydrated");
+                    const value = attr.value.replace("hydrated", "").trim();
+                    const currentClass = element.getAttribute("class");
+                    element.setAttribute(attr.name, `${currentClass ? `${currentClass} ` : ""}${value}`);
+                    if (isWebComponent) {
+                        // Stencil is using this class for lazy loading component
+                        parent.setAttribute("class", "hydrated");
+                    }
+                    else {
+                        parent.removeAttribute(attr.name);
+                    }
+                }
+            }
+        }
+    }
+    ngOnInit() {
+        if (typeof window !== "undefined") {
+            this._id = this.id || this._id;
+            this._name = `tabs-${this.name || uuid()}`;
+            this.initialized = true;
+        }
+    }
+    ngAfterViewInit() {
+        const element = this._ref?.nativeElement;
+        this.enableAttributePassing(element, "db-tabs");
+    }
+    ngAfterContentChecked(changes) {
+        if (typeof window !== "undefined") {
+            if (this._ref?.nativeElement && this.initialized) {
+                this.initTabList();
+                this.initTabs(true);
+                const tabList = this._ref.nativeElement.querySelector(".db-tab-list");
+                if (tabList) {
+                    const observer = new MutationObserver((mutations) => {
+                        mutations.forEach((mutation) => {
+                            if (mutation.removedNodes.length || mutation.addedNodes.length) {
+                                this.initTabList();
+                                this.initTabs();
+                            }
+                        });
+                    });
+                    observer.observe(tabList, {
+                        childList: true,
+                        subtree: true,
+                    });
+                }
+                this.initialized = false;
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DBTabs, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: DBTabs, isStandalone: true, selector: "db-tabs", inputs: { id: "id", name: "name", arrowScrollDistance: "arrowScrollDistance", orientation: "orientation", behavior: "behavior", initialSelectedMode: "initialSelectedMode", initialSelectedIndex: "initialSelectedIndex", className: "className", alignment: "alignment", width: "width", tabs: "tabs" }, viewQueries: [{ propertyName: "_ref", first: true, predicate: ["_ref"], descendants: true }], ngImport: i0, template: `
+    <div
+      #_ref
+      [attr.id]="_id"
+      [class]="cls('db-tabs', className)"
+      [attr.data-orientation]="orientation"
+      [attr.data-scroll-behavior]="behavior"
+      [attr.data-alignment]="alignment ?? 'start'"
+      [attr.data-width]="width ?? 'auto'"
+    >
+      <ng-container *ngIf="showScrollLeft">
+        <db-button
+          class="tabs-scroll-left"
+          variant="ghost"
+          icon="chevron_left"
+          [noText]="true"
+          (click)="scroll(true)"
+        >
+          Scroll left
+        </db-button>
+      </ng-container>
+      <ng-container *ngIf="tabs">
+        <db-tab-list>
+          <ng-container
+            *ngFor="let tab of convertTabs(tabs); index as index; trackBy: trackByTab0"
+          >
+            <db-tab-item
+              [active]="tab.active"
+              [label]="tab.label"
+              [iconAfter]="tab.iconAfter"
+              [icon]="tab.icon"
+              [noText]="tab.noText"
+            ></db-tab-item>
+          </ng-container>
+        </db-tab-list>
+        <ng-container
+          *ngFor="let tab of convertTabs(tabs); index as index; trackBy: trackByTab1"
+        >
+          <db-tab-panel [content]="tab.content">{{tab.children}}</db-tab-panel>
+        </ng-container>
+      </ng-container>
+      <ng-container *ngIf="showScrollRight">
+        <db-button
+          class="tabs-scroll-right"
+          variant="ghost"
+          icon="chevron_right"
+          [noText]="true"
+          (click)="scroll()"
+        >
+          Scroll right
+        </db-button>
+      </ng-container>
+      <ng-content></ng-content>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: DBButton, selector: "db-button", inputs: ["id", "className", "type", "disabled", "label", "icon", "showIcon", "size", "state", "width", "variant", "noText", "name", "value", "describedbyid", "ariaexpanded", "ariapressed", "text"], outputs: ["onClick"] }, { kind: "component", type: DBTabList, selector: "db-tab-list", inputs: ["id", "className"] }, { kind: "component", type: DBTabItem, selector: "db-tab-item", inputs: ["active", "className", "id", "icon", "iconAfter", "showIcon", "noText", "disabled", "controls", "checked", "label"], outputs: ["onChange", "change"] }, { kind: "component", type: DBTabPanel, selector: "db-tab-panel", inputs: ["className", "id", "labelledBy", "content"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DBTabs, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "db-tabs",
+                    template: `
+    <div
+      #_ref
+      [attr.id]="_id"
+      [class]="cls('db-tabs', className)"
+      [attr.data-orientation]="orientation"
+      [attr.data-scroll-behavior]="behavior"
+      [attr.data-alignment]="alignment ?? 'start'"
+      [attr.data-width]="width ?? 'auto'"
+    >
+      <ng-container *ngIf="showScrollLeft">
+        <db-button
+          class="tabs-scroll-left"
+          variant="ghost"
+          icon="chevron_left"
+          [noText]="true"
+          (click)="scroll(true)"
+        >
+          Scroll left
+        </db-button>
+      </ng-container>
+      <ng-container *ngIf="tabs">
+        <db-tab-list>
+          <ng-container
+            *ngFor="let tab of convertTabs(tabs); index as index; trackBy: trackByTab0"
+          >
+            <db-tab-item
+              [active]="tab.active"
+              [label]="tab.label"
+              [iconAfter]="tab.iconAfter"
+              [icon]="tab.icon"
+              [noText]="tab.noText"
+            ></db-tab-item>
+          </ng-container>
+        </db-tab-list>
+        <ng-container
+          *ngFor="let tab of convertTabs(tabs); index as index; trackBy: trackByTab1"
+        >
+          <db-tab-panel [content]="tab.content">{{tab.children}}</db-tab-panel>
+        </ng-container>
+      </ng-container>
+      <ng-container *ngIf="showScrollRight">
+        <db-button
+          class="tabs-scroll-right"
+          variant="ghost"
+          icon="chevron_right"
+          [noText]="true"
+          (click)="scroll()"
+        >
+          Scroll right
+        </db-button>
+      </ng-container>
+      <ng-content></ng-content>
+    </div>
+  `,
+                    standalone: true,
+                    imports: [CommonModule, DBButton, DBTabList, DBTabItem, DBTabPanel],
+                }]
+        }], propDecorators: { id: [{
+                type: Input
+            }], name: [{
+                type: Input
+            }], arrowScrollDistance: [{
+                type: Input
+            }], orientation: [{
+                type: Input
+            }], behavior: [{
+                type: Input
+            }], initialSelectedMode: [{
+                type: Input
+            }], initialSelectedIndex: [{
+                type: Input
+            }], className: [{
+                type: Input
+            }], alignment: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], tabs: [{
+                type: Input
+            }], _ref: [{
+                type: ViewChild,
+                args: ["_ref"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tabs.js","sourceRoot":"","sources":["../../../../../output/angular/src/components/tabs/tabs.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  ViewChild,\n  ElementRef,\n  Input,\n  SimpleChanges,\n} from \"@angular/core\";\nimport { CommonModule } from \"@angular/common\";\n\nconst defaultProps = {};\n\nimport { DBSimpleTabProps, DBTabsProps, DBTabsState } from \"./model\";\nimport { cls, uuid } from \"../../utils\";\nimport { DBButton } from \"../button/button\";\nimport { DBTabList } from \"../tab-list/tab-list\";\nimport { DBTabItem } from \"../tab-item/tab-item\";\nimport { DBTabPanel } from \"../tab-panel/tab-panel\";\n\n@Component({\n  selector: \"db-tabs\",\n  template: `\n    <div\n      #_ref\n      [attr.id]=\"_id\"\n      [class]=\"cls('db-tabs', className)\"\n      [attr.data-orientation]=\"orientation\"\n      [attr.data-scroll-behavior]=\"behavior\"\n      [attr.data-alignment]=\"alignment ?? 'start'\"\n      [attr.data-width]=\"width ?? 'auto'\"\n    >\n      <ng-container *ngIf=\"showScrollLeft\">\n        <db-button\n          class=\"tabs-scroll-left\"\n          variant=\"ghost\"\n          icon=\"chevron_left\"\n          [noText]=\"true\"\n          (click)=\"scroll(true)\"\n        >\n          Scroll left\n        </db-button>\n      </ng-container>\n      <ng-container *ngIf=\"tabs\">\n        <db-tab-list>\n          <ng-container\n            *ngFor=\"let tab of convertTabs(tabs); index as index; trackBy: trackByTab0\"\n          >\n            <db-tab-item\n              [active]=\"tab.active\"\n              [label]=\"tab.label\"\n              [iconAfter]=\"tab.iconAfter\"\n              [icon]=\"tab.icon\"\n              [noText]=\"tab.noText\"\n            ></db-tab-item>\n          </ng-container>\n        </db-tab-list>\n        <ng-container\n          *ngFor=\"let tab of convertTabs(tabs); index as index; trackBy: trackByTab1\"\n        >\n          <db-tab-panel [content]=\"tab.content\">{{tab.children}}</db-tab-panel>\n        </ng-container>\n      </ng-container>\n      <ng-container *ngIf=\"showScrollRight\">\n        <db-button\n          class=\"tabs-scroll-right\"\n          variant=\"ghost\"\n          icon=\"chevron_right\"\n          [noText]=\"true\"\n          (click)=\"scroll()\"\n        >\n          Scroll right\n        </db-button>\n      </ng-container>\n      <ng-content></ng-content>\n    </div>\n  `,\n  standalone: true,\n  imports: [CommonModule, DBButton, DBTabList, DBTabItem, DBTabPanel],\n})\nexport class DBTabs {\n  cls = cls;\n\n  @Input() id!: DBTabsProps[\"id\"];\n  @Input() name!: DBTabsProps[\"name\"];\n  @Input() arrowScrollDistance!: DBTabsProps[\"arrowScrollDistance\"];\n  @Input() orientation!: DBTabsProps[\"orientation\"];\n  @Input() behavior!: DBTabsProps[\"behavior\"];\n  @Input() initialSelectedMode!: DBTabsProps[\"initialSelectedMode\"];\n  @Input() initialSelectedIndex!: DBTabsProps[\"initialSelectedIndex\"];\n  @Input() className!: DBTabsProps[\"className\"];\n  @Input() alignment!: DBTabsProps[\"alignment\"];\n  @Input() width!: DBTabsProps[\"width\"];\n  @Input() tabs!: DBTabsProps[\"tabs\"];\n\n  @ViewChild(\"_ref\") _ref!: ElementRef | undefined;\n\n  _id: DBTabsState[\"_id\"] = \"tabs-\" + uuid();\n  _name: DBTabsState[\"_name\"] = \"\";\n  initialized: DBTabsState[\"initialized\"] = false;\n  showScrollLeft: DBTabsState[\"showScrollLeft\"] = false;\n  showScrollRight: DBTabsState[\"showScrollRight\"] = false;\n  scrollContainer: DBTabsState[\"scrollContainer\"] = null;\n  convertTabs(\n    tabs: unknown[] | string | undefined\n  ): ReturnType<DBTabsState[\"convertTabs\"]> {\n    try {\n      if (typeof tabs === \"string\") {\n        return JSON.parse(tabs);\n      }\n      return tabs as DBSimpleTabProps[];\n    } catch (error) {\n      console.error(error);\n    }\n    return [];\n  }\n  evaluateScrollButtons(\n    tList: Element\n  ): ReturnType<DBTabsState[\"evaluateScrollButtons\"]> {\n    const needsScroll = tList.scrollWidth > tList.clientWidth;\n    this.showScrollLeft = needsScroll && tList.scrollLeft > 1;\n    this.showScrollRight =\n      needsScroll && tList.scrollLeft < tList.scrollWidth - tList.clientWidth;\n  }\n  scroll(left?: boolean): ReturnType<DBTabsState[\"scroll\"]> {\n    let step = this.arrowScrollDistance || 100;\n    if (left) {\n      step *= -1;\n    }\n    this.scrollContainer?.scrollBy({\n      top: 0,\n      left: step,\n      behavior: \"smooth\",\n    });\n  }\n  initTabList(): ReturnType<DBTabsState[\"initTabList\"]> {\n    if (this._ref?.nativeElement) {\n      const tabList = this._ref.nativeElement.querySelector(\".db-tab-list\");\n      if (tabList) {\n        const container: HTMLElement | null =\n          tabList.querySelector('[role=\"tablist\"]');\n        if (container) {\n          container.setAttribute(\n            \"aria-orientation\",\n            this.orientation || \"horizontal\"\n          );\n          if (this.behavior === \"arrows\") {\n            this.scrollContainer = container;\n            this.evaluateScrollButtons(container);\n            container.addEventListener(\"scroll\", () => {\n              this.evaluateScrollButtons(container);\n            });\n          }\n        }\n      }\n    }\n  }\n  initTabs(init?: boolean): ReturnType<DBTabsState[\"initTabs\"]> {\n    if (this._ref?.nativeElement) {\n      const tabItems = Array.from<Element>(\n        this._ref?.nativeElement.getElementsByClassName(\"db-tab-item\")\n      );\n      for (const tabItem of tabItems) {\n        const index: number = tabItems.indexOf(tabItem);\n        const label = tabItem.querySelector(\"label\");\n        const input = tabItem.querySelector(\"input\");\n        if (input && label) {\n          if (!input.id) {\n            const tabId = `${this._name}-tab-${index}`;\n            label.setAttribute(\"for\", tabId);\n            input.setAttribute(\n              \"aria-controls\",\n              `${this._name}-tab-panel-${index}`\n            );\n            input.id = tabId;\n            input.setAttribute(\"name\", this._name);\n          }\n          if (init) {\n            // Auto select\n            const autoSelect =\n              !this.initialSelectedMode || this.initialSelectedMode === \"auto\";\n            const shouldAutoSelect =\n              (this.initialSelectedIndex == null && index === 0) ||\n              this.initialSelectedIndex === index;\n            if (autoSelect && shouldAutoSelect) {\n              input.click();\n            }\n          }\n        }\n      }\n      const tabPanels = Array.from<Element>(\n        this._ref?.nativeElement.querySelectorAll(\n          \":is(:scope > .db-tab-panel, :scope > db-tab-panel > .db-tab-panel)\"\n        )\n      );\n      for (const panel of tabPanels) {\n        if (panel.id) continue;\n        const index: number = tabPanels.indexOf(panel);\n        panel.id = `${this._name}-tab-panel-${index}`;\n        panel.setAttribute(\"aria-labelledby\", `${this._name}-tab-${index}`);\n      }\n    }\n  }\n  trackByTab0(index, tab) {\n    return this.name + \"tab-item\" + index;\n  }\n  trackByTab1(index, tab) {\n    return this.name + \"tab-panel\" + index;\n  }\n\n  /**\n   * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.\n   * @param element  the ref for the component\n   * @param customElementSelector  the custom element like `my-component`\n   */\n  private enableAttributePassing(\n    element: HTMLElement | null,\n    customElementSelector: string\n  ) {\n    const parent = element?.closest(customElementSelector);\n    if (element && parent) {\n      const attributes = parent.attributes;\n      for (let i = 0; i < attributes.length; i++) {\n        const attr = attributes.item(i);\n        if (\n          attr &&\n          (attr.name.startsWith(\"data-\") || attr.name.startsWith(\"aria-\"))\n        ) {\n          element.setAttribute(attr.name, attr.value);\n          parent.removeAttribute(attr.name);\n        }\n        if (attr && attr.name === \"class\") {\n          const isWebComponent = attr.value.includes(\"hydrated\");\n          const value = attr.value.replace(\"hydrated\", \"\").trim();\n          const currentClass = element.getAttribute(\"class\");\n          element.setAttribute(\n            attr.name,\n            `${currentClass ? `${currentClass} ` : \"\"}${value}`\n          );\n          if (isWebComponent) {\n            // Stencil is using this class for lazy loading component\n            parent.setAttribute(\"class\", \"hydrated\");\n          } else {\n            parent.removeAttribute(attr.name);\n          }\n        }\n      }\n    }\n  }\n\n  ngOnInit() {\n    if (typeof window !== \"undefined\") {\n      this._id = this.id || this._id;\n      this._name = `tabs-${this.name || uuid()}`;\n      this.initialized = true;\n    }\n  }\n\n  ngAfterViewInit() {\n    const element: HTMLElement | null = this._ref?.nativeElement;\n    this.enableAttributePassing(element, \"db-tabs\");\n  }\n\n  ngAfterContentChecked(changes: SimpleChanges) {\n    if (typeof window !== \"undefined\") {\n      if (this._ref?.nativeElement && this.initialized) {\n        this.initTabList();\n        this.initTabs(true);\n        const tabList = this._ref.nativeElement.querySelector(\".db-tab-list\");\n        if (tabList) {\n          const observer = new MutationObserver((mutations) => {\n            mutations.forEach((mutation) => {\n              if (mutation.removedNodes.length || mutation.addedNodes.length) {\n                this.initTabList();\n                this.initTabs();\n              }\n            });\n          });\n          observer.observe(tabList, {\n            childList: true,\n            subtree: true,\n          });\n        }\n        this.initialized = false;\n      }\n    }\n  }\n}\n"]}

package/esm2022/components/tag/index.mjs

@@ -0,0 +1,2 @@
+export { DBTag } from './tag';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9vdXRwdXQvYW5ndWxhci9zcmMvY29tcG9uZW50cy90YWcvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssRUFBRSxNQUFNLE9BQU8sQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IERCVGFnIH0gZnJvbSAnLi90YWcnIl19

package/esm2022/components/tag/model.mjs

@@ -0,0 +1,2 @@
+export const TagBehaviorList = ['static', 'removable'];
+//# sourceMappingURL=data:application/json;base64,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