@deepfuture/dui-components 0.0.1

package/slider/slider.js

@@ -0,0 +1,268 @@
+/** Ported from original DUI: deep-future-app/app/client/components/dui/slider */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { css, html, LitElement } from "lit";
+import { property } from "lit/decorators.js";
+import { base } from "@deepfuture/dui-core/base";
+import { customEvent } from "@deepfuture/dui-core/event";
+export const valueChangeEvent = customEvent("value-change", { bubbles: true, composed: true });
+export const valueCommittedEvent = customEvent("value-committed", { bubbles: true, composed: true });
+const styles = css `
+  :host {
+    display: block;
+  }
+
+  [part="root"] {
+    position: relative;
+    display: flex;
+    align-items: center;
+    width: 100%;
+    touch-action: none;
+    user-select: none;
+  }
+
+  [part="root"][data-disabled] {
+    pointer-events: none;
+  }
+
+  [part="track"] {
+    position: relative;
+    flex-grow: 1;
+    overflow: hidden;
+  }
+
+  [part="indicator"] {
+    position: absolute;
+    top: 0;
+    left: 0;
+    height: 100%;
+    width: var(--slider-progress, 0%);
+  }
+
+  [part="thumb"] {
+    position: absolute;
+    left: var(--slider-progress, 0%);
+    transform: translateX(-50%);
+    cursor: grab;
+    outline: none;
+    transition-property: left, box-shadow;
+  }
+
+  [part="root"][data-dragging] [part="thumb"] {
+    cursor: grabbing;
+  }
+
+  /* Hidden native input for accessibility */
+  .native-input {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    padding: 0;
+    margin: -1px;
+    overflow: hidden;
+    clip: rect(0, 0, 0, 0);
+    white-space: nowrap;
+    border: 0;
+  }
+`;
+/**
+ * A slider for selecting numeric values within a range.
+ *
+ * Supports pointer drag, keyboard navigation (arrows, Page Up/Down, Home/End),
+ * and a hidden native range input for accessibility.
+ */
+export class DuiSlider extends LitElement {
+    static { this.tagName = "dui-slider"; }
+    static { this.styles = [base, styles]; }
+    #value_accessor_storage = 0;
+    /** Current value. */
+    get value() { return this.#value_accessor_storage; }
+    set value(value) { this.#value_accessor_storage = value; }
+    #min_accessor_storage = 0;
+    /** Minimum value. */
+    get min() { return this.#min_accessor_storage; }
+    set min(value) { this.#min_accessor_storage = value; }
+    #max_accessor_storage = 100;
+    /** Maximum value. */
+    get max() { return this.#max_accessor_storage; }
+    set max(value) { this.#max_accessor_storage = value; }
+    #step_accessor_storage = 1;
+    /** Step increment. */
+    get step() { return this.#step_accessor_storage; }
+    set step(value) { this.#step_accessor_storage = value; }
+    #disabled_accessor_storage = false;
+    /** Whether the slider is disabled. */
+    get disabled() { return this.#disabled_accessor_storage; }
+    set disabled(value) { this.#disabled_accessor_storage = value; }
+    #name_accessor_storage = "";
+    /** Name for form submission. */
+    get name() { return this.#name_accessor_storage; }
+    set name(value) { this.#name_accessor_storage = value; }
+    #dragging_accessor_storage = false;
+    get #dragging() { return this.#dragging_accessor_storage; }
+    set #dragging(value) { this.#dragging_accessor_storage = value; }
+    get #progress() {
+        const range = this.max - this.min;
+        if (range === 0)
+            return 0;
+        return ((this.value - this.min) / range) * 100;
+    }
+    #clampValue(value) {
+        const stepped = Math.round(value / this.step) * this.step;
+        return Math.max(this.min, Math.min(this.max, stepped));
+    }
+    #getValueFromPosition(clientX) {
+        const track = this.shadowRoot?.querySelector("[part='track']");
+        if (!track)
+            return this.value;
+        const rect = track.getBoundingClientRect();
+        const percentage = (clientX - rect.left) / rect.width;
+        const rawValue = this.min + percentage * (this.max - this.min);
+        return this.#clampValue(rawValue);
+    }
+    #onPointerDown = (event) => {
+        if (this.disabled)
+            return;
+        event.preventDefault();
+        this.#dragging = true;
+        const newValue = this.#getValueFromPosition(event.clientX);
+        if (newValue !== this.value) {
+            this.value = newValue;
+            this.dispatchEvent(valueChangeEvent({ value: newValue }));
+        }
+        document.addEventListener("pointermove", this.#onPointerMove);
+        document.addEventListener("pointerup", this.#onPointerUp);
+    };
+    #onPointerMove = (event) => {
+        if (!this.#dragging)
+            return;
+        const newValue = this.#getValueFromPosition(event.clientX);
+        if (newValue !== this.value) {
+            this.value = newValue;
+            this.dispatchEvent(valueChangeEvent({ value: newValue }));
+        }
+    };
+    #onPointerUp = () => {
+        if (!this.#dragging)
+            return;
+        this.#dragging = false;
+        this.dispatchEvent(valueCommittedEvent({ value: this.value }));
+        document.removeEventListener("pointermove", this.#onPointerMove);
+        document.removeEventListener("pointerup", this.#onPointerUp);
+    };
+    #onKeyDown = (event) => {
+        if (this.disabled)
+            return;
+        let newValue = this.value;
+        const largeStep = this.step * 10;
+        switch (event.key) {
+            case "ArrowRight":
+            case "ArrowUp":
+                event.preventDefault();
+                newValue = this.#clampValue(this.value + this.step);
+                break;
+            case "ArrowLeft":
+            case "ArrowDown":
+                event.preventDefault();
+                newValue = this.#clampValue(this.value - this.step);
+                break;
+            case "PageUp":
+                event.preventDefault();
+                newValue = this.#clampValue(this.value + largeStep);
+                break;
+            case "PageDown":
+                event.preventDefault();
+                newValue = this.#clampValue(this.value - largeStep);
+                break;
+            case "Home":
+                event.preventDefault();
+                newValue = this.min;
+                break;
+            case "End":
+                event.preventDefault();
+                newValue = this.max;
+                break;
+            default:
+                return;
+        }
+        if (newValue !== this.value) {
+            this.value = newValue;
+            this.dispatchEvent(valueChangeEvent({ value: newValue }));
+            this.dispatchEvent(valueCommittedEvent({ value: newValue }));
+        }
+    };
+    #onNativeInput = (event) => {
+        const target = event.target;
+        const newValue = parseFloat(target.value);
+        if (!isNaN(newValue) && newValue !== this.value) {
+            this.value = newValue;
+            this.dispatchEvent(valueChangeEvent({ value: newValue }));
+        }
+    };
+    #onNativeChange = () => {
+        this.dispatchEvent(valueCommittedEvent({ value: this.value }));
+    };
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        document.removeEventListener("pointermove", this.#onPointerMove);
+        document.removeEventListener("pointerup", this.#onPointerUp);
+    }
+    render() {
+        return html `
+      <div
+        part="root"
+        role="group"
+        ?data-disabled=${this.disabled}
+        ?data-dragging=${this.#dragging}
+        style="--slider-progress: ${this.#progress}%"
+        @pointerdown=${this.#onPointerDown}
+      >
+        <div part="track">
+          <div part="indicator"></div>
+        </div>
+        <div
+          part="thumb"
+          tabindex=${this.disabled ? -1 : 0}
+          @keydown=${this.#onKeyDown}
+        ></div>
+        <input
+          class="native-input"
+          type="range"
+          name=${this.name}
+          .value=${String(this.value)}
+          min=${this.min}
+          max=${this.max}
+          step=${this.step}
+          ?disabled=${this.disabled}
+          aria-valuenow=${this.value}
+          aria-valuemin=${this.min}
+          aria-valuemax=${this.max}
+          @input=${this.#onNativeInput}
+          @change=${this.#onNativeChange}
+        />
+      </div>
+    `;
+    }
+}
+__decorate([
+    property({ type: Number })
+], DuiSlider.prototype, "value", null);
+__decorate([
+    property({ type: Number })
+], DuiSlider.prototype, "min", null);
+__decorate([
+    property({ type: Number })
+], DuiSlider.prototype, "max", null);
+__decorate([
+    property({ type: Number })
+], DuiSlider.prototype, "step", null);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], DuiSlider.prototype, "disabled", null);
+__decorate([
+    property()
+], DuiSlider.prototype, "name", null);

package/spinner/index.d.ts

@@ -0,0 +1 @@
+export { DuiSpinner } from "./spinner.js";

package/spinner/index.js

@@ -0,0 +1 @@
+export { DuiSpinner } from "./spinner.js";

package/spinner/register.d.ts

@@ -0,0 +1 @@
+export {};

package/spinner/register.js

@@ -0,0 +1,4 @@
+import { DuiSpinner } from "./spinner.js";
+if (!customElements.get(DuiSpinner.tagName)) {
+    customElements.define(DuiSpinner.tagName, DuiSpinner);
+}

package/spinner/spinner.d.ts

@@ -0,0 +1,18 @@
+/** Ported from original DUI: deep-future-app/app/client/components/dui/spinner */
+import { LitElement, type TemplateResult } from "lit";
+type SpinnerSize = "sm" | "md" | "lg";
+type SpinnerVariant = "pulse" | "lucide-loader" | "lucide-loader-circle";
+/**
+ * A loading indicator with multiple animation variants and sizes.
+ */
+export declare class DuiSpinner extends LitElement {
+    #private;
+    static tagName: "dui-spinner";
+    static styles: import("lit").CSSResult[];
+    /** Size variant: "sm" (24px), "md" (32px), "lg" (44px). */
+    accessor size: SpinnerSize;
+    /** Animation variant. */
+    accessor variant: SpinnerVariant;
+    render(): TemplateResult;
+}
+export {};

package/spinner/spinner.js

@@ -0,0 +1,138 @@
+/** Ported from original DUI: deep-future-app/app/client/components/dui/spinner */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { css, html, LitElement, svg } from "lit";
+import { property } from "lit/decorators.js";
+import { base } from "@deepfuture/dui-core/base";
+/** Pulsing circle loading animation SVG */
+const pulseSvg = svg `
+  <svg
+    part="svg"
+    viewBox="0 0 44 44"
+    xmlns="http://www.w3.org/2000/svg"
+    role="img"
+    aria-label="Loading"
+  >
+    <circle cx="22" cy="22" r="8" fill="currentColor">
+      <animate
+        attributeName="r"
+        values="8;14;8"
+        dur="1.2s"
+        repeatCount="indefinite"
+        calcMode="spline"
+        keySplines="0.445,0.05,0.55,0.95;0.445,0.05,0.55,0.95"
+        keyTimes="0;0.5;1"
+      />
+      <animate
+        attributeName="opacity"
+        values="1;0.2;1"
+        dur="1.2s"
+        repeatCount="indefinite"
+        calcMode="spline"
+        keySplines="0.445,0.05,0.55,0.95;0.445,0.05,0.55,0.95"
+        keyTimes="0;0.5;1"
+      />
+    </circle>
+  </svg>
+`;
+/** Lucide loader icon with rotation animation */
+const lucideLoaderSvg = svg `
+  <svg
+    part="svg"
+    data-rotate
+    viewBox="0 0 24 24"
+    xmlns="http://www.w3.org/2000/svg"
+    fill="none"
+    stroke="currentColor"
+    stroke-width="2"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+    role="img"
+    aria-label="Loading"
+  >
+    <path d="M12 2v4" />
+    <path d="m16.2 7.8 2.9-2.9" />
+    <path d="M18 12h4" />
+    <path d="m16.2 16.2 2.9 2.9" />
+    <path d="M12 18v4" />
+    <path d="m4.9 19.1 2.9-2.9" />
+    <path d="M2 12h4" />
+    <path d="m4.9 4.9 2.9 2.9" />
+  </svg>
+`;
+/** Lucide loader circle icon with rotation animation */
+const lucideLoaderCircleSvg = svg `
+  <svg
+    part="svg"
+    data-rotate
+    viewBox="0 0 24 24"
+    xmlns="http://www.w3.org/2000/svg"
+    fill="none"
+    stroke="currentColor"
+    stroke-width="2"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+    role="img"
+    aria-label="Loading"
+  >
+    <path d="M21 12a9 9 0 1 1-6.219-8.56" />
+  </svg>
+`;
+const styles = css `
+  :host {
+    display: block;
+  }
+
+  [part="svg"] {
+    display: block;
+    width: 100%;
+    height: 100%;
+  }
+
+  [part="svg"][data-rotate] {
+    animation: spin 1.25s linear infinite;
+  }
+
+  @keyframes spin {
+    from { transform: rotate(0deg); }
+    to { transform: rotate(360deg); }
+  }
+`;
+/**
+ * A loading indicator with multiple animation variants and sizes.
+ */
+export class DuiSpinner extends LitElement {
+    static { this.tagName = "dui-spinner"; }
+    static { this.styles = [base, styles]; }
+    #size_accessor_storage = "sm";
+    /** Size variant: "sm" (24px), "md" (32px), "lg" (44px). */
+    get size() { return this.#size_accessor_storage; }
+    set size(value) { this.#size_accessor_storage = value; }
+    #variant_accessor_storage = "pulse";
+    /** Animation variant. */
+    get variant() { return this.#variant_accessor_storage; }
+    set variant(value) { this.#variant_accessor_storage = value; }
+    #getSvg() {
+        switch (this.variant) {
+            case "lucide-loader":
+                return lucideLoaderSvg;
+            case "lucide-loader-circle":
+                return lucideLoaderCircleSvg;
+            default:
+                return pulseSvg;
+        }
+    }
+    render() {
+        return html `${this.#getSvg()}`;
+    }
+}
+__decorate([
+    property({ reflect: true })
+], DuiSpinner.prototype, "size", null);
+__decorate([
+    property({ reflect: true })
+], DuiSpinner.prototype, "variant", null);

package/switch/index.d.ts

@@ -0,0 +1 @@
+export { DuiSwitch, checkedChangeEvent } from "./switch.js";

package/switch/index.js

@@ -0,0 +1 @@
+export { DuiSwitch, checkedChangeEvent } from "./switch.js";

package/switch/register.d.ts

@@ -0,0 +1 @@
+export {};

package/switch/register.js

@@ -0,0 +1,4 @@
+import { DuiSwitch } from "./index.js";
+if (!customElements.get(DuiSwitch.tagName)) {
+    customElements.define(DuiSwitch.tagName, DuiSwitch);
+}

package/switch/switch.d.ts

@@ -0,0 +1,29 @@
+import { LitElement, type TemplateResult } from "lit";
+export declare const checkedChangeEvent: (detail: {
+    checked: boolean;
+}) => CustomEvent<{
+    checked: boolean;
+}>;
+/**
+ * `<dui-switch>` — A toggle switch for binary on/off settings.
+ *
+ * @csspart root - The switch track container.
+ * @csspart thumb - The movable thumb indicator.
+ * @fires checked-change - Fired when toggled. Detail: { checked: boolean }
+ */
+export declare class DuiSwitch extends LitElement {
+    #private;
+    static tagName: "dui-switch";
+    static styles: import("lit").CSSResult[];
+    accessor checked: boolean | undefined;
+    accessor defaultChecked: boolean;
+    accessor disabled: boolean;
+    accessor readOnly: boolean;
+    accessor required: boolean;
+    accessor name: string | undefined;
+    accessor value: string;
+    accessor uncheckedValue: string;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    render(): TemplateResult;
+}

package/switch/switch.js

@@ -0,0 +1,201 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { css, html, LitElement, nothing } from "lit";
+import { property } from "lit/decorators.js";
+import { base } from "@deepfuture/dui-core/base";
+import { customEvent } from "@deepfuture/dui-core/event";
+export const checkedChangeEvent = customEvent("checked-change", { bubbles: true, composed: true });
+/** Structural styles only — layout and behavioral CSS. */
+const styles = css `
+  :host {
+    display: inline-flex;
+    align-items: start;
+    cursor: pointer;
+    text-align: start;
+  }
+
+  :host([disabled]) {
+    cursor: not-allowed;
+  }
+
+  [part="root"] {
+    position: relative;
+    display: inline-flex;
+    flex-shrink: 0;
+    align-items: center;
+    padding: 0;
+    margin-block-end: 0;
+    margin-inline: 0;
+    border: none;
+    cursor: pointer;
+    transition-property: background, outline-color, box-shadow, filter, transform;
+  }
+
+  [part="thumb"] {
+    position: absolute;
+    left: var(--switch-thumb-offset, 0.125rem);
+    transition-property: transform, outline-color;
+  }
+
+  [part="root"][data-checked] [part="thumb"] {
+    transform: translateX(var(--switch-checked-offset, 0));
+  }
+
+  .HiddenInput {
+    position: absolute;
+    pointer-events: none;
+    opacity: 0;
+    margin: 0;
+    width: 0;
+    height: 0;
+  }
+`;
+/**
+ * `<dui-switch>` — A toggle switch for binary on/off settings.
+ *
+ * @csspart root - The switch track container.
+ * @csspart thumb - The movable thumb indicator.
+ * @fires checked-change - Fired when toggled. Detail: { checked: boolean }
+ */
+export class DuiSwitch extends LitElement {
+    static { this.tagName = "dui-switch"; }
+    static { this.styles = [base, styles]; }
+    #checked_accessor_storage = undefined;
+    get checked() { return this.#checked_accessor_storage; }
+    set checked(value) { this.#checked_accessor_storage = value; }
+    #defaultChecked_accessor_storage = false;
+    get defaultChecked() { return this.#defaultChecked_accessor_storage; }
+    set defaultChecked(value) { this.#defaultChecked_accessor_storage = value; }
+    #disabled_accessor_storage = false;
+    get disabled() { return this.#disabled_accessor_storage; }
+    set disabled(value) { this.#disabled_accessor_storage = value; }
+    #readOnly_accessor_storage = false;
+    get readOnly() { return this.#readOnly_accessor_storage; }
+    set readOnly(value) { this.#readOnly_accessor_storage = value; }
+    #required_accessor_storage = false;
+    get required() { return this.#required_accessor_storage; }
+    set required(value) { this.#required_accessor_storage = value; }
+    #name_accessor_storage = undefined;
+    get name() { return this.#name_accessor_storage; }
+    set name(value) { this.#name_accessor_storage = value; }
+    #value_accessor_storage = "on";
+    get value() { return this.#value_accessor_storage; }
+    set value(value) { this.#value_accessor_storage = value; }
+    #uncheckedValue_accessor_storage = "";
+    get uncheckedValue() { return this.#uncheckedValue_accessor_storage; }
+    set uncheckedValue(value) { this.#uncheckedValue_accessor_storage = value; }
+    #internalChecked_accessor_storage = false;
+    get #internalChecked() { return this.#internalChecked_accessor_storage; }
+    set #internalChecked(value) { this.#internalChecked_accessor_storage = value; }
+    #fieldCtx_accessor_storage;
+    get #fieldCtx() { return this.#fieldCtx_accessor_storage; }
+    set #fieldCtx(value) { this.#fieldCtx_accessor_storage = value; }
+    get #isChecked() {
+        return this.checked ?? this.#internalChecked;
+    }
+    get #isDisabled() {
+        return this.disabled || (this.#fieldCtx?.disabled ?? false);
+    }
+    get #isInvalid() {
+        return this.#fieldCtx?.invalid ?? false;
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        if (this.checked === undefined && this.defaultChecked) {
+            this.#internalChecked = true;
+        }
+        this.addEventListener("click", this.#handleHostClick);
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        this.removeEventListener("click", this.#handleHostClick);
+    }
+    #handleHostClick = (_e) => {
+        this.#handleClick();
+    };
+    #handleClick = () => {
+        if (this.#isDisabled || this.readOnly)
+            return;
+        const newChecked = !this.#isChecked;
+        if (this.checked === undefined) {
+            this.#internalChecked = newChecked;
+        }
+        this.#fieldCtx?.markDirty();
+        this.#fieldCtx?.markTouched();
+        this.dispatchEvent(checkedChangeEvent({ checked: newChecked }));
+    };
+    #handleKeyDown = (e) => {
+        if (e.key === " " || e.key === "Enter") {
+            e.preventDefault();
+            this.#handleClick();
+        }
+    };
+    render() {
+        const isChecked = this.#isChecked;
+        const isDisabled = this.#isDisabled;
+        const isInvalid = this.#isInvalid;
+        const controlId = this.#fieldCtx?.controlId ?? "";
+        return html `
+      <span
+        part="root"
+        role="switch"
+        id="${controlId || nothing}"
+        aria-checked="${String(isChecked)}"
+        aria-disabled="${isDisabled ? "true" : nothing}"
+        aria-readonly="${this.readOnly ? "true" : nothing}"
+        aria-required="${this.required ? "true" : nothing}"
+        aria-invalid="${isInvalid ? "true" : nothing}"
+        tabindex="${isDisabled ? nothing : "0"}"
+        ?data-checked="${isChecked}"
+        ?data-unchecked="${!isChecked}"
+        ?data-disabled="${isDisabled}"
+        ?data-readonly="${this.readOnly}"
+        ?data-required="${this.required}"
+        ?data-invalid="${isInvalid}"
+        @keydown="${this.#handleKeyDown}"
+      >
+        <span part="thumb"></span>
+        <input
+          type="checkbox"
+          name="${this.name ?? nothing}"
+          value="${isChecked ? this.value : this.uncheckedValue}"
+          .checked="${isChecked}"
+          ?disabled="${isDisabled}"
+          ?required="${this.required}"
+          class="HiddenInput"
+          aria-hidden="true"
+          tabindex="-1"
+        />
+      </span>
+      <slot></slot>
+    `;
+    }
+}
+__decorate([
+    property({ type: Boolean, reflect: true })
+], DuiSwitch.prototype, "checked", null);
+__decorate([
+    property({ type: Boolean, attribute: "default-checked" })
+], DuiSwitch.prototype, "defaultChecked", null);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], DuiSwitch.prototype, "disabled", null);
+__decorate([
+    property({ type: Boolean, reflect: true, attribute: "read-only" })
+], DuiSwitch.prototype, "readOnly", null);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], DuiSwitch.prototype, "required", null);
+__decorate([
+    property()
+], DuiSwitch.prototype, "name", null);
+__decorate([
+    property()
+], DuiSwitch.prototype, "value", null);
+__decorate([
+    property({ attribute: "unchecked-value" })
+], DuiSwitch.prototype, "uncheckedValue", null);

package/tabs/index.d.ts

@@ -0,0 +1,6 @@
+export { DuiTabs, valueChangeEvent } from "./tabs.js";
+export { DuiTabsList } from "./tabs-list.js";
+export { DuiTab } from "./tab.js";
+export { DuiTabsPanel } from "./tabs-panel.js";
+export { DuiTabsIndicator } from "./tabs-indicator.js";
+export type { TabsContext } from "./tabs-context.js";