material 1.0.4 → 3.0.0-next.1

package/dist/components/chips/factories.d.ts

@@ -0,0 +1,9 @@
+import type { AssistChipConfig, FilterChipConfig, InputChipConfig, SuggestionChipConfig, ChipComponent } from "./types.js";
+/** Action chip; flat and outlined by default. */
+export declare const createAssistChip: (config: AssistChipConfig) => ChipComponent;
+/** Toggleable filter; selected chips show a checkmark. */
+export declare const createFilterChip: (config: FilterChipConfig) => ChipComponent;
+/** Selectable input token with an optional independent removal action. */
+export declare const createInputChip: (config: InputChipConfig) => ChipComponent;
+/** Suggested action; flat and outlined by default. */
+export declare const createSuggestionChip: (config: SuggestionChipConfig) => ChipComponent;

package/dist/components/chips/factories.js

@@ -0,0 +1,6 @@
+import createChip from "./chip/chip.js";
+const open = (config, type) => createChip({ ...config, type, onSelected: undefined });
+export const createAssistChip = (config) => open(config, "assist");
+export const createFilterChip = (config) => open(config, "filter");
+export const createInputChip = (config) => open(config, "input");
+export const createSuggestionChip = (config) => open(config, "suggestion");

package/dist/components/chips/features/chip-items.d.ts

@@ -0,0 +1,39 @@
+import { ChipsConfig, ChipComponent, ChipConfig } from "../types.js";
+/**
+ * Adds chip item management to chips component
+ *
+ * @param config Chips configuration
+ * @returns Component enhancer that adds chip items functionality
+ */
+/** What this feature reads off the component it is handed. */
+/**
+ * What this feature reads off the component it is handed.
+ *
+ * `element` is required, and not because this file touches it: an all-optional
+ * interface is a weak type, so nothing satisfies it unless it shares at least
+ * one property, and the pipe's component shared none. That is what made the
+ * stage reject its own input. withElement runs before this, so requiring it
+ * costs nothing and says what the pipe already guarantees.
+ */
+/**
+ * What `onCreated` reaches for through `this` when it runs.
+ *
+ * `chips` is installed by withController, which composes *after* this feature,
+ * so it is not on what this returns — but `onCreated` fires later still, by
+ * which time the finished component has it. The `?.` at the call site was
+ * already saying that; this says it to the checker.
+ */
+interface ChipItemsCaller {
+    chips?: {
+        addChip?: (chipConfig: ChipConfig) => unknown;
+    };
+}
+interface ChipItemsHost {
+    element: HTMLElement;
+    onCreated?: () => void;
+}
+export declare const withChipItems: (config: ChipsConfig) => <C extends ChipItemsHost>(component: C) => C & {
+    chipInstances: ChipComponent[];
+    onCreated(this: ChipItemsCaller): void;
+};
+export {};

package/dist/components/chips/features/chip-items.js

@@ -0,0 +1,17 @@
+export const withChipItems = (config) => (component) => {
+    const chipInstances = [];
+    return {
+        ...component,
+        chipInstances,
+        onCreated() {
+            if (typeof component.onCreated === "function") {
+                component.onCreated();
+            }
+            if (Array.isArray(config.chips) && config.chips.length > 0) {
+                config.chips.forEach((chipConfig) => {
+                    this.chips?.addChip?.(chipConfig);
+                });
+            }
+        },
+    };
+};

package/dist/components/chips/features/container.d.ts

@@ -0,0 +1,75 @@
+import { ChipsConfig } from "../types.js";
+/**
+ * Adds container layout features to chips component
+ *
+ * @param config Chips configuration
+ * @returns Component enhancer that adds container layout functionality
+ */
+/** What this feature reads off the component it is handed. */
+interface ContainerHost {
+    element: HTMLElement;
+    getClass: (name: string) => string;
+}
+export declare const withContainer: (config: ChipsConfig) => <C extends ContainerHost>(component: C) => C & {
+    layout: {
+        /**
+         * Sets the scrollable state of the chips container
+         * @param {boolean} isScrollable - Whether the chips container should be scrollable
+         * @returns Layout controller for chaining
+         */
+        setScrollable(isScrollable: boolean): {
+            setScrollable(isScrollable: boolean): /*elided*/ any;
+            /**
+             * Gets the scrollable state
+             * @returns {boolean} Whether the container is scrollable
+             */
+            isScrollable(): boolean;
+            /**
+             * Sets the vertical layout state
+             * @param {boolean} isVertical - Whether the chips container should be vertically stacked
+             * @returns Layout controller for chaining
+             */
+            setVertical(isVertical: boolean): /*elided*/ any;
+            /**
+             * Gets the vertical state
+             * @returns {boolean} Whether the container has vertical layout
+             */
+            isVertical(): boolean;
+        };
+        /**
+         * Gets the scrollable state
+         * @returns {boolean} Whether the container is scrollable
+         */
+        isScrollable(): boolean;
+        /**
+         * Sets the vertical layout state
+         * @param {boolean} isVertical - Whether the chips container should be vertically stacked
+         * @returns Layout controller for chaining
+         */
+        setVertical(isVertical: boolean): {
+            /**
+             * Sets the scrollable state of the chips container
+             * @param {boolean} isScrollable - Whether the chips container should be scrollable
+             * @returns Layout controller for chaining
+             */
+            setScrollable(isScrollable: boolean): /*elided*/ any;
+            /**
+             * Gets the scrollable state
+             * @returns {boolean} Whether the container is scrollable
+             */
+            isScrollable(): boolean;
+            setVertical(isVertical: boolean): /*elided*/ any;
+            /**
+             * Gets the vertical state
+             * @returns {boolean} Whether the container has vertical layout
+             */
+            isVertical(): boolean;
+        };
+        /**
+         * Gets the vertical state
+         * @returns {boolean} Whether the container has vertical layout
+         */
+        isVertical(): boolean;
+    };
+};
+export {};

package/dist/components/chips/features/container.js

@@ -0,0 +1,41 @@
+export const withContainer = (config) => (component) => {
+    const state = {
+        scrollable: config.scrollable === true,
+        vertical: config.vertical === true
+    };
+    return {
+        ...component,
+        layout: {
+            setScrollable(isScrollable) {
+                state.scrollable = isScrollable;
+                if (component.element) {
+                    if (isScrollable) {
+                        component.element.classList.add(`${component.getClass('chips')}--scrollable`);
+                    }
+                    else {
+                        component.element.classList.remove(`${component.getClass('chips')}--scrollable`);
+                    }
+                }
+                return this;
+            },
+            isScrollable() {
+                return state.scrollable;
+            },
+            setVertical(isVertical) {
+                state.vertical = isVertical;
+                if (component.element) {
+                    if (isVertical) {
+                        component.element.classList.add(`${component.getClass('chips')}--vertical`);
+                    }
+                    else {
+                        component.element.classList.remove(`${component.getClass('chips')}--vertical`);
+                    }
+                }
+                return this;
+            },
+            isVertical() {
+                return state.vertical;
+            }
+        }
+    };
+};

package/dist/components/chips/features/controller.d.ts

@@ -0,0 +1,61 @@
+import type { EventCallback } from "../../../core/state/emitter.js";
+import { ChipsConfig, ChipComponent, ChipConfig, ChipsFeatureComponent } from "../types.js";
+/**
+ * Add controller functionality to chips component
+ * Manages state, events, user interactions, and UI rendering
+ *
+ * @param config Chips configuration
+ * @returns Component enhancer with chips controller functionality
+ */
+export declare const withController: (config: ChipsConfig) => <C extends ChipsFeatureComponent>(component: C) => C & {
+    chips: {
+        addChip: (chipConfig: ChipConfig) => ChipComponent;
+        removeChip: (chipOrIndex: ChipComponent | number) => void;
+        getChips: () => ChipComponent[];
+        getSelectedChips: () => ChipComponent[];
+        getSelectedValues: () => (string | null)[];
+        selectByValue: (values: string | string[], triggerEvent?: boolean, exclusive?: boolean) => void;
+        clearSelection: (triggerEvent?: boolean) => void;
+        scrollToChip: (chipOrIndex: ChipComponent | number) => void;
+    };
+    keyboard: {
+        enable: () => void;
+        disable: () => void;
+    };
+    on(event: string, handler: EventCallback): C & {
+        chips: {
+            addChip: (chipConfig: ChipConfig) => ChipComponent;
+            removeChip: (chipOrIndex: ChipComponent | number) => void;
+            getChips: () => ChipComponent[];
+            getSelectedChips: () => ChipComponent[];
+            getSelectedValues: () => (string | null)[];
+            selectByValue: (values: string | string[], triggerEvent?: boolean, exclusive?: boolean) => void;
+            clearSelection: (triggerEvent?: boolean) => void;
+            scrollToChip: (chipOrIndex: ChipComponent | number) => void;
+        };
+        keyboard: {
+            enable: () => void;
+            disable: () => void;
+        };
+        on(event: string, handler: EventCallback): C & /*elided*/ any;
+        off(event: string, handler: EventCallback): C & /*elided*/ any;
+    };
+    off(event: string, handler: EventCallback): C & {
+        chips: {
+            addChip: (chipConfig: ChipConfig) => ChipComponent;
+            removeChip: (chipOrIndex: ChipComponent | number) => void;
+            getChips: () => ChipComponent[];
+            getSelectedChips: () => ChipComponent[];
+            getSelectedValues: () => (string | null)[];
+            selectByValue: (values: string | string[], triggerEvent?: boolean, exclusive?: boolean) => void;
+            clearSelection: (triggerEvent?: boolean) => void;
+            scrollToChip: (chipOrIndex: ChipComponent | number) => void;
+        };
+        keyboard: {
+            enable: () => void;
+            disable: () => void;
+        };
+        on(event: string, handler: EventCallback): C & /*elided*/ any;
+        off(event: string, handler: EventCallback): C & /*elided*/ any;
+    };
+};

package/dist/components/chips/features/controller.js

@@ -0,0 +1,323 @@
+import { getCleanup } from "../../../core/compose/cleanup.js";
+import createChip from "../chip/chip.js";
+import { CHIPS_EVENTS } from "../constants.js";
+import { activeElementOf } from "../../../core/dom/focus.js";
+export const withController = (config) => (component) => {
+    const eventListeners = {
+        change: [],
+        add: [],
+        remove: [],
+    };
+    let focusedChipIndex = -1;
+    let keyboardEnabled = true;
+    const dispatchEvent = (eventName, ...args) => {
+        if (eventListeners[eventName]) {
+            eventListeners[eventName].forEach((handler) => handler(...args));
+        }
+    };
+    const selectionValue = (values) => {
+        const selected = values.filter((value) => value !== null);
+        return config.multiSelect ? selected : (selected[0] ?? null);
+    };
+    const changeEvent = (values, changed) => {
+        return { value: selectionValue(values), selected: values, changed };
+    };
+    const currentValue = () => selectionValue(getSelectedValues());
+    const selectSingle = (selectedChip) => {
+        if (config.multiSelect)
+            return;
+        component.chipInstances.forEach((chip) => {
+            if (chip !== selectedChip && chip.isSelected())
+                chip.setSelected(false);
+        });
+    };
+    const handleSelection = (selectedChip) => {
+        if (selectedChip.isSelected())
+            selectSingle(selectedChip);
+        if (config.selectionRequired && !selectedChip.isSelected() && getSelectedChips().length === 0) {
+            selectedChip.setSelected(true);
+            return true;
+        }
+        const selectedChips = component.chipInstances.filter((chip) => chip.isSelected());
+        const selectedValues = selectedChips.map((chip) => chip.getValue());
+        const changedValue = selectedChip ? selectedChip.getValue() : null;
+        dispatchEvent(CHIPS_EVENTS.CHANGE, changeEvent(selectedValues, changedValue));
+    };
+    const targets = () => component.chipInstances
+        .filter((chip) => !chip.isDisabled())
+        .flatMap((chip) => chip.element.hasAttribute("tabindex")
+        ? [chip.element]
+        : Array.from(chip.element.querySelectorAll(":scope > button")));
+    let current = null;
+    const syncTabStop = () => {
+        const list = targets();
+        if (!current || !list.includes(current))
+            current = list[0] ?? null;
+        for (const chip of component.chipInstances) {
+            if (chip.element.hasAttribute("tabindex"))
+                chip.element.tabIndex = -1;
+            chip.element.querySelectorAll(":scope > button").forEach((button) => { button.tabIndex = -1; });
+        }
+        if (current)
+            current.tabIndex = 0;
+    };
+    const handleKeyboardNavigation = (event) => {
+        if (!keyboardEnabled)
+            return;
+        const list = targets();
+        if (list.length === 0)
+            return;
+        const isVertical = !!(component.layout && component.layout.isVertical());
+        const rtl = component.element.matches(":dir(rtl)");
+        const back = isVertical ? "ArrowUp" : rtl ? "ArrowRight" : "ArrowLeft";
+        const forward = isVertical ? "ArrowDown" : rtl ? "ArrowLeft" : "ArrowRight";
+        const from = list.indexOf(event.target);
+        let next;
+        if (event.key === back)
+            next = Math.max(0, from - 1);
+        else if (event.key === forward)
+            next = Math.min(list.length - 1, from + 1);
+        else if (event.key === "Home")
+            next = 0;
+        else if (event.key === "End")
+            next = list.length - 1;
+        else
+            return;
+        event.preventDefault();
+        event.stopPropagation();
+        if (from === -1)
+            next = 0;
+        current = list[next];
+        syncTabStop();
+        current.focus();
+        const owner = component.chipInstances.findIndex((chip) => chip.element.contains(current));
+        if (owner >= 0) {
+            focusedChipIndex = owner;
+            if (component.layout && component.layout.isScrollable())
+                scrollToChip(owner);
+        }
+    };
+    const scrollToChip = (chipOrIndex) => {
+        const isScrollable = component.layout && component.layout.isScrollable();
+        if (!isScrollable)
+            return;
+        const index = typeof chipOrIndex === "number"
+            ? chipOrIndex
+            : component.chipInstances.indexOf(chipOrIndex);
+        if (index >= 0 && index < component.chipInstances.length) {
+            const chipElement = component.chipInstances[index].element;
+            const container = component.chipContainer || component.element;
+            const containerRect = container.getBoundingClientRect();
+            const chipRect = chipElement.getBoundingClientRect();
+            const isVertical = component.layout && component.layout.isVertical();
+            if (isVertical) {
+                const scrollTop = chipElement.offsetTop -
+                    container.offsetTop -
+                    containerRect.height / 2 +
+                    chipRect.height / 2;
+                container.scrollTo({
+                    top: Math.max(0, scrollTop),
+                });
+            }
+            else {
+                const scrollLeft = chipElement.offsetLeft -
+                    container.offsetLeft -
+                    containerRect.width / 2 +
+                    chipRect.width / 2;
+                container.scrollTo({
+                    left: Math.max(0, scrollLeft),
+                });
+            }
+        }
+    };
+    const unlist = (index) => {
+        const chips = component.chipInstances;
+        const chip = chips[index];
+        const hadFocus = chip.element.contains(activeElementOf(chip.element));
+        chip.element.removeEventListener("keydown", handleKeyboardNavigation);
+        chips.splice(index, 1);
+        if (index === focusedChipIndex)
+            focusedChipIndex = -1;
+        else if (index < focusedChipIndex)
+            focusedChipIndex--;
+        syncTabStop();
+        if (!hadFocus)
+            return;
+        let next = Math.min(index, chips.length - 1);
+        while (next >= 0 && chips[next].isDisabled())
+            next--;
+        if (next < 0)
+            next = chips.findIndex(candidate => !candidate.isDisabled());
+        if (next >= 0) {
+            focusedChipIndex = next;
+            chips[next].focus();
+        }
+    };
+    let tearingDown = false;
+    const watchChipDestroy = (chip) => {
+        const destroy = chip.destroy.bind(chip);
+        chip.destroy = () => {
+            const index = tearingDown ? -1 : component.chipInstances.indexOf(chip);
+            if (index >= 0)
+                unlist(index);
+            destroy();
+        };
+    };
+    const addChip = (chipConfig) => {
+        const chipInstance = createChip({
+            ...chipConfig,
+            managedSelection: true,
+            onSelected: selectSingle,
+            cell: true,
+            onRemoved: removeChip,
+        });
+        const container = component.chipContainer || component.element;
+        const fragment = document.createDocumentFragment();
+        fragment.appendChild(chipInstance.element);
+        container.appendChild(fragment);
+        component.chipInstances.push(chipInstance);
+        if (chipInstance.isSelected())
+            selectSingle(chipInstance);
+        chipInstance.on("click", () => {
+            if (!chipInstance.isDisabled() && ["filter", "input"].includes(chipInstance.getType())) {
+                chipInstance.toggleSelected();
+                if (!handleSelection(chipInstance))
+                    chipConfig.onSelect?.(chipInstance);
+                focusedChipIndex = component.chipInstances.indexOf(chipInstance);
+            }
+        });
+        chipInstance.on("focus", () => {
+            focusedChipIndex = component.chipInstances.indexOf(chipInstance);
+        });
+        chipInstance.element.addEventListener("keydown", handleKeyboardNavigation);
+        syncTabStop();
+        watchChipDestroy(chipInstance);
+        dispatchEvent(CHIPS_EVENTS.ADD, { value: currentValue(), chip: chipInstance });
+        return chipInstance;
+    };
+    const removeChip = (chipOrIndex) => {
+        const index = typeof chipOrIndex === "number"
+            ? chipOrIndex
+            : component.chipInstances.indexOf(chipOrIndex);
+        if (index >= 0 && index < component.chipInstances.length) {
+            const chip = component.chipInstances[index];
+            const chipValue = chip.getValue();
+            unlist(index);
+            chip.destroy();
+            dispatchEvent(CHIPS_EVENTS.REMOVE, { value: currentValue(), chip, chipValue });
+        }
+    };
+    const getChips = () => {
+        return [...component.chipInstances];
+    };
+    const getSelectedChips = () => {
+        return component.chipInstances.filter((chip) => chip.isSelected());
+    };
+    const getSelectedValues = () => {
+        return getSelectedChips().map((chip) => chip.getValue());
+    };
+    const selectByValue = (values, triggerEvent = false, exclusive = !config.multiSelect) => {
+        const valueArray = Array.isArray(values) ? values : [values];
+        let selectionChanged = false;
+        if (exclusive) {
+            component.chipInstances.forEach((chip) => {
+                const chipValue = chip.getValue();
+                const shouldSelect = chipValue !== null && valueArray.includes(chipValue);
+                if (!shouldSelect && chip.isSelected()) {
+                    chip.setSelected(false);
+                    selectionChanged = true;
+                }
+            });
+        }
+        component.chipInstances.forEach((chip) => {
+            const chipValue = chip.getValue();
+            const shouldSelect = chipValue !== null && valueArray.includes(chipValue);
+            if (shouldSelect && !chip.isSelected()) {
+                chip.setSelected(true);
+                selectionChanged = true;
+            }
+        });
+        if (selectionChanged && triggerEvent) {
+            const selectedValues = getSelectedValues();
+            dispatchEvent(CHIPS_EVENTS.CHANGE, changeEvent(selectedValues, null));
+        }
+    };
+    const clearSelection = (triggerEvent = false) => {
+        const selectedValues = getSelectedValues();
+        const hadSelectedChips = selectedValues.length > 0;
+        component.chipInstances.forEach((chip) => {
+            chip.setSelected(false);
+        });
+        if (hadSelectedChips && triggerEvent) {
+            dispatchEvent(CHIPS_EVENTS.CHANGE, changeEvent([], null));
+        }
+    };
+    const enableKeyboardNavigation = () => {
+        keyboardEnabled = true;
+        component.chipInstances.forEach((chip) => {
+            chip.element.addEventListener("keydown", handleKeyboardNavigation);
+        });
+    };
+    const disableKeyboardNavigation = () => {
+        keyboardEnabled = false;
+        component.chipInstances.forEach((chip) => {
+            chip.element.removeEventListener("keydown", handleKeyboardNavigation);
+        });
+    };
+    enableKeyboardNavigation();
+    const trackFocus = (event) => {
+        const target = event.target;
+        if (targets().includes(target)) {
+            current = target;
+            syncTabStop();
+        }
+    };
+    if (component.element) {
+        component.element.addEventListener("keydown", handleKeyboardNavigation);
+        component.element.addEventListener("focusin", trackFocus);
+    }
+    getCleanup(component).add(() => {
+        tearingDown = true;
+        component.element.removeEventListener("keydown", handleKeyboardNavigation);
+        component.element.removeEventListener("focusin", trackFocus);
+        component.chipInstances.forEach(chip => {
+            chip.element.removeEventListener("keydown", handleKeyboardNavigation);
+            chip.destroy();
+        });
+        component.chipInstances.length = 0;
+        Object.keys(eventListeners).forEach(event => { eventListeners[event].length = 0; });
+    });
+    return {
+        ...component,
+        chips: {
+            addChip,
+            removeChip,
+            getChips,
+            getSelectedChips,
+            getSelectedValues,
+            selectByValue,
+            clearSelection,
+            scrollToChip,
+        },
+        keyboard: {
+            enable: enableKeyboardNavigation,
+            disable: disableKeyboardNavigation,
+        },
+        on(event, handler) {
+            if (!eventListeners[event]) {
+                eventListeners[event] = [];
+            }
+            eventListeners[event].push(handler);
+            return this;
+        },
+        off(event, handler) {
+            if (eventListeners[event]) {
+                const index = eventListeners[event].indexOf(handler);
+                if (index !== -1) {
+                    eventListeners[event].splice(index, 1);
+                }
+            }
+            return this;
+        },
+    };
+};

package/dist/components/chips/features/dom.d.ts

@@ -0,0 +1,24 @@
+import { ChipsConfig } from "../types.js";
+type ChipsLabelPosition = "start" | "end";
+/** The chips set's label, behind setLabel/getLabel/setLabelPosition/getLabelPosition. */
+export interface ChipsLabelControl {
+    setText: (text: string) => void;
+    getText: () => string;
+    setPosition: (position: ChipsLabelPosition) => void;
+    getPosition: () => ChipsLabelPosition;
+}
+import { ElementComponent } from "../../../core/compose/component.js";
+/**
+ * Creates the inner chips DOM structure using optimized createElement
+ * This works alongside withElement to create chips-specific inner elements
+ *
+ * @param config Chips configuration
+ * @returns Component enhancement function
+ */
+export declare const withDom: (config: ChipsConfig) => <T extends ElementComponent>(component: T) => T & {
+    chipContainer: HTMLElement;
+    labelControl: ChipsLabelControl;
+    getChipContainer: () => HTMLElement;
+    getLabel: () => HTMLElement | null;
+};
+export {};

package/dist/components/chips/features/dom.js

@@ -0,0 +1,55 @@
+import { createElement } from "../../../core/dom/create.js";
+export const withDom = (config) => (component) => {
+    const getClass = (className) => component.getClass(className);
+    const hasLabel = config.label && config.label.trim().length > 0;
+    let position = config.labelPosition === "end" ? "end" : "start";
+    const root = component.element;
+    const createLabel = (text) => {
+        const created = createElement({ tag: "label", className: getClass("chips__label"), text });
+        created.id = `${getClass("chips")}-label-${Math.random().toString(36).slice(2, 9)}`;
+        root.insertBefore(created, root.firstChild);
+        root.setAttribute("aria-labelledby", created.id);
+        return created;
+    };
+    const syncClasses = () => {
+        root.classList.toggle(getClass("chips--with-label"), !!label);
+        root.classList.toggle(getClass("chips--label-end"), !!label && position === "end");
+    };
+    let label = hasLabel ? createLabel(config.label) : undefined;
+    const chipContainer = createElement({
+        tag: "div",
+        className: getClass("chips__container"),
+        container: component.element,
+    });
+    chipContainer.setAttribute("role", "row");
+    const labelControl = {
+        setText(text) {
+            const value = (text ?? "").trim() ? text : "";
+            if (!value) {
+                label?.remove();
+                label = undefined;
+                root.removeAttribute("aria-labelledby");
+            }
+            else if (label) {
+                label.textContent = value;
+            }
+            else {
+                label = createLabel(value);
+            }
+            syncClasses();
+        },
+        getText: () => label?.textContent ?? "",
+        setPosition(next) {
+            position = next === "end" ? "end" : "start";
+            syncClasses();
+        },
+        getPosition: () => position,
+    };
+    return {
+        ...component,
+        chipContainer,
+        labelControl,
+        getChipContainer: () => chipContainer,
+        getLabel: () => label || null,
+    };
+};

package/dist/components/chips/features/index.d.ts

@@ -0,0 +1,4 @@
+export { withContainer } from "./container.js";
+export { withChipItems } from "./chip-items.js";
+export { withController } from "./controller.js";
+export { withDom } from "./dom.js";

package/dist/components/chips/features/index.js

@@ -0,0 +1,4 @@
+export { withContainer } from "./container.js";
+export { withChipItems } from "./chip-items.js";
+export { withController } from "./controller.js";
+export { withDom } from "./dom.js";

package/dist/components/chips/index.d.ts

@@ -0,0 +1,3 @@
+export { createAssistChip, createFilterChip, createInputChip, createSuggestionChip } from "./factories.js";
+export { default, default as createChips } from "./chips.js";
+export type { ChipConfig, ChipComponent, ChipType, ChipEvents, ChipChangePayload, AssistChipConfig, FilterChipConfig, InputChipConfig, SuggestionChipConfig, ChipsConfig, ChipsComponent, ChipsEvents, ChipsChangeEvent, ChipsAddEvent, ChipsRemoveEvent, } from "./types.js";

package/dist/components/chips/index.js

@@ -0,0 +1,2 @@
+export { createAssistChip, createFilterChip, createInputChip, createSuggestionChip } from "./factories.js";
+export { default, default as createChips } from "./chips.js";