@santi020k/lumen-elements 3.0.1 → 4.1.0

package/dist/components/ai-surfaces.js

@@ -0,0 +1,270 @@
+import { bindLumenApprovalCard, createLumenPromptComposerController, normalizeLumenPromptLimit, resolveLumenCitationHref } from '@santi020k/lumen-core';
+import { LumenElement } from '../element-base.js';
+const node = (root, tag, className = '') => {
+    const element = root.ownerDocument.createElement(tag);
+    element.className = className;
+    return element;
+};
+const booleanAttribute = (root, name) => root.hasAttribute(name) && root.getAttribute(name) !== 'false';
+const approvalDisabled = (root) => booleanAttribute(root, 'disabled') || root.dataset.status !== 'pending' || !root.dataset.requestId;
+class LumenAiSurfaceElement extends LumenElement {
+    cleanup;
+    connectedCallback() {
+        super.connectedCallback();
+        queueMicrotask(() => {
+            if (this.isConnected)
+                this.render();
+        });
+    }
+    disconnectedCallback() {
+        this.cleanup?.();
+        this.cleanup = undefined;
+    }
+    attributeChangedCallback() {
+        super.attributeChangedCallback();
+        if (this.isConnected)
+            this.render();
+    }
+}
+export const lumenPromptComposerElementConfig = {
+    baseClassName: 'ui-prompt-composer',
+    defaults: { 'data-ui-prompt-composer': '' },
+    observedAttributes: ['action', 'disabled', 'label', 'max-length', 'pending', 'send-label', 'stop-label', 'submit-on-enter', 'value'],
+    tagName: 'lumen-prompt-composer'
+};
+export class LumenPromptComposerElement extends LumenAiSurfaceElement {
+    static config = lumenPromptComposerElementConfig;
+    form;
+    input;
+    label;
+    send;
+    stop;
+    get value() {
+        return this.input?.value ?? this.getAttribute('value') ?? '';
+    }
+    set value(value) {
+        this.setAttribute('value', value);
+    }
+    attributeChangedCallback(name) {
+        super.attributeChangedCallback();
+        if (name === 'value' && this.input) {
+            this.input.defaultValue = this.getAttribute('value') ?? '';
+            this.input.value = this.input.defaultValue;
+        }
+    }
+    render() {
+        if (!this.form)
+            this.create();
+        const elements = this.elements();
+        if (!elements)
+            return;
+        const { form, input, label, send, stop } = elements;
+        this.cleanup?.();
+        this.dataset.pending = String(booleanAttribute(this, 'pending'));
+        this.dataset.disabled = String(booleanAttribute(this, 'disabled'));
+        this.dataset.submitOnEnter = String(booleanAttribute(this, 'submit-on-enter'));
+        const action = this.getAttribute('action');
+        if (action !== null)
+            form.setAttribute('action', action);
+        else
+            form.removeAttribute('action');
+        input.maxLength = normalizeLumenPromptLimit(Number(this.getAttribute('max-length')));
+        label.textContent = this.getAttribute('label') ?? 'Message';
+        send.textContent = this.getAttribute('send-label') ?? 'Send';
+        stop.textContent = this.getAttribute('stop-label') ?? 'Stop';
+        const controller = createLumenPromptComposerController(this);
+        this.cleanup = () => {
+            controller.destroy();
+        };
+    }
+    elements() {
+        if (!this.form || !this.input || !this.label || !this.send || !this.stop)
+            return undefined;
+        return { form: this.form, input: this.input, label: this.label, send: this.send, stop: this.stop };
+    }
+    create() {
+        const children = [...this.childNodes];
+        this.form = node(this, 'form', 'ui-form');
+        this.form.method = 'post';
+        this.label = node(this, 'label', 'ui-label');
+        this.input = node(this, 'textarea', 'ui-textarea');
+        this.input.id = `prompt-${this.ownerDocument.defaultView?.crypto.randomUUID() ?? crypto.randomUUID()}`;
+        this.input.rows = 3;
+        this.input.defaultValue = this.getAttribute('value') ?? '';
+        this.input.required = true;
+        this.input.name = 'prompt';
+        this.input.dataset.uiPromptInput = '';
+        this.label.htmlFor = this.input.id;
+        this.send = node(this, 'button', 'ui-button');
+        this.send.type = 'submit';
+        this.send.dataset.uiPromptSend = '';
+        this.stop = node(this, 'button', 'ui-button ui-button--secondary');
+        this.stop.type = 'button';
+        this.stop.dataset.uiPromptStop = '';
+        const actions = node(this, 'div', 'ui-prompt-composer__actions');
+        actions.append(this.send, this.stop);
+        this.form.append(this.label, this.input, actions, ...children);
+        this.append(this.form);
+    }
+}
+export const lumenStreamMessageElementConfig = {
+    baseClassName: 'ui-stream-message ui-message ui-message--assistant',
+    observedAttributes: ['label', 'status', 'status-label', 'text'],
+    role: 'article',
+    tagName: 'lumen-stream-message'
+};
+export class LumenStreamMessageElement extends LumenAiSurfaceElement {
+    static config = lumenStreamMessageElementConfig;
+    content;
+    statusText;
+    get text() {
+        return this.content?.textContent ?? this.getAttribute('text') ?? '';
+    }
+    set text(value) {
+        this.setAttribute('text', value);
+    }
+    render() {
+        if (!this.content) {
+            const children = [...this.childNodes];
+            const actions = this.querySelector('[slot="actions"]');
+            const sources = this.querySelector('[slot="sources"]');
+            this.content = node(this, 'div', 'ui-prose');
+            this.content.dataset.uiStreamContent = '';
+            this.content.setAttribute('aria-live', 'off');
+            this.statusText = node(this, 'span');
+            this.statusText.setAttribute('role', 'status');
+            this.statusText.setAttribute('aria-live', 'polite');
+            const footer = node(this, 'div', 'ui-stream-message__actions');
+            footer.append(this.statusText);
+            if (actions)
+                footer.append(actions);
+            this.content.append(...children.filter(child => child !== actions && child !== sources));
+            this.append(this.content, footer);
+            if (sources)
+                this.append(sources);
+        }
+        this.dataset.status = this.getAttribute('status') ?? 'idle';
+        this.setAttribute('aria-label', this.getAttribute('label') ?? 'Assistant');
+        this.content.setAttribute('aria-busy', String(this.dataset.status === 'streaming'));
+        if (this.hasAttribute('text'))
+            this.content.textContent = this.getAttribute('text') ?? '';
+        if (this.statusText)
+            this.statusText.textContent = this.getAttribute('status-label') ?? 'Ready';
+    }
+}
+export const lumenSourceCitationElementConfig = {
+    baseClassName: 'ui-source-citation',
+    observedAttributes: ['href', 'label', 'target'],
+    tagName: 'lumen-source-citation'
+};
+export class LumenSourceCitationElement extends LumenAiSurfaceElement {
+    static config = lumenSourceCitationElementConfig;
+    render() {
+        const href = resolveLumenCitationHref(this.getAttribute('href') ?? '');
+        const label = this.getAttribute('label') ?? 'Source';
+        if (href) {
+            const anchor = node(this, 'a', 'ui-link');
+            anchor.href = href;
+            anchor.rel = 'noopener noreferrer';
+            anchor.target = this.getAttribute('target') === '_blank' ? '_blank' : '_self';
+            anchor.textContent = label;
+            this.replaceChildren(anchor);
+        }
+        else
+            this.textContent = label;
+    }
+}
+export const lumenToolActivityElementConfig = {
+    baseClassName: 'ui-tool-activity',
+    observedAttributes: ['label', 'open', 'status', 'status-label'],
+    tagName: 'lumen-tool-activity'
+};
+export class LumenToolActivityElement extends LumenAiSurfaceElement {
+    static config = lumenToolActivityElementConfig;
+    details;
+    summary;
+    statusText;
+    render() {
+        if (!this.details)
+            this.create();
+        if (!this.details || !this.summary || !this.statusText)
+            return;
+        this.details.open = this.hasAttribute('open');
+        this.summary.textContent = this.getAttribute('label') ?? 'Tool activity';
+        this.statusText.textContent = this.getAttribute('status-label') ?? 'Queued';
+        this.dataset.status = this.getAttribute('status') ?? 'queued';
+        this.cleanup?.();
+        const toggle = () => {
+            this.toggleAttribute('open', this.details?.open ?? false);
+        };
+        this.details.addEventListener('toggle', toggle);
+        this.cleanup = () => {
+            this.details?.removeEventListener('toggle', toggle);
+        };
+    }
+    create() {
+        const children = [...this.childNodes];
+        this.details = node(this, 'details', 'ui-collapsible');
+        this.summary = node(this, 'summary');
+        this.statusText = node(this, 'span');
+        this.statusText.setAttribute('role', 'status');
+        this.details.append(this.summary, this.statusText, ...children);
+        this.append(this.details);
+    }
+}
+const approvalStatusLabel = (root) => root.getAttribute('status-label') ?? `Decision: ${root.getAttribute('status') ?? 'pending'}`;
+export const lumenApprovalCardElementConfig = {
+    baseClassName: 'ui-approval-card ui-card',
+    defaults: { 'data-ui-approval-card': '' },
+    observedAttributes: ['approve-label', 'disabled', 'label', 'reject-label', 'request-id', 'status', 'status-label'],
+    role: 'group',
+    tagName: 'lumen-approval-card'
+};
+export class LumenApprovalCardElement extends LumenAiSurfaceElement {
+    static config = lumenApprovalCardElementConfig;
+    titleElement;
+    statusText;
+    approve;
+    reject;
+    render() {
+        if (!this.titleElement)
+            this.create();
+        const elements = this.elements();
+        if (!elements)
+            return;
+        const { title, statusText, approve, reject } = elements;
+        title.textContent = this.getAttribute('label') ?? 'Review action';
+        this.setAttribute('aria-label', title.textContent);
+        statusText.textContent = approvalStatusLabel(this);
+        this.dataset.requestId = this.getAttribute('request-id') ?? '';
+        this.dataset.status = this.getAttribute('status') ?? 'pending';
+        this.dataset.disabled = String(booleanAttribute(this, 'disabled'));
+        const disabled = approvalDisabled(this);
+        approve.disabled = disabled;
+        reject.disabled = disabled;
+        approve.textContent = this.getAttribute('approve-label') ?? 'Approve';
+        reject.textContent = this.getAttribute('reject-label') ?? 'Reject';
+        this.cleanup?.();
+        this.cleanup = bindLumenApprovalCard(this);
+    }
+    elements() {
+        if (!this.titleElement || !this.statusText || !this.approve || !this.reject)
+            return undefined;
+        return { title: this.titleElement, statusText: this.statusText, approve: this.approve, reject: this.reject };
+    }
+    create() {
+        const children = [...this.childNodes];
+        this.titleElement = node(this, 'strong');
+        this.statusText = node(this, 'span');
+        this.statusText.setAttribute('role', 'status');
+        this.approve = node(this, 'button', 'ui-button');
+        this.approve.type = 'button';
+        this.approve.dataset.uiApprovalResponse = 'approve';
+        this.reject = node(this, 'button', 'ui-button ui-button--secondary');
+        this.reject.type = 'button';
+        this.reject.dataset.uiApprovalResponse = 'reject';
+        const actions = node(this, 'div', 'ui-approval-card__actions');
+        actions.append(this.approve, this.reject);
+        this.append(this.titleElement, ...children, this.statusText, actions);
+    }
+}

package/dist/components/button.d.ts

@@ -1,4 +1,4 @@
-import { type LumenCustomElementRegistry } from '../element-base.js';
+import { type LumenCustomElementRegistry, LumenElement } from '../element-base.js';
 export declare const lumenButtonElementConfig: {
     readonly attributeClasses: {
         readonly variant: {
@@ -30,9 +30,62 @@ export declare const lumenButtonElementConfig: {
         readonly tabindex: "0";
         readonly variant: "default";
     };
+    readonly observedAttributes: readonly ["variant", "size", "disabled", "loading", "aria-busy", "aria-disabled"];
     readonly role: "button";
     readonly tagName: "lumen-button";
 };
-export declare const LumenButtonElement: import("../element-base.js").LumenElementConstructor;
+export declare class LumenButtonElement extends LumenElement {
+    static config: {
+        readonly attributeClasses: {
+            readonly variant: {
+                readonly default: "ui-button--default";
+                readonly destructive: "ui-button--destructive";
+                readonly ghost: "ui-button--ghost";
+                readonly link: "ui-button--link";
+                readonly outline: "ui-button--outline";
+                readonly secondary: "ui-button--secondary";
+            };
+            readonly size: {
+                readonly default: "ui-button--default-size";
+                readonly icon: "ui-button--icon";
+                readonly lg: "ui-button--lg";
+                readonly sm: "ui-button--sm";
+            };
+            readonly disabled: {
+                readonly true: "ui-button--disabled";
+            };
+            readonly loading: {
+                readonly true: "ui-button--loading";
+            };
+        };
+        readonly baseClassName: "ui-button";
+        readonly defaults: {
+            readonly 'data-slot': "button";
+            readonly role: "button";
+            readonly size: "default";
+            readonly tabindex: "0";
+            readonly variant: "default";
+        };
+        readonly observedAttributes: readonly ["variant", "size", "disabled", "loading", "aria-busy", "aria-disabled"];
+        readonly role: "button";
+        readonly tagName: "lumen-button";
+    };
+    private spacePressed;
+    private applyingSemantics;
+    private hasBlockingAttribute;
+    private isLoading;
+    private syncManagedSemantic;
+    private syncBusySemantics;
+    private syncDisabledSemantics;
+    private isBlocked;
+    private activateAfterDispatch;
+    private onKeyDown;
+    private onKeyUp;
+    private onBlur;
+    private onClick;
+    connectedCallback(): void;
+    attributeChangedCallback(name?: string, previousValue?: string | null, value?: string | null): void;
+    disconnectedCallback(): void;
+}
 export declare const defineLumenButton: (registry?: LumenCustomElementRegistry) => void;
 //# sourceMappingURL=button.d.ts.map

package/dist/components/button.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"button.d.ts","sourceRoot":"","sources":["../../src/components/button.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,0BAA0B,EAEhC,MAAM,oBAAoB,CAAA;AAE3B,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BE,CAAA;AAEvC,eAAO,MAAM,kBAAkB,sDAE9B,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,WAAW,0BAA0B,KACpC,IAEF,CAAA"}
+{"version":3,"file":"button.d.ts","sourceRoot":"","sources":["../../src/components/button.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,0BAA0B,EAC/B,YAAY,EAEb,MAAM,oBAAoB,CAAA;AAE3B,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BE,CAAA;AAEvC,qBAAa,kBAAmB,SAAQ,YAAY;IAClD,OAAgB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAA2B;IACjD,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,iBAAiB,CAAQ;IAEjC,OAAO,CAAC,oBAAoB;IAI5B,OAAO,CAAC,SAAS;IAKjB,OAAO,CAAC,mBAAmB;IA4B3B,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,qBAAqB;IAI7B,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,qBAAqB;IAM7B,OAAO,CAAC,SAAS,CAUhB;IAED,OAAO,CAAC,OAAO,CAQd;IAED,OAAO,CAAC,MAAM,CAEb;IAED,OAAO,CAAC,OAAO,CAMd;IAEQ,iBAAiB,IAAI,IAAI;IAgBzB,wBAAwB,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAgBnG,oBAAoB,IAAI,IAAI;CAatC;AAED,eAAO,MAAM,iBAAiB,GAC5B,WAAW,0BAA0B,KACpC,IAEF,CAAA"}

package/dist/components/button.js

@@ -1,4 +1,4 @@
-import { createLumenElementClass, defineLumenElement } from '../element-base.js';
+import { defineLumenElement, LumenElement } from '../element-base.js';
 export const lumenButtonElementConfig = {
     attributeClasses: {
         variant: {
@@ -26,10 +26,118 @@ export const lumenButtonElementConfig = {
         tabindex: '0',
         variant: 'default'
     },
+    observedAttributes: ['variant', 'size', 'disabled', 'loading', 'aria-busy', 'aria-disabled'],
     role: 'button',
     tagName: 'lumen-button'
 };
-export const LumenButtonElement = createLumenElementClass(lumenButtonElementConfig);
+export class LumenButtonElement extends LumenElement {
+    static config = lumenButtonElementConfig;
+    spacePressed = false;
+    applyingSemantics = false;
+    hasBlockingAttribute() {
+        return ['disabled', 'loading'].some(name => this.hasAttribute(name) && this.getAttribute(name) !== 'false');
+    }
+    isLoading() {
+        return this.hasAttribute('loading') && this.getAttribute('loading') !== 'false';
+    }
+    syncManagedSemantic(name, active) {
+        const ownership = `data-ui-button-${name}`;
+        const recorded = this.getAttribute(ownership);
+        this.applyingSemantics = true;
+        try {
+            if (active) {
+                if (recorded === null) {
+                    const original = this.getAttribute(name);
+                    this.setAttribute(ownership, original === null ? 'absent' : `value:${original}`);
+                }
+                this.setAttribute(name, 'true');
+            }
+            else if (recorded !== null) {
+                this.removeAttribute(ownership);
+                if (this.getAttribute(name) !== 'true')
+                    return;
+                if (recorded === 'absent')
+                    this.removeAttribute(name);
+                else if (recorded.startsWith('value:'))
+                    this.setAttribute(name, recorded.slice(6));
+            }
+        }
+        finally {
+            this.applyingSemantics = false;
+        }
+    }
+    syncBusySemantics() {
+        this.syncManagedSemantic('aria-busy', this.isLoading());
+    }
+    syncDisabledSemantics() {
+        this.syncManagedSemantic('aria-disabled', this.hasBlockingAttribute());
+    }
+    isBlocked() {
+        return this.hasBlockingAttribute() || this.getAttribute('aria-disabled') === 'true';
+    }
+    activateAfterDispatch(event) {
+        setTimeout(() => {
+            if (this.isConnected && !event.defaultPrevented && !this.isBlocked())
+                this.click();
+        }, 0);
+    }
+    onKeyDown = (event) => {
+        if (event.target !== this || event.defaultPrevented || event.repeat || event.isComposing || this.isBlocked())
+            return;
+        if (event.key === 'Enter')
+            this.activateAfterDispatch(event);
+        if (event.key === ' ') {
+            event.preventDefault();
+            this.spacePressed = true;
+        }
+    };
+    onKeyUp = (event) => {
+        if (event.key !== ' ')
+            return;
+        const spacePressed = this.spacePressed;
+        this.spacePressed = false;
+        if (event.target === this && spacePressed && !event.isComposing)
+            this.activateAfterDispatch(event);
+    };
+    onBlur = () => {
+        this.spacePressed = false;
+    };
+    onClick = (event) => {
+        if (!this.isBlocked())
+            return;
+        event.preventDefault();
+        event.stopImmediatePropagation();
+    };
+    connectedCallback() {
+        super.connectedCallback();
+        this.syncDisabledSemantics();
+        this.syncBusySemantics();
+        this.addEventListener('keydown', this.onKeyDown);
+        this.addEventListener('keyup', this.onKeyUp);
+        this.addEventListener('blur', this.onBlur);
+        this.addEventListener('click', this.onClick, true);
+    }
+    attributeChangedCallback(name, previousValue, value) {
+        super.attributeChangedCallback(name, previousValue, value);
+        if (this.applyingSemantics)
+            return;
+        if ((name === 'aria-busy' || name === 'aria-disabled') && previousValue !== null && previousValue !== undefined) {
+            this.removeAttribute(`data-ui-button-${name}`);
+        }
+        if (!this.isConnected)
+            return;
+        this.syncDisabledSemantics();
+        this.syncBusySemantics();
+    }
+    disconnectedCallback() {
+        this.spacePressed = false;
+        this.removeEventListener('keydown', this.onKeyDown);
+        this.removeEventListener('keyup', this.onKeyUp);
+        this.removeEventListener('blur', this.onBlur);
+        this.removeEventListener('click', this.onClick, true);
+        super.disconnectedCallback();
+    }
+}
 export const defineLumenButton = (registry) => {
     defineLumenElement(lumenButtonElementConfig, LumenButtonElement, registry);
 };

package/dist/components/card.d.ts

@@ -1,6 +1,11 @@
 import { type LumenCustomElementRegistry } from '../element-base.js';
 export declare const lumenCardElementConfig: {
     readonly attributeClasses: {
+        readonly density: {
+            readonly comfortable: "ui-card--comfortable";
+            readonly compact: "ui-card--compact";
+            readonly spacious: "ui-card--spacious";
+        };
         readonly glass: {
             readonly strong: "ui-card--glass ui-glass-strong";
             readonly subtle: "ui-card--glass ui-glass-subtle";
@@ -16,6 +21,7 @@ export declare const lumenCardElementConfig: {
     readonly baseClassName: "ui-card";
     readonly defaults: {
         readonly 'data-slot': "card";
+        readonly density: "comfortable";
         readonly variant: "default";
     };
     readonly tagName: "lumen-card";

package/dist/components/card.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"card.d.ts","sourceRoot":"","sources":["../../src/components/card.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,0BAA0B,EAEhC,MAAM,oBAAoB,CAAA;AAE3B,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;CAiBI,CAAA;AAEvC,eAAO,MAAM,gBAAgB,sDAE5B,CAAA;AAED,eAAO,MAAM,eAAe,GAC1B,WAAW,0BAA0B,KACpC,IAEF,CAAA"}
+{"version":3,"file":"card.d.ts","sourceRoot":"","sources":["../../src/components/card.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,0BAA0B,EAEhC,MAAM,oBAAoB,CAAA;AAE3B,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;CAsBI,CAAA;AAEvC,eAAO,MAAM,gBAAgB,sDAE5B,CAAA;AAED,eAAO,MAAM,eAAe,GAC1B,WAAW,0BAA0B,KACpC,IAEF,CAAA"}

package/dist/components/card.js

@@ -1,6 +1,11 @@
 import { createLumenElementClass, defineLumenElement } from '../element-base.js';
 export const lumenCardElementConfig = {
     attributeClasses: {
+        density: {
+            comfortable: 'ui-card--comfortable',
+            compact: 'ui-card--compact',
+            spacious: 'ui-card--spacious'
+        },
         glass: {
             strong: 'ui-card--glass ui-glass-strong',
             subtle: 'ui-card--glass ui-glass-subtle',
@@ -14,7 +19,7 @@ export const lumenCardElementConfig = {
         }
     },
     baseClassName: 'ui-card',
-    defaults: { 'data-slot': 'card', variant: 'default' },
+    defaults: { 'data-slot': 'card', density: 'comfortable', variant: 'default' },
     tagName: 'lumen-card'
 };
 export const LumenCardElement = createLumenElementClass(lumenCardElementConfig);

package/dist/components/combobox.d.ts

@@ -7,6 +7,7 @@ export declare const lumenComboboxElementConfig: {
     readonly tagName: "lumen-combobox";
 };
 export declare class LumenComboboxElement extends LumenElement {
+    #private;
     static config: {
         readonly baseClassName: "ui-combobox";
         readonly defaults: {
@@ -14,10 +15,8 @@ export declare class LumenComboboxElement extends LumenElement {
         };
         readonly tagName: "lumen-combobox";
     };
-    private abortController;
     connectedCallback(): void;
     disconnectedCallback(): void;
-    private setupCombobox;
 }
 export declare const defineLumenCombobox: (registry?: LumenCustomElementRegistry) => void;
 //# sourceMappingURL=combobox.d.ts.map

package/dist/components/combobox.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"combobox.d.ts","sourceRoot":"","sources":["../../src/components/combobox.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,0BAA0B,EAC/B,YAAY,EAEb,MAAM,oBAAoB,CAAA;AAE3B,eAAO,MAAM,0BAA0B;;;;;;CAIA,CAAA;AAyBvC,qBAAa,oBAAqB,SAAQ,YAAY;IACpD,OAAgB,MAAM;;;;;;MAA6B;IAEnD,OAAO,CAAC,eAAe,CAA6B;IAE3C,iBAAiB;IAYjB,oBAAoB;IAM7B,OAAO,CAAC,aAAa;CAmJtB;AAED,eAAO,MAAM,mBAAmB,GAC9B,WAAW,0BAA0B,KACpC,IAIF,CAAA"}
+{"version":3,"file":"combobox.d.ts","sourceRoot":"","sources":["../../src/components/combobox.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,0BAA0B,EAC/B,YAAY,EAEb,MAAM,oBAAoB,CAAA;AAE3B,eAAO,MAAM,0BAA0B;;;;;;CAIA,CAAA;AAEvC,qBAAa,oBAAqB,SAAQ,YAAY;;IACpD,OAAgB,MAAM;;;;;;MAA6B;IAsB1C,iBAAiB;IAcjB,oBAAoB;CAa9B;AAED,eAAO,MAAM,mBAAmB,GAC9B,WAAW,0BAA0B,KACpC,IAIF,CAAA"}