kr-elements 0.0.1-alpha.1

package/dist/esm/HTML.combobox.element.js

@@ -0,0 +1,313 @@
+import { ComboboxMarkup } from './Combobox.markup.js';
+import { HTMLComboboxOptionElement } from './HTML.combobox.option.element.js';
+import { toBoolean } from './Boolean.attribute.value.normalizer.js';
+export class HTMLComboboxElement extends HTMLElement {
+    static stringAttributes = new Set(['value', 'placeholder', 'query']);
+    static booleanAttributes = new Set(['required', 'disabled', 'clearable', 'multiple', 'filterable', 'searchable']);
+    static observerOptions = { childList: true, attributes: false, subtree: false };
+    static styleSheet = [new CSSStyleSheet];
+    static formAssociated = true;
+    internals;
+    shadowRoot;
+    #observer;
+    #markup;
+    #values = new Set;
+    constructor() {
+        super();
+        this.internals = this.attachInternals();
+        this.internals.role = "combobox";
+        this.shadowRoot = this.attachShadow({ mode: 'closed', delegatesFocus: true });
+        this.#markup = new ComboboxMarkup(this.shadowRoot, this.internals);
+        this.shadowRoot.innerHTML = ComboboxMarkup.template;
+        this.shadowRoot.adoptedStyleSheets = HTMLComboboxElement.styleSheet;
+        this.#observer = new MutationObserver(this.#onOptionsChanges);
+    }
+    connectedCallback() {
+        this.#markup.connect();
+        this.#initialAttributesSynchronization();
+        this.#onOptionsChanges([{ addedNodes: Array.from(this.children) }]);
+        this.#observer.observe(this, HTMLComboboxElement.observerOptions);
+        this.#markup.clearAllButton.addEventListener('click', this.#onClickClearAllButton);
+        this.#markup.searchInput.addEventListener('input', this.#onInput);
+    }
+    disconnectedCallback() {
+        this.#observer.disconnect();
+        this.#markup.disconnect();
+    }
+    formResetCallback() {
+        this.#values = new Set;
+        this.selectedOptions.forEach(option => option.removeAttribute('selected'));
+        this.#markup.tagsContainer.replaceChildren();
+        this.#setValidityAndFormValue();
+        this.dispatchEvent(new Event('change'));
+    }
+    formDisabledCallback(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    get valueAsArray() {
+        return Array.from(this.#values);
+    }
+    get selectedOptions() {
+        return this.#markup.selectedOptions;
+    }
+    get validity() {
+        return this.internals.validity;
+    }
+    get willValidate() {
+        return this.internals.willValidate;
+    }
+    get value() {
+        return this.valueAsArray.join(',');
+    }
+    set value(value) {
+        if (this.value === value || typeof value !== 'string')
+            return;
+        const prevValue = new Set(this.#values);
+        this.#values = new Set;
+        const values = value.split(',').filter(Boolean);
+        Promise.resolve(values)
+            .then(values => {
+            if (values.length) {
+                if (!this.multiple) {
+                    if (this.#values.size === 0) {
+                        values.length = 1;
+                    }
+                    else {
+                        values.length = 0;
+                    }
+                }
+                for (const key of values) {
+                    const option = this.#markup.getOptionByValue(key);
+                    if (option)
+                        this.#selectOption(option);
+                }
+            }
+            for (const key of prevValue) {
+                if (this.#values.has(key))
+                    continue;
+                const option = this.#markup.getOptionByValue(key);
+                const tag = this.#markup.getTagByValue(key);
+                tag?.remove();
+                option?.toggleAttribute('selected', false);
+            }
+        });
+    }
+    get query() {
+        return this.#markup.searchInput.value;
+    }
+    set query(value) {
+        if (value === this.query)
+            return;
+        this.#markup.searchInput.value = value;
+        super.setAttribute('query', value);
+    }
+    get clearable() {
+        return this.hasAttribute('clearable');
+    }
+    set clearable(value) {
+        super.toggleAttribute('clearable', value);
+    }
+    get multiple() {
+        return this.hasAttribute('multiple');
+    }
+    set multiple(value) {
+        super.toggleAttribute('multiple', value);
+    }
+    get filterable() {
+        return this.hasAttribute('filterable');
+    }
+    set filterable(value) {
+        super.toggleAttribute('filterable', value);
+    }
+    get searchable() {
+        return this.hasAttribute('searchable');
+    }
+    set searchable(value) {
+        super.toggleAttribute('searchable', value);
+    }
+    get disabled() {
+        return this.hasAttribute('disabled');
+    }
+    set disabled(value) {
+        this.internals.ariaDisabled = String(value);
+        super.toggleAttribute('disabled', value);
+    }
+    get required() {
+        return this.hasAttribute('required');
+    }
+    set required(value) {
+        this.internals.ariaRequired = String(value);
+        super.toggleAttribute('required', value);
+    }
+    get placeholder() {
+        return this.#markup.searchInput.placeholder;
+    }
+    set placeholder(value) {
+        this.#markup.placeholder.innerText = value;
+        this.#markup.searchInput.placeholder = value;
+        super.setAttribute('placeholder', value);
+    }
+    setAttribute(name, value) {
+        if (HTMLComboboxElement.booleanAttributes.has(name)) {
+            Reflect.set(this, name, toBoolean(value));
+            return;
+        }
+        if (HTMLComboboxElement.stringAttributes.has(name)) {
+            Reflect.set(this, name, value);
+            return;
+        }
+        super.setAttribute(name, value);
+    }
+    removeAttribute(name) {
+        if (HTMLComboboxElement.booleanAttributes.has(name)) {
+            Reflect.set(this, name, false);
+            return;
+        }
+        if (HTMLComboboxElement.stringAttributes.has(name)) {
+            return;
+        }
+        super.removeAttribute(name);
+    }
+    reportValidity() {
+        this.internals.reportValidity();
+    }
+    checkValidity() {
+        this.internals.checkValidity();
+    }
+    setCustomValidity(message) {
+        if (message === '') {
+            this.internals.setValidity({});
+        }
+        else {
+            this.internals.setValidity({ customError: true }, message);
+        }
+    }
+    #onInput = (event) => {
+        if (this.filterable) {
+            if (event.target && event.target instanceof HTMLInputElement) {
+                this.#markup.sort(event.target.value);
+            }
+        }
+    };
+    #onOptionsChanges = (records) => {
+        records.forEach(record => {
+            record.addedNodes.forEach(node => {
+                if (node instanceof HTMLComboboxOptionElement) {
+                    node.addEventListener('click', this.#onSelectOption);
+                    if (node.selected) {
+                        if (this.multiple) {
+                            this.#selectOption(node);
+                        }
+                        else if (this.#values.size === 0) {
+                            this.#selectOption(node);
+                        }
+                    }
+                }
+                if (node instanceof HTMLComboboxOptionElement || node instanceof HTMLOptGroupElement) {
+                    this.#markup.optionsContainer.append(node);
+                }
+            });
+        });
+        this.#setValidityAndFormValue();
+    };
+    #selectOption(option) {
+        if (this.#values.has(option.value))
+            return;
+        const value = option.value;
+        this.#values.add(value);
+        option.toggleAttribute('selected', true);
+        const control = this.#markup.createAndAppendTag(option);
+        control.addEventListener('click', this.#onClickTagClearButton);
+    }
+    #onSelectOption = (event) => {
+        let option;
+        if (event.target instanceof HTMLComboboxOptionElement) {
+            option = event.target;
+        }
+        else {
+            option = event.composedPath()
+                .find(el => el instanceof HTMLComboboxOptionElement);
+        }
+        if (option) {
+            if (this.#values.has(option.value))
+                return;
+            if (!this.multiple) {
+                this.#values.forEach(value => {
+                    this.#markup.getTagByValue(value)?.remove();
+                    this.#markup.getOptionByValue(value)?.toggleAttribute('selected', false);
+                });
+                this.#values.clear();
+                this.#markup.tagsContainer.replaceChildren();
+            }
+            this.#selectOption(option);
+            this.#setValidityAndFormValue();
+            this.dispatchEvent(new Event('change'));
+        }
+    };
+    #onClickTagClearButton = (event) => {
+        if (event.target && event.target instanceof HTMLButtonElement) {
+            const value = event.target.value;
+            const option = this.#markup.getOptionByValue(value);
+            const tag = this.#markup.getTagByValue(value);
+            option.removeAttribute('selected');
+            this.#values.delete(event.target.value);
+            tag.remove();
+            this.#setValidityAndFormValue();
+            this.dispatchEvent(new Event('change'));
+        }
+    };
+    #onClickClearAllButton = () => {
+        this.formResetCallback();
+    };
+    #setValidityAndFormValue() {
+        this.internals.setFormValue(this.value);
+        if (this.required && this.value === '') {
+            this.internals.setValidity({ valueMissing: true });
+        }
+        else {
+            this.internals.setValidity({});
+        }
+    }
+    #initialAttributesSynchronization() {
+        for (const key of HTMLComboboxElement.booleanAttributes) {
+            const value = toBoolean(this.getAttribute(key));
+            Reflect.set(this, key, value);
+        }
+        for (const key of HTMLComboboxElement.stringAttributes) {
+            if (this.hasAttribute(key)) {
+                Reflect.set(this, key, this.getAttribute(key));
+            }
+        }
+    }
+    static staticLoadCssByUrls(urls) {
+    }
+    static loadCssFromDocumentStyleSheets() {
+        if (document.readyState === 'complete') {
+            HTMLComboboxElement.#loadDocumentStyleSheets();
+        }
+        if (document.readyState === 'loading') {
+            document.addEventListener('DOMContentLoaded', HTMLComboboxElement.#loadDocumentStyleSheets);
+        }
+        if (document.readyState === 'interactive') {
+            queueMicrotask(HTMLComboboxElement.#loadDocumentStyleSheets);
+        }
+    }
+    static #loadDocumentStyleSheets() {
+        const [innerSheet] = HTMLComboboxElement.styleSheet;
+        for (const outerSheet of document.styleSheets) {
+            for (const rule of outerSheet.cssRules) {
+                innerSheet.insertRule(rule.cssText, innerSheet.cssRules.length);
+            }
+        }
+    }
+}
+document.addEventListener('keypress', (event) => {
+    if (document.activeElement instanceof HTMLComboboxElement) {
+        if (document.activeElement.shadowRoot.activeElement instanceof HTMLComboboxOptionElement) {
+            document.activeElement.shadowRoot.activeElement.click();
+        }
+    }
+});
+if (!window.customElements.get('combo-box')) {
+    window.customElements.define('combo-box', HTMLComboboxElement);
+}

package/dist/esm/HTML.combobox.option.element.js

@@ -0,0 +1,91 @@
+import { toBoolean } from './Boolean.attribute.value.normalizer.js';
+export class HTMLComboboxOptionElement extends HTMLElement {
+    static booleanAttributes = new Set(['selected']);
+    static stringAttributes = new Set(['value', 'label']);
+    connectedCallback() {
+        this.#initialAttributesSynchronization();
+        super.setAttribute('part', 'box-option');
+        super.setAttribute('tabindex', "0");
+        super.setAttribute('role', "option");
+        if (this.children.length === 0) {
+            this.textContent = this.label;
+        }
+    }
+    get value() {
+        return this.getAttribute('value');
+    }
+    set value(value) {
+        value = this.#getOrExtractValue(value, 'value');
+        super.setAttribute('value', value);
+    }
+    get label() {
+        return this.getAttribute('value');
+    }
+    set label(value) {
+        value = this.#getOrExtractValue(value, 'label');
+        super.setAttribute('label', value);
+    }
+    get selected() {
+        return this.hasAttribute('selected');
+    }
+    set selected(value) {
+        super.toggleAttribute('selected', toBoolean(value));
+    }
+    #initialAttributesSynchronization() {
+        for (const key of HTMLComboboxOptionElement.booleanAttributes) {
+            const value = toBoolean(this.getAttribute(key));
+            Reflect.set(this, key, value);
+        }
+        for (const key of HTMLComboboxOptionElement.stringAttributes) {
+            Reflect.set(this, key, this.getAttribute(key));
+        }
+    }
+    get #optionHasOnlyTextNode() {
+        return this.children.length === 0 && this.textContent.length > 0;
+    }
+    #getOrExtractValue(value, name) {
+        if (typeof value === 'string')
+            return value;
+        if (value == null) {
+            const opposite = name === 'label' ? 'value' : 'label';
+            const oppositeValue = this.getAttribute(opposite);
+            if (oppositeValue) {
+                value = oppositeValue;
+            }
+            else {
+                if (this.#optionHasOnlyTextNode) {
+                    value = this.textContent;
+                }
+                else {
+                    throw new TypeError('No value, or label or textContent found');
+                }
+            }
+            return value;
+        }
+        throw new TypeError('Invalid value');
+    }
+    setAttribute(name, value) {
+        if (HTMLComboboxOptionElement.booleanAttributes.has(name)) {
+            Reflect.set(this, name, toBoolean(value));
+            return;
+        }
+        if (HTMLComboboxOptionElement.stringAttributes.has(name)) {
+            Reflect.set(this, name, value);
+            return;
+        }
+        super.setAttribute(name, value);
+    }
+    removeAttribute(name) {
+        if (HTMLComboboxOptionElement.stringAttributes.has(name)) {
+            Reflect.set(this, name, false);
+            return;
+        }
+        if (HTMLComboboxOptionElement.stringAttributes.has(name)) {
+            return;
+        }
+        super.removeAttribute(name);
+    }
+}
+if (!window.customElements.get('box-option')) {
+    window.customElements.define('box-option', HTMLComboboxOptionElement);
+}

package/dist/esm/HTML.combobox.tag.element.js

@@ -0,0 +1,18 @@
+export class HTMLComboboxTagElement extends HTMLElement {
+    connectedCallback() {
+        this.part.add('box-tag');
+        if (this.parentElement) {
+            if (this.parentElement.hasAttribute('multiple')) {
+                if (!this.querySelector('[part="tag-clear-button"]')) {
+                    throw new Error(`A <button> with part="tag-clear-button" is required for <combo-box> with multiple attribute`);
+                }
+            }
+            if (!this.querySelector('[part="tag-label"]')) {
+                throw new Error(`Invalid <box-tag-template>, an element with part="tag-label" is required as a descendant`);
+            }
+        }
+    }
+}
+if (!window.customElements.get('box-tag')) {
+    window.customElements.define('box-tag', HTMLComboboxTagElement);
+}

package/dist/esm/index.js

@@ -0,0 +1 @@
+export * from './HTML.combobox.element.js';

package/dist/types/Boolean.attribute.value.normalizer.d.ts

@@ -0,0 +1,2 @@
+export declare function toBoolean(value: any): boolean;
+//# sourceMappingURL=Boolean.attribute.value.normalizer.d.ts.map

package/dist/types/Boolean.attribute.value.normalizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Boolean.attribute.value.normalizer.d.ts","sourceRoot":"","sources":["../../src/combobox/Boolean.attribute.value.normalizer.ts"],"names":[],"mappings":"AACA,wBAAgB,SAAS,CAAC,KAAK,EAAE,GAAG,WAInC"}

package/dist/types/Combobox.markup.d.ts

@@ -0,0 +1,26 @@
+import { HTMLComboboxTagElement } from './HTML.combobox.tag.element.js';
+import { HTMLComboboxOptionElement } from './HTML.combobox.option.element.js';
+export declare class ComboboxMarkup {
+    #private;
+    tagsContainer: HTMLDivElement | null;
+    optionsContainer: HTMLDivElement | null;
+    clearAllButton: HTMLButtonElement | null;
+    dropdown: HTMLDivElement | null;
+    placeholder: HTMLDivElement | null;
+    searchInput: HTMLInputElement | null;
+    constructor(shadowRoot: ShadowRoot, internals: ElementInternals);
+    connect(): void;
+    sort(query: string): void;
+    disconnect(): void;
+    onPageScroll: () => void;
+    setDropdownPosition(rect: DOMRect): void;
+    showDropdown: () => void;
+    hideDropdown: (event: Event) => void;
+    createAndAppendTag(option: HTMLComboboxOptionElement): HTMLButtonElement;
+    getTagByValue(value: string): HTMLComboboxTagElement;
+    getOptionByValue(value: string): HTMLComboboxOptionElement;
+    get tagTemplate(): HTMLComboboxTagElement;
+    get selectedOptions(): NodeListOf<HTMLComboboxOptionElement>;
+    static get template(): string;
+}
+//# sourceMappingURL=Combobox.markup.d.ts.map

package/dist/types/Combobox.markup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Combobox.markup.d.ts","sourceRoot":"","sources":["../../src/combobox/Combobox.markup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AACxE,OAAO,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAE9E,qBAAa,cAAc;;IAGzB,aAAa,EAAE,cAAc,GAAG,IAAI,CAAQ;IAC5C,gBAAgB,EAAE,cAAc,GAAG,IAAI,CAAQ;IAC/C,cAAc,EAAE,iBAAiB,GAAG,IAAI,CAAQ;IAChD,QAAQ,EAAE,cAAc,GAAG,IAAI,CAAQ;IACvC,WAAW,EAAE,cAAc,GAAG,IAAI,CAAQ;IAC1C,WAAW,EAAE,gBAAgB,GAAG,IAAI,CAAQ;gBAEhC,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,gBAAgB;IAU/D,OAAO;IASP,IAAI,CAAC,KAAK,EAAE,MAAM;IAiBlB,UAAU;IAQV,YAAY,aAIX;IAED,mBAAmB,CAAC,IAAI,EAAE,OAAO;IAmBjC,YAAY,aAUX;IAED,YAAY,UAAW,KAAK,UAU3B;IAED,kBAAkB,CAAC,MAAM,EAAE,yBAAyB;IAqBpD,aAAa,CAAC,KAAK,EAAE,MAAM;IAI3B,gBAAgB,CAAC,KAAK,EAAE,MAAM;IAI9B,IAAI,WAAW,2BAQd;IAGD,IAAI,eAAe,0CAGlB;IAED,MAAM,KAAK,QAAQ,WAgLlB;CACF"}

package/dist/types/HTML.combobox.element.d.ts

@@ -0,0 +1,50 @@
+import { HTMLComboboxOptionElement } from './HTML.combobox.option.element.js';
+export declare class HTMLComboboxElement extends HTMLElement {
+    #private;
+    static stringAttributes: Set<string>;
+    static booleanAttributes: Set<string>;
+    static observerOptions: {
+        childList: boolean;
+        attributes: boolean;
+        subtree: boolean;
+    };
+    static styleSheet: CSSStyleSheet[];
+    static formAssociated: boolean;
+    internals: ElementInternals;
+    shadowRoot: ShadowRoot;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    formResetCallback(): void;
+    formDisabledCallback(isDisabled: boolean): void;
+    get valueAsArray(): string[];
+    get selectedOptions(): NodeListOf<HTMLComboboxOptionElement>;
+    get validity(): ValidityState;
+    get willValidate(): boolean;
+    get value(): string;
+    set value(value: string);
+    get query(): string;
+    set query(value: string);
+    get clearable(): boolean;
+    set clearable(value: boolean);
+    get multiple(): boolean;
+    set multiple(value: boolean);
+    get filterable(): boolean;
+    set filterable(value: boolean);
+    get searchable(): boolean;
+    set searchable(value: boolean);
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    get required(): boolean;
+    set required(value: boolean);
+    get placeholder(): string;
+    set placeholder(value: string);
+    setAttribute(name: string, value: any): void;
+    removeAttribute(name: string): void;
+    reportValidity(): void;
+    checkValidity(): void;
+    setCustomValidity(message: string): void;
+    static staticLoadCssByUrls(urls: string[]): void;
+    static loadCssFromDocumentStyleSheets(): void;
+}
+//# sourceMappingURL=HTML.combobox.element.d.ts.map

package/dist/types/HTML.combobox.element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HTML.combobox.element.d.ts","sourceRoot":"","sources":["../../src/combobox/HTML.combobox.element.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAG9E,qBAAa,mBAAoB,SAAQ,WAAW;;IAClD,MAAM,CAAC,gBAAgB,cAAgD;IACvE,MAAM,CAAC,iBAAiB,cAA4F;IACpH,MAAM,CAAC,eAAe;;;;MAA0D;IAChF,MAAM,CAAC,UAAU,kBAAuB;IACxC,MAAM,CAAC,cAAc,UAAQ;IAE7B,SAAS,EAAE,gBAAgB,CAAC;IAC5B,UAAU,EAAE,UAAU,CAAC;;IAkBvB,iBAAiB;IASjB,oBAAoB;IAKpB,iBAAiB;IAQjB,oBAAoB,CAAC,UAAU,EAAE,OAAO;IAMxC,IAAI,YAAY,aAEf;IACD,IAAI,eAAe,0CAElB;IACD,IAAI,QAAQ,kBAEX;IACD,IAAI,YAAY,YAEf;IAGD,IAAI,KAAK,IAGQ,MAAM,CADtB;IACD,IAAI,KAAK,CAAC,KAAK,EAAE,MAAM,EAgCtB;IAED,IAAI,KAAK,IAGQ,MAAM,CADtB;IACD,IAAI,KAAK,CAAC,KAAK,EAAE,MAAM,EAItB;IAED,IAAI,SAAS,YAEZ;IACD,IAAI,SAAS,CAAC,KAAK,SAAA,EAElB;IAED,IAAI,QAAQ,YAEX;IACD,IAAI,QAAQ,CAAC,KAAK,SAAA,EAEjB;IAED,IAAI,UAAU,YAEb;IACD,IAAI,UAAU,CAAC,KAAK,SAAA,EAEnB;IAED,IAAI,UAAU,YAEb;IACD,IAAI,UAAU,CAAC,KAAK,SAAA,EAEnB;IAED,IAAI,QAAQ,YAEX;IACD,IAAI,QAAQ,CAAC,KAAK,SAAA,EAGjB;IAED,IAAI,QAAQ,YAEX;IACD,IAAI,QAAQ,CAAC,KAAK,SAAA,EAGjB;IAED,IAAI,WAAW,WAEd;IACD,IAAI,WAAW,CAAC,KAAK,QAAA,EAIpB;IAID,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG;IAYrC,eAAe,CAAC,IAAI,EAAE,MAAM;IAW5B,cAAc;IAId,aAAa;IAIb,iBAAiB,CAAC,OAAO,EAAE,MAAM;IAgHjC,MAAM,CAAC,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE;IAIzC,MAAM,CAAC,8BAA8B;CAoBtC"}

package/dist/types/HTML.combobox.option.element.d.ts

@@ -0,0 +1,15 @@
+export declare class HTMLComboboxOptionElement extends HTMLElement {
+    #private;
+    static booleanAttributes: Set<string>;
+    static stringAttributes: Set<string>;
+    connectedCallback(): void;
+    get value(): string;
+    set value(value: string);
+    get label(): string;
+    set label(value: string);
+    get selected(): boolean;
+    set selected(value: boolean);
+    setAttribute(name: string, value: string): void;
+    removeAttribute(name: string): void;
+}
+//# sourceMappingURL=HTML.combobox.option.element.d.ts.map

package/dist/types/HTML.combobox.option.element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HTML.combobox.option.element.d.ts","sourceRoot":"","sources":["../../src/combobox/HTML.combobox.option.element.ts"],"names":[],"mappings":"AAEA,qBAAa,yBAA0B,SAAQ,WAAW;;IACxD,MAAM,CAAC,iBAAiB,cAAyB;IACjD,MAAM,CAAC,gBAAgB,cAA+B;IAEtD,iBAAiB;IAUjB,IAAI,KAAK,WAER;IACD,IAAI,KAAK,CAAC,KAAK,QAAA,EAGd;IAED,IAAI,KAAK,WAER;IACD,IAAI,KAAK,CAAC,KAAK,QAAA,EAGd;IAED,IAAI,QAAQ,YAEX;IACD,IAAI,QAAQ,CAAC,KAAK,SAAA,EAEjB;IAoCD,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAYxC,eAAe,CAAC,IAAI,EAAE,MAAM;CAU7B"}

package/dist/types/HTML.combobox.tag.element.d.ts

@@ -0,0 +1,4 @@
+export declare class HTMLComboboxTagElement extends HTMLElement {
+    connectedCallback(): void;
+}
+//# sourceMappingURL=HTML.combobox.tag.element.d.ts.map

package/dist/types/HTML.combobox.tag.element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HTML.combobox.tag.element.d.ts","sourceRoot":"","sources":["../../src/combobox/HTML.combobox.tag.element.ts"],"names":[],"mappings":"AAAA,qBAAa,sBAAuB,SAAQ,WAAW;IACrD,iBAAiB;CAalB"}

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './HTML.combobox.element.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/combobox/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC"}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "kr-elements",
+  "version": "0.0.1-alpha.1",
+  "description": "Custom elements",
+  "type": "module",
+  "scripts": {
+    "prepare": "husky",
+    "clean": "rm -rf dist",
+    "build:combobox": "tsc -b configs/tsconfig.cjs.json configs/tsconfig.esm.json configs/tsconfig.types.json",
+    "generate": "node --import tsx ./scripts/genPackageFiles.ts",
+    "build": "npm-run-all clean build:combobox generate",
+    "check-types": "tsc --noEmit"
+  },
+  "keywords": [
+    "web-components",
+    "custom elements"
+  ],
+  "author": "Roman Konstantin",
+  "license": "MIT",
+  "devDependencies": {
+    "@espcom/eslint-config": "latest",
+    "@types/node": "22.8.6",
+    "c8": "10.1.2",
+    "esbuild": "0.25.5",
+    "husky": "9.1.5",
+    "lint-staged": "15.2.9",
+    "npm-run-all": "^4.1.5",
+    "tsx": "^4.19.2",
+    "typescript": "latest",
+    "xml-splitter": "1.2.1"
+  },
+  "sideEffect": false,
+  "exports": {
+    "./combobox": {
+      "types": "./dist/types/combobox/index.d.ts",
+      "require": "./dist/cjs/combobox/index.js",
+      "import": "./dist/esm/combobox/index.js"
+    }
+  },
+  "main": "dist/cjs/combobox/index.js",
+  "module": "dist/esm/combobox/index.js",
+  "types": "dist/types/combobox/index.d.ts",
+  "combobox": "dist/cjs/combobox/index.js"
+}