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

package/esm2022/components/accordion/accordion.mjs

@@ -0,0 +1,196 @@
+import { Component, ViewChild, Input, } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { cls, uuid } from "../../utils";
+import { DBAccordionItem } from "../accordion-item/accordion-item";
+import { DEFAULT_ID } from "../../shared/constants";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+const defaultProps = {};
+export class DBAccordion {
+    constructor() {
+        this.cls = cls;
+        this._id = DEFAULT_ID;
+        this._name = "";
+        this.initialized = false;
+        this._initOpenIndexDone = false;
+    }
+    convertItems(items) {
+        try {
+            if (typeof items === "string") {
+                return JSON.parse(items);
+            }
+            return items;
+        }
+        catch (error) {
+            console.error(error);
+        }
+        return [];
+    }
+    trackByItem0(index, item) {
+        return `accordion-item-${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 || "accordion-" + uuid();
+            this.initialized = true;
+            this._initOpenIndexDone = true;
+        }
+    }
+    ngAfterViewInit() {
+        const element = this._ref?.nativeElement;
+        this.enableAttributePassing(element, "db-accordion");
+    }
+    ngAfterContentChecked(changes) {
+        if (typeof window !== "undefined") {
+            // If we have a single behavior we first check for
+            // props.name otherwise for state_id
+            if (this.initialized) {
+                if (this.behavior === "single") {
+                    if (this.name) {
+                        if (this._name !== this.name) {
+                            this._name = this.name;
+                        }
+                    }
+                    else {
+                        if (this._name !== this._id && this._id) {
+                            this._name = this._id;
+                        }
+                    }
+                }
+                else {
+                    this._name = "";
+                }
+            }
+            if (this._ref?.nativeElement) {
+                const childDetails = this._ref?.nativeElement.getElementsByTagName("details");
+                if (childDetails) {
+                    for (const details of Array.from(childDetails)) {
+                        if (this._name === "") {
+                            details.removeAttribute("name");
+                        }
+                        else {
+                            details.name = this._name;
+                        }
+                    }
+                }
+            }
+            if (this._ref?.nativeElement && this._initOpenIndexDone) {
+                if (this.initOpenIndex && this.initOpenIndex?.length > 0) {
+                    const childDetails = this._ref?.nativeElement.getElementsByTagName("details");
+                    if (childDetails) {
+                        const initOpenIndex = this.behavior === "single" && this.initOpenIndex.length > 1
+                            ? [this.initOpenIndex[0]] // use only one index for behavior=single
+                            : this.initOpenIndex;
+                        Array.from(childDetails).forEach((details, index) => {
+                            if (initOpenIndex.includes(index)) {
+                                details.open = true;
+                            }
+                        });
+                    }
+                }
+                this._initOpenIndexDone = false;
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DBAccordion, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: DBAccordion, isStandalone: true, selector: "db-accordion", inputs: { id: "id", name: "name", behavior: "behavior", initOpenIndex: "initOpenIndex", className: "className", variant: "variant", items: "items" }, viewQueries: [{ propertyName: "_ref", first: true, predicate: ["_ref"], descendants: true }], ngImport: i0, template: `
+    <ul
+      #_ref
+      [attr.id]="_id"
+      [class]="cls('db-accordion', className)"
+      [attr.data-variant]="variant"
+    >
+      <ng-container *ngIf="!items"><ng-content></ng-content></ng-container>
+      <ng-container *ngIf="items">
+        <ng-container
+          *ngFor="let item of convertItems(items); index as index; trackBy: trackByItem0"
+        >
+          <db-accordion-item
+            [headlinePlain]="item.headlinePlain"
+            [disabled]="item.disabled"
+            [text]="item.text"
+          ></db-accordion-item>
+        </ng-container>
+      </ng-container>
+    </ul>
+  `, 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: DBAccordionItem, selector: "db-accordion-item", inputs: ["id", "defaultOpen", "className", "disabled", "headlinePlain", "text"], outputs: ["onToggle"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DBAccordion, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "db-accordion",
+                    template: `
+    <ul
+      #_ref
+      [attr.id]="_id"
+      [class]="cls('db-accordion', className)"
+      [attr.data-variant]="variant"
+    >
+      <ng-container *ngIf="!items"><ng-content></ng-content></ng-container>
+      <ng-container *ngIf="items">
+        <ng-container
+          *ngFor="let item of convertItems(items); index as index; trackBy: trackByItem0"
+        >
+          <db-accordion-item
+            [headlinePlain]="item.headlinePlain"
+            [disabled]="item.disabled"
+            [text]="item.text"
+          ></db-accordion-item>
+        </ng-container>
+      </ng-container>
+    </ul>
+  `,
+                    standalone: true,
+                    imports: [CommonModule, DBAccordionItem],
+                }]
+        }], propDecorators: { id: [{
+                type: Input
+            }], name: [{
+                type: Input
+            }], behavior: [{
+                type: Input
+            }], initOpenIndex: [{
+                type: Input
+            }], className: [{
+                type: Input
+            }], variant: [{
+                type: Input
+            }], items: [{
+                type: Input
+            }], _ref: [{
+                type: ViewChild,
+                args: ["_ref"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"accordion.js","sourceRoot":"","sources":["../../../../../output/angular/src/components/accordion/accordion.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 { DBAccordionItemDefaultProps } from \"../accordion-item/model\";\nimport { DBAccordionProps, DBAccordionState } from \"./model\";\nimport { cls, uuid } from \"../../utils\";\nimport { DBAccordionItem } from \"../accordion-item/accordion-item\";\nimport { DEFAULT_ID } from \"../../shared/constants\";\n\n@Component({\n  selector: \"db-accordion\",\n  template: `\n    <ul\n      #_ref\n      [attr.id]=\"_id\"\n      [class]=\"cls('db-accordion', className)\"\n      [attr.data-variant]=\"variant\"\n    >\n      <ng-container *ngIf=\"!items\"><ng-content></ng-content></ng-container>\n      <ng-container *ngIf=\"items\">\n        <ng-container\n          *ngFor=\"let item of convertItems(items); index as index; trackBy: trackByItem0\"\n        >\n          <db-accordion-item\n            [headlinePlain]=\"item.headlinePlain\"\n            [disabled]=\"item.disabled\"\n            [text]=\"item.text\"\n          ></db-accordion-item>\n        </ng-container>\n      </ng-container>\n    </ul>\n  `,\n  standalone: true,\n  imports: [CommonModule, DBAccordionItem],\n})\nexport class DBAccordion {\n  cls = cls;\n\n  @Input() id!: DBAccordionProps[\"id\"];\n  @Input() name!: DBAccordionProps[\"name\"];\n  @Input() behavior!: DBAccordionProps[\"behavior\"];\n  @Input() initOpenIndex!: DBAccordionProps[\"initOpenIndex\"];\n  @Input() className!: DBAccordionProps[\"className\"];\n  @Input() variant!: DBAccordionProps[\"variant\"];\n  @Input() items!: DBAccordionProps[\"items\"];\n\n  @ViewChild(\"_ref\") _ref!: ElementRef | undefined;\n\n  _id: DBAccordionState[\"_id\"] = DEFAULT_ID;\n  _name: DBAccordionState[\"_name\"] = \"\";\n  initialized: DBAccordionState[\"initialized\"] = false;\n  _initOpenIndexDone: DBAccordionState[\"_initOpenIndexDone\"] = false;\n  convertItems(\n    items: unknown[] | string | undefined\n  ): ReturnType<DBAccordionState[\"convertItems\"]> {\n    try {\n      if (typeof items === \"string\") {\n        return JSON.parse(items);\n      }\n      return items as DBAccordionItemDefaultProps[];\n    } catch (error) {\n      console.error(error);\n    }\n    return [];\n  }\n  trackByItem0(index, item) {\n    return `accordion-item-${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 || \"accordion-\" + uuid();\n      this.initialized = true;\n      this._initOpenIndexDone = true;\n    }\n  }\n\n  ngAfterViewInit() {\n    const element: HTMLElement | null = this._ref?.nativeElement;\n    this.enableAttributePassing(element, \"db-accordion\");\n  }\n\n  ngAfterContentChecked(changes: SimpleChanges) {\n    if (typeof window !== \"undefined\") {\n      // If we have a single behavior we first check for\n      // props.name otherwise for state_id\n      if (this.initialized) {\n        if (this.behavior === \"single\") {\n          if (this.name) {\n            if (this._name !== this.name) {\n              this._name = this.name;\n            }\n          } else {\n            if (this._name !== this._id && this._id) {\n              this._name = this._id;\n            }\n          }\n        } else {\n          this._name = \"\";\n        }\n      }\n      if (this._ref?.nativeElement) {\n        const childDetails =\n          this._ref?.nativeElement.getElementsByTagName(\"details\");\n        if (childDetails) {\n          for (const details of Array.from<HTMLDetailsElement>(childDetails)) {\n            if (this._name === \"\") {\n              details.removeAttribute(\"name\");\n            } else {\n              details.name = this._name;\n            }\n          }\n        }\n      }\n      if (this._ref?.nativeElement && this._initOpenIndexDone) {\n        if (this.initOpenIndex && this.initOpenIndex?.length > 0) {\n          const childDetails =\n            this._ref?.nativeElement.getElementsByTagName(\"details\");\n          if (childDetails) {\n            const initOpenIndex =\n              this.behavior === \"single\" && this.initOpenIndex.length > 1\n                ? [this.initOpenIndex[0]] // use only one index for behavior=single\n                : this.initOpenIndex;\n            Array.from<HTMLDetailsElement>(childDetails).forEach(\n              (details: HTMLDetailsElement, index: number) => {\n                if (initOpenIndex.includes(index)) {\n                  details.open = true;\n                }\n              }\n            );\n          }\n        }\n        this._initOpenIndexDone = false;\n      }\n    }\n  }\n}\n"]}

package/esm2022/components/accordion/index.mjs

@@ -0,0 +1,2 @@
+export { DBAccordion } from './accordion';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9vdXRwdXQvYW5ndWxhci9zcmMvY29tcG9uZW50cy9hY2NvcmRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGFBQWEsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IERCQWNjb3JkaW9uIH0gZnJvbSAnLi9hY2NvcmRpb24nIl19

package/esm2022/components/accordion/model.mjs

@@ -0,0 +1,3 @@
+export const AccordionVariantList = ['divider', 'card'];
+export const AccordionBehaviorList = ['multiple', 'single'];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/accordion-item/accordion-item.mjs

@@ -0,0 +1,136 @@
+import { Output, EventEmitter, Component, ViewChild, Input, } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { cls, getBooleanAsString, uuid } from "../../utils";
+import { DEFAULT_ID } from "../../shared/constants";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+const defaultProps = {};
+export class DBAccordionItem {
+    constructor() {
+        this.cls = cls;
+        this.getBooleanAsString = getBooleanAsString;
+        this.onToggle = new EventEmitter();
+        this._id = DEFAULT_ID;
+        this._open = false;
+    }
+    toggle(event) {
+        // We need this for react https://github.com/facebook/react/issues/15486#issuecomment-488028431
+        event?.preventDefault();
+        const newStateOpen = !this._open;
+        if (this.onToggle) {
+            this.onToggle.emit(newStateOpen);
+        }
+        this._open = newStateOpen;
+    }
+    /**
+     * 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 || "accordion-item-" + uuid();
+            if (this.defaultOpen) {
+                this._open = this.defaultOpen;
+            }
+        }
+    }
+    ngAfterViewInit() {
+        const element = this._ref?.nativeElement;
+        this.enableAttributePassing(element, "db-accordion-item");
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DBAccordionItem, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: DBAccordionItem, isStandalone: true, selector: "db-accordion-item", inputs: { id: "id", defaultOpen: "defaultOpen", className: "className", disabled: "disabled", headlinePlain: "headlinePlain", text: "text" }, outputs: { onToggle: "onToggle" }, viewQueries: [{ propertyName: "_ref", first: true, predicate: ["_ref"], descendants: true }], ngImport: i0, template: `
+    <li [attr.id]="_id" [class]="cls('db-accordion-item', className)">
+      <details
+        [attr.aria-disabled]="getBooleanAsString(disabled)"
+        #_ref
+        [open]="_open"
+      >
+        <summary (click)="toggle($event)">
+          <ng-container *ngIf="headlinePlain">{{headlinePlain}}</ng-container>
+          <ng-container *ngIf="!headlinePlain">
+            <ng-content select="[headline]"></ng-content>
+          </ng-container>
+        </summary>
+        <div>
+          <ng-container *ngIf="text">{{text}}</ng-container>
+          <ng-container *ngIf="!(text)"><ng-content></ng-content></ng-container>
+        </div>
+      </details>
+    </li>
+  `, 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: DBAccordionItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "db-accordion-item",
+                    template: `
+    <li [attr.id]="_id" [class]="cls('db-accordion-item', className)">
+      <details
+        [attr.aria-disabled]="getBooleanAsString(disabled)"
+        #_ref
+        [open]="_open"
+      >
+        <summary (click)="toggle($event)">
+          <ng-container *ngIf="headlinePlain">{{headlinePlain}}</ng-container>
+          <ng-container *ngIf="!headlinePlain">
+            <ng-content select="[headline]"></ng-content>
+          </ng-container>
+        </summary>
+        <div>
+          <ng-container *ngIf="text">{{text}}</ng-container>
+          <ng-container *ngIf="!(text)"><ng-content></ng-content></ng-container>
+        </div>
+      </details>
+    </li>
+  `,
+                    standalone: true,
+                    imports: [CommonModule],
+                }]
+        }], propDecorators: { id: [{
+                type: Input
+            }], defaultOpen: [{
+                type: Input
+            }], className: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], headlinePlain: [{
+                type: Input
+            }], text: [{
+                type: Input
+            }], onToggle: [{
+                type: Output
+            }], _ref: [{
+                type: ViewChild,
+                args: ["_ref"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"accordion-item.js","sourceRoot":"","sources":["../../../../../output/angular/src/components/accordion-item/accordion-item.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Output,\n  EventEmitter,\n  Component,\n  ViewChild,\n  ElementRef,\n  Input,\n} from \"@angular/core\";\nimport { CommonModule } from \"@angular/common\";\n\nconst defaultProps = {};\n\nimport { DBAccordionItemProps, DBAccordionItemState } from \"./model\";\nimport { cls, getBooleanAsString, uuid } from \"../../utils\";\nimport { ClickEvent } from \"../../shared/model\";\nimport { DEFAULT_ID } from \"../../shared/constants\";\n\n@Component({\n  selector: \"db-accordion-item\",\n  template: `\n    <li [attr.id]=\"_id\" [class]=\"cls('db-accordion-item', className)\">\n      <details\n        [attr.aria-disabled]=\"getBooleanAsString(disabled)\"\n        #_ref\n        [open]=\"_open\"\n      >\n        <summary (click)=\"toggle($event)\">\n          <ng-container *ngIf=\"headlinePlain\">{{headlinePlain}}</ng-container>\n          <ng-container *ngIf=\"!headlinePlain\">\n            <ng-content select=\"[headline]\"></ng-content>\n          </ng-container>\n        </summary>\n        <div>\n          <ng-container *ngIf=\"text\">{{text}}</ng-container>\n          <ng-container *ngIf=\"!(text)\"><ng-content></ng-content></ng-container>\n        </div>\n      </details>\n    </li>\n  `,\n  standalone: true,\n  imports: [CommonModule],\n})\nexport class DBAccordionItem {\n  cls = cls;\n  getBooleanAsString = getBooleanAsString;\n\n  @Input() id!: DBAccordionItemProps[\"id\"];\n  @Input() defaultOpen!: DBAccordionItemProps[\"defaultOpen\"];\n  @Input() className!: DBAccordionItemProps[\"className\"];\n  @Input() disabled!: DBAccordionItemProps[\"disabled\"];\n  @Input() headlinePlain!: DBAccordionItemProps[\"headlinePlain\"];\n  @Input() text!: DBAccordionItemProps[\"text\"];\n\n  @Output() onToggle = new EventEmitter();\n\n  @ViewChild(\"_ref\") _ref!: ElementRef | undefined;\n\n  _id: DBAccordionItemState[\"_id\"] = DEFAULT_ID;\n  _open: DBAccordionItemState[\"_open\"] = false;\n  toggle(\n    event: ClickEvent<HTMLElement>\n  ): ReturnType<DBAccordionItemState[\"toggle\"]> {\n    // We need this for react https://github.com/facebook/react/issues/15486#issuecomment-488028431\n    event?.preventDefault();\n    const newStateOpen = !this._open;\n    if (this.onToggle) {\n      this.onToggle.emit(newStateOpen);\n    }\n    this._open = newStateOpen;\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 || \"accordion-item-\" + uuid();\n      if (this.defaultOpen) {\n        this._open = this.defaultOpen;\n      }\n    }\n  }\n\n  ngAfterViewInit() {\n    const element: HTMLElement | null = this._ref?.nativeElement;\n    this.enableAttributePassing(element, \"db-accordion-item\");\n  }\n}\n"]}

package/esm2022/components/accordion-item/index.mjs

@@ -0,0 +1,2 @@
+export { DBAccordionItem } from './accordion-item';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9vdXRwdXQvYW5ndWxhci9zcmMvY29tcG9uZW50cy9hY2NvcmRpb24taXRlbS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sa0JBQWtCLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBEQkFjY29yZGlvbkl0ZW0gfSBmcm9tICcuL2FjY29yZGlvbi1pdGVtJyJdfQ==

package/esm2022/components/accordion-item/model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9vdXRwdXQvYW5ndWxhci9zcmMvY29tcG9uZW50cy9hY2NvcmRpb24taXRlbS9tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgR2xvYmFsUHJvcHMsIEdsb2JhbFN0YXRlLCBUZXh0UHJvcHMsIFRvZ2dsZUV2ZW50UHJvcHMsIFRvZ2dsZUV2ZW50U3RhdGUgfSBmcm9tICcuLi8uLi9zaGFyZWQvbW9kZWwnO1xuZXhwb3J0IHR5cGUgREJBY2NvcmRpb25JdGVtRGVmYXVsdFByb3BzID0ge1xuICAvKipcbiAgICogSW5pdGlhbCBzdGF0ZSBmb3IgdGhlIGFjY29yZGlvbiBpdGVtXG4gICAqL1xuICBkZWZhdWx0T3Blbj86IGJvb2xlYW47XG4gIC8qKlxuICAgKiBUaGUgZGlzYWJsZWQgYXR0cmlidXRlIGNhbiBiZSBzZXQgdG8ga2VlcCBhIHVzZXIgZnJvbSBjbGlja2luZyBvbiB0aGUgZWxlbWVudC5cbiAgICovXG4gIGRpc2FibGVkPzogYm9vbGVhbjtcbiAgLyoqXG4gICAqIFRpdGxlIG9mIHRoZSBhY2NvcmRpb24taXRlbSBhcyBzbG90XG4gICAqL1xuICBoZWFkbGluZT86IGFueTtcbiAgLyoqXG4gICAqIFRpdGxlIG9mIHRoZSBhY2NvcmRpb24taXRlbSBhcyBwbGFpbiB0ZXh0XG4gICAqL1xuICBoZWFkbGluZVBsYWluPzogc3RyaW5nO1xufSAmIFRleHRQcm9wcztcbmV4cG9ydCB0eXBlIERCQWNjb3JkaW9uSXRlbVByb3BzID0gREJBY2NvcmRpb25JdGVtRGVmYXVsdFByb3BzICYgR2xvYmFsUHJvcHMgJiBUb2dnbGVFdmVudFByb3BzO1xuZXhwb3J0IHR5cGUgREJBY2NvcmRpb25JdGVtRGVmYXVsdFN0YXRlID0ge1xuICBfb3BlbjogYm9vbGVhbjtcbn07XG5leHBvcnQgdHlwZSBEQkFjY29yZGlvbkl0ZW1TdGF0ZSA9IERCQWNjb3JkaW9uSXRlbURlZmF1bHRTdGF0ZSAmIEdsb2JhbFN0YXRlICYgVG9nZ2xlRXZlbnRTdGF0ZTxIVE1MRWxlbWVudD4iXX0=

package/esm2022/components/badge/badge.mjs

@@ -0,0 +1,130 @@
+import { Component, ViewChild, Input, } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { cls } from "../../utils";
+import { DEFAULT_LABEL } from "../../shared/constants";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+const defaultProps = {};
+export class DBBadge {
+    constructor() {
+        this.cls = cls;
+        this.DEFAULT_LABEL = DEFAULT_LABEL;
+        this.initialized = false;
+    }
+    /**
+     * 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.initialized = true;
+        }
+    }
+    ngAfterViewInit() {
+        const element = this._ref?.nativeElement;
+        this.enableAttributePassing(element, "db-badge");
+    }
+    ngAfterContentChecked(changes) {
+        if (typeof window !== "undefined") {
+            if (this._ref?.nativeElement && this.initialized) {
+                if (this.placement?.startsWith("corner")) {
+                    let parent = this._ref.nativeElement.parentElement;
+                    if (parent && parent.localName.includes("badge")) {
+                        // Angular workaround
+                        parent = parent.parentElement;
+                    }
+                    if (parent) {
+                        parent.setAttribute("data-has-badge", "true");
+                    }
+                }
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DBBadge, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: DBBadge, isStandalone: true, selector: "db-badge", inputs: { placement: "placement", id: "id", className: "className", semantic: "semantic", size: "size", emphasis: "emphasis", label: "label", text: "text" }, viewQueries: [{ propertyName: "_ref", first: true, predicate: ["_ref"], descendants: true }], ngImport: i0, template: `
+    <span
+      #_ref
+      [attr.id]="id"
+      [class]="cls('db-badge', className)"
+      [attr.data-semantic]="semantic"
+      [attr.data-size]="size"
+      [attr.data-emphasis]="emphasis"
+      [attr.data-placement]="placement"
+      [attr.data-label]="placement?.startsWith('corner') && (label ?? DEFAULT_LABEL)"
+    >
+      <ng-container *ngIf="text">{{text}}</ng-container>
+      <ng-container *ngIf="!(text)"><ng-content></ng-content></ng-container>
+    </span>
+  `, 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: DBBadge, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "db-badge",
+                    template: `
+    <span
+      #_ref
+      [attr.id]="id"
+      [class]="cls('db-badge', className)"
+      [attr.data-semantic]="semantic"
+      [attr.data-size]="size"
+      [attr.data-emphasis]="emphasis"
+      [attr.data-placement]="placement"
+      [attr.data-label]="placement?.startsWith('corner') && (label ?? DEFAULT_LABEL)"
+    >
+      <ng-container *ngIf="text">{{text}}</ng-container>
+      <ng-container *ngIf="!(text)"><ng-content></ng-content></ng-container>
+    </span>
+  `,
+                    standalone: true,
+                    imports: [CommonModule],
+                }]
+        }], propDecorators: { placement: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], className: [{
+                type: Input
+            }], semantic: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], emphasis: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], text: [{
+                type: Input
+            }], _ref: [{
+                type: ViewChild,
+                args: ["_ref"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"badge.js","sourceRoot":"","sources":["../../../../../output/angular/src/components/badge/badge.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 { DBBadgeProps, DBBadgeState } from \"./model\";\nimport { cls } from \"../../utils\";\nimport { DEFAULT_LABEL } from \"../../shared/constants\";\n\n@Component({\n  selector: \"db-badge\",\n  template: `\n    <span\n      #_ref\n      [attr.id]=\"id\"\n      [class]=\"cls('db-badge', className)\"\n      [attr.data-semantic]=\"semantic\"\n      [attr.data-size]=\"size\"\n      [attr.data-emphasis]=\"emphasis\"\n      [attr.data-placement]=\"placement\"\n      [attr.data-label]=\"placement?.startsWith('corner') && (label ?? DEFAULT_LABEL)\"\n    >\n      <ng-container *ngIf=\"text\">{{text}}</ng-container>\n      <ng-container *ngIf=\"!(text)\"><ng-content></ng-content></ng-container>\n    </span>\n  `,\n  standalone: true,\n  imports: [CommonModule],\n})\nexport class DBBadge {\n  cls = cls;\n  DEFAULT_LABEL = DEFAULT_LABEL;\n\n  @Input() placement!: DBBadgeProps[\"placement\"];\n  @Input() id!: DBBadgeProps[\"id\"];\n  @Input() className!: DBBadgeProps[\"className\"];\n  @Input() semantic!: DBBadgeProps[\"semantic\"];\n  @Input() size!: DBBadgeProps[\"size\"];\n  @Input() emphasis!: DBBadgeProps[\"emphasis\"];\n  @Input() label!: DBBadgeProps[\"label\"];\n  @Input() text!: DBBadgeProps[\"text\"];\n\n  @ViewChild(\"_ref\") _ref!: ElementRef | undefined;\n\n  initialized: DBBadgeState[\"initialized\"] = false;\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.initialized = true;\n    }\n  }\n\n  ngAfterViewInit() {\n    const element: HTMLElement | null = this._ref?.nativeElement;\n    this.enableAttributePassing(element, \"db-badge\");\n  }\n\n  ngAfterContentChecked(changes: SimpleChanges) {\n    if (typeof window !== \"undefined\") {\n      if (this._ref?.nativeElement && this.initialized) {\n        if (this.placement?.startsWith(\"corner\")) {\n          let parent = this._ref.nativeElement.parentElement;\n          if (parent && parent.localName.includes(\"badge\")) {\n            // Angular workaround\n            parent = parent.parentElement;\n          }\n          if (parent) {\n            parent.setAttribute(\"data-has-badge\", \"true\");\n          }\n        }\n      }\n    }\n  }\n}\n"]}

package/esm2022/components/badge/index.mjs

@@ -0,0 +1,2 @@
+export { DBBadge } from './badge';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9vdXRwdXQvYW5ndWxhci9zcmMvY29tcG9uZW50cy9iYWRnZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sU0FBUyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgREJCYWRnZSB9IGZyb20gJy4vYmFkZ2UnIl19

package/esm2022/components/badge/model.mjs

@@ -0,0 +1,2 @@
+export const BadgePlacementList = ['inline', 'corner-top-left', 'corner-top-right', 'corner-center-left', 'corner-center-right', 'corner-bottom-left', 'corner-bottom-right'];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9vdXRwdXQvYW5ndWxhci9zcmMvY29tcG9uZW50cy9iYWRnZS9tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBSSxDQUFDLFFBQVEsRUFBRSxpQkFBaUIsRUFBRSxrQkFBa0IsRUFBRSxvQkFBb0IsRUFBRSxxQkFBcUIsRUFBRSxvQkFBb0IsRUFBRSxxQkFBcUIsQ0FBVyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgR2xvYmFsUHJvcHMsIEdsb2JhbFN0YXRlLCBJbml0aWFsaXplZFN0YXRlLCBTZW1hbnRpY1Byb3BzLCBTaXplUHJvcHMsIFRhZ0VtcGhhc2lzUHJvcHMsIFRleHRQcm9wcyB9IGZyb20gJy4uLy4uL3NoYXJlZC9tb2RlbCc7XG5leHBvcnQgY29uc3QgQmFkZ2VQbGFjZW1lbnRMaXN0ID0gKFsnaW5saW5lJywgJ2Nvcm5lci10b3AtbGVmdCcsICdjb3JuZXItdG9wLXJpZ2h0JywgJ2Nvcm5lci1jZW50ZXItbGVmdCcsICdjb3JuZXItY2VudGVyLXJpZ2h0JywgJ2Nvcm5lci1ib3R0b20tbGVmdCcsICdjb3JuZXItYm90dG9tLXJpZ2h0J10gYXMgY29uc3QpO1xuZXhwb3J0IHR5cGUgQmFkZ2VQbGFjZW1lbnRUeXBlID0gKHR5cGVvZiBCYWRnZVBsYWNlbWVudExpc3QpW251bWJlcl07XG5leHBvcnQgdHlwZSBEQkJhZGdlRGVmYXVsdFByb3BzID0ge1xuICAvKipcbiAgICogVGhlIGBwbGFjZW1lbnRgIGF0dHJpYnV0ZXMgYGNvcm5lci0qYCB2YWx1ZXMgY2hhbmdlIHRoZSBwb3NpdGlvbiB0byBhYnNvbHV0ZSBhbmQgYWRkcyBhIHRyYW5zZm9ybSBiYXNlZCBvbiB0aGUgcGxhY2VtZW50LlxuICAgKi9cbiAgcGxhY2VtZW50PzogQmFkZ2VQbGFjZW1lbnRUeXBlO1xuXG4gIC8qKlxuICAgKiBEZXNjcmliZXMgdGhlIGJhZGdlIGZvciBhMTF5IGlmIHlvdSB1c2UgcGxhY2VtZW50IGF0dHJpYnV0ZSB3aXRoIGBjb3JuZXItKmBcbiAgICovXG4gIGxhYmVsPzogc3RyaW5nO1xufTtcbmV4cG9ydCB0eXBlIERCQmFkZ2VQcm9wcyA9IERCQmFkZ2VEZWZhdWx0UHJvcHMgJiBHbG9iYWxQcm9wcyAmIFNlbWFudGljUHJvcHMgJiBTaXplUHJvcHMgJiBUYWdFbXBoYXNpc1Byb3BzICYgVGV4dFByb3BzO1xuZXhwb3J0IHR5cGUgREJCYWRnZURlZmF1bHRTdGF0ZSA9IHt9O1xuZXhwb3J0IHR5cGUgREJCYWRnZVN0YXRlID0gREJCYWRnZURlZmF1bHRTdGF0ZSAmIEdsb2JhbFN0YXRlICYgSW5pdGlhbGl6ZWRTdGF0ZSJdfQ==