@hypericon/mico 0.6.0 → 0.7.0

package/dist/cjs/src/components/dialogue/dialogue-manager.d.ts

@@ -0,0 +1,83 @@
+import m from "mithril";
+export interface DialogueManagerOptions {
+    /** An optional parent element into which per-dialogue containers are appended. Defaults to `document.body`. */
+    containerEl?: HTMLElement;
+    debug?: boolean;
+}
+/** A handle returned from `open()` that refers to the specific dialogue that was opened. */
+export interface DialogueHandle {
+    /** Unique ID for this dialogue instance. */
+    id: string;
+    /** Close this specific dialogue, regardless of its position in the stack. */
+    close(): void;
+}
+export declare class DialogueManager {
+    /** The parent element into which per-dialogue container divs are appended. */
+    private parentEl;
+    /** LIFO stack — the last entry is the topmost (most recently opened) dialogue. */
+    private stack;
+    /** True if at least one dialogue is currently open. */
+    get isOpen(): boolean;
+    /** The number of dialogues currently open. */
+    get stackDepth(): number;
+    private debug;
+    backdropDismissTimeout: number;
+    constructor(options?: DialogueManagerOptions);
+    /**
+     * Open a new dialogue with the given contents and push it onto the dialogue stack.
+     *
+     * Note: to make use of Mithril's auto-redraw system, the dialogue must be defined as a component,
+     * not a Vnode.
+     *
+     * Example:
+     * ```ts
+     * open(MyDialogue, { ... }); // WILL redraw
+     * open(m("h1", "...")); // will NOT redraw
+     * ```
+     *
+     * To pass data back from a dialogue, provide a callback in `attrs`:
+     * ```ts
+     * const handle = await dialogueMgr.open(MyDialogue, { onconfirm: (v) => doSomething(v) });
+     * // close the dialogue from outside:
+     * handle.close();
+     * ```
+     *
+     * @returns A `DialogueHandle` once the dialogue has been created and is displayed to the user.
+     */
+    open<A = {}>(dialogue: m.Component<A, any> | m.Vnode<any, any>, attrs?: A, opts?: {
+        backdropDismiss?: boolean;
+        noEscape?: boolean;
+    }): Promise<DialogueHandle>;
+    /**
+     * Close the topmost dialogue in the stack.
+     *
+     * Silently does nothing if no dialogue is open.
+     */
+    close(): void;
+    /**
+     * Close all open dialogues, from the topmost downward.
+     *
+     * Silently does nothing if no dialogues are open.
+     */
+    closeAll(): void;
+    /**
+     * Close a specific dialogue by its ID.
+     * Used internally and via `DialogueHandle.close()`.
+     */
+    private _closeById;
+    /**
+     * Unmount the Mithril root for a dialogue and remove it from the stack and the DOM.
+     * Called from each dialogue's native `onclose` event so it fires for all close paths
+     * (programmatic, Escape key, backdrop dismiss).
+     */
+    private _teardown;
+}
+/**
+ * A singleton instance of `DialogueManager` that can be imported and used throughout the application.
+ * Use this instance to open and manage dialogues.
+ */
+export declare const dialogueMgr: DialogueManager;
+/**
+ * @deprecated Use `dialogueMgr` instead. This alias is provided for backwards compatibility.
+ */
+export declare const dialogMgr: DialogueManager;

package/dist/cjs/src/components/dialogue/dialogue-manager.js

@@ -0,0 +1,170 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dialogMgr = exports.dialogueMgr = exports.DialogueManager = void 0;
+const mithril_1 = __importDefault(require("mithril"));
+const utils_1 = require("../../utils");
+class DialogueManager {
+    /** True if at least one dialogue is currently open. */
+    get isOpen() { return this.stack.length > 0; }
+    /** The number of dialogues currently open. */
+    get stackDepth() { return this.stack.length; }
+    constructor(options) {
+        /** LIFO stack — the last entry is the topmost (most recently opened) dialogue. */
+        this.stack = [];
+        this.debug = false;
+        this.backdropDismissTimeout = 100;
+        if (options === null || options === void 0 ? void 0 : options.debug)
+            this.debug = options.debug;
+        if (options === null || options === void 0 ? void 0 : options.containerEl) {
+            this.parentEl = options.containerEl;
+        }
+        else {
+            this.parentEl = document.body;
+        }
+    }
+    /**
+     * Open a new dialogue with the given contents and push it onto the dialogue stack.
+     *
+     * Note: to make use of Mithril's auto-redraw system, the dialogue must be defined as a component,
+     * not a Vnode.
+     *
+     * Example:
+     * ```ts
+     * open(MyDialogue, { ... }); // WILL redraw
+     * open(m("h1", "...")); // will NOT redraw
+     * ```
+     *
+     * To pass data back from a dialogue, provide a callback in `attrs`:
+     * ```ts
+     * const handle = await dialogueMgr.open(MyDialogue, { onconfirm: (v) => doSomething(v) });
+     * // close the dialogue from outside:
+     * handle.close();
+     * ```
+     *
+     * @returns A `DialogueHandle` once the dialogue has been created and is displayed to the user.
+     */
+    open(dialogue, attrs, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const manager = this;
+            const dialogueId = `mico-dialogue-${Math.random().toString().replace("0.", "")}`;
+            // Each dialogue gets its own container div appended to the parent element.
+            const containerEl = document.createElement("div");
+            containerEl.classList.add("mico-dialogue-container", "mico-dialog-container");
+            this.parentEl.append(containerEl);
+            return new Promise((resolve) => {
+                const backdropDismissAvailableAt = Date.now() + this.backdropDismissTimeout;
+                mithril_1.default.mount(containerEl, {
+                    oncreate({ dom }) {
+                        var _a;
+                        const dialogueEl = dom;
+                        (_a = dialogueEl.showModal) === null || _a === void 0 ? void 0 : _a.call(dialogueEl);
+                        const entry = { id: dialogueId, containerEl, dialogueEl: dialogueEl };
+                        manager.stack.push(entry);
+                        // Optionally wire up the backdrop to dismiss the dialogue
+                        if ((opts === null || opts === void 0 ? void 0 : opts.backdropDismiss) === true) {
+                            dialogueEl.addEventListener("click", (ev) => {
+                                if (Date.now() < backdropDismissAvailableAt)
+                                    return;
+                                if (ev.target !== dom)
+                                    return;
+                                const isInDialogue = (0, utils_1.mouseWithinElement)(ev, dom);
+                                if (!isInDialogue)
+                                    manager._closeById(dialogueId);
+                            });
+                        }
+                        resolve({
+                            id: dialogueId,
+                            close: () => manager._closeById(dialogueId),
+                        });
+                    },
+                    view() {
+                        return (0, mithril_1.default)("dialog", {
+                            id: dialogueId,
+                            key: dialogueId,
+                            class: "mico-dialog mico-dialogue",
+                            onclose: () => {
+                                manager.debug && console.log(`dialogue onclose() id=${dialogueId}`);
+                                manager._teardown(dialogueId);
+                            },
+                            oncancel: (ev) => {
+                                if ((opts === null || opts === void 0 ? void 0 : opts.noEscape) === true) {
+                                    ev.preventDefault();
+                                }
+                            },
+                        }, [
+                            ("view" in dialogue)
+                                ? (0, mithril_1.default)(dialogue, Object.assign({}, attrs))
+                                : dialogue,
+                        ]);
+                    },
+                });
+            });
+        });
+    }
+    /**
+     * Close the topmost dialogue in the stack.
+     *
+     * Silently does nothing if no dialogue is open.
+     */
+    close() {
+        const top = this.stack[this.stack.length - 1];
+        top === null || top === void 0 ? void 0 : top.dialogueEl.close();
+    }
+    /**
+     * Close all open dialogues, from the topmost downward.
+     *
+     * Silently does nothing if no dialogues are open.
+     */
+    closeAll() {
+        // Snapshot the stack before iterating — each .close() triggers onclose → _teardown()
+        // which splices the live array, so we must not iterate the array directly.
+        const entries = this.stack.slice().reverse();
+        for (const entry of entries) {
+            entry.dialogueEl.close();
+        }
+    }
+    /**
+     * Close a specific dialogue by its ID.
+     * Used internally and via `DialogueHandle.close()`.
+     */
+    _closeById(id) {
+        const entry = this.stack.find(e => e.id === id);
+        entry === null || entry === void 0 ? void 0 : entry.dialogueEl.close();
+    }
+    /**
+     * Unmount the Mithril root for a dialogue and remove it from the stack and the DOM.
+     * Called from each dialogue's native `onclose` event so it fires for all close paths
+     * (programmatic, Escape key, backdrop dismiss).
+     */
+    _teardown(id) {
+        const index = this.stack.findIndex(e => e.id === id);
+        if (index === -1)
+            return;
+        const [entry] = this.stack.splice(index, 1);
+        mithril_1.default.mount(entry.containerEl, null);
+        entry.containerEl.remove();
+        this.debug && console.log(`dialogue _teardown() id=${id}, stackDepth=${this.stack.length}`);
+    }
+}
+exports.DialogueManager = DialogueManager;
+/**
+ * A singleton instance of `DialogueManager` that can be imported and used throughout the application.
+ * Use this instance to open and manage dialogues.
+ */
+exports.dialogueMgr = new DialogueManager();
+/**
+ * @deprecated Use `dialogueMgr` instead. This alias is provided for backwards compatibility.
+ */
+exports.dialogMgr = exports.dialogueMgr;

package/dist/cjs/src/components/dialogue/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./dialogue-manager";
+/**
+ * @deprecated Use `DialogueHandle` instead. This alias is provided for backwards compatibility.
+ */
+export type { DialogueHandle as DialogHandle } from "./dialogue-manager";

package/dist/cjs/src/components/dialogue/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./dialogue-manager"), exports);

package/dist/cjs/{components → src/components}/index.d.ts

@@ -1,4 +1,4 @@
-export * from "./dialog";
+export * from "./dialogue";
 export * from "./drag-handler";
 export * from "./drop-target";
 export * from "./icon";

package/dist/cjs/{components → src/components}/index.js

@@ -17,7 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 // export * from "./accordion";
 // export * from "./data-grid";
 // export * from "./data-table";
-__exportStar(require("./dialog"), exports);
+__exportStar(require("./dialogue"), exports);
 // export * from "./drawer";
 __exportStar(require("./drag-handler"), exports);
 __exportStar(require("./drop-target"), exports);

package/dist/cjs/vitest.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig;
+export default _default;

package/dist/cjs/vitest.config.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("vitest/config");
+exports.default = (0, config_1.defineConfig)({
+    test: {
+        environment: "jsdom",
+        globals: true,
+        setupFiles: ["./src/tests/setup.ts"],
+        coverage: {
+            provider: "v8",
+            include: ["src/components/**", "src/utils/**"],
+            exclude: ["src/docs/**", "src/tests/**"],
+            thresholds: { statements: 80, branches: 70, functions: 80 },
+        },
+    },
+});

package/dist/esm/src/components/dialogue/dialogue-manager.d.ts

@@ -0,0 +1,83 @@
+import m from "mithril";
+export interface DialogueManagerOptions {
+    /** An optional parent element into which per-dialogue containers are appended. Defaults to `document.body`. */
+    containerEl?: HTMLElement;
+    debug?: boolean;
+}
+/** A handle returned from `open()` that refers to the specific dialogue that was opened. */
+export interface DialogueHandle {
+    /** Unique ID for this dialogue instance. */
+    id: string;
+    /** Close this specific dialogue, regardless of its position in the stack. */
+    close(): void;
+}
+export declare class DialogueManager {
+    /** The parent element into which per-dialogue container divs are appended. */
+    private parentEl;
+    /** LIFO stack — the last entry is the topmost (most recently opened) dialogue. */
+    private stack;
+    /** True if at least one dialogue is currently open. */
+    get isOpen(): boolean;
+    /** The number of dialogues currently open. */
+    get stackDepth(): number;
+    private debug;
+    backdropDismissTimeout: number;
+    constructor(options?: DialogueManagerOptions);
+    /**
+     * Open a new dialogue with the given contents and push it onto the dialogue stack.
+     *
+     * Note: to make use of Mithril's auto-redraw system, the dialogue must be defined as a component,
+     * not a Vnode.
+     *
+     * Example:
+     * ```ts
+     * open(MyDialogue, { ... }); // WILL redraw
+     * open(m("h1", "...")); // will NOT redraw
+     * ```
+     *
+     * To pass data back from a dialogue, provide a callback in `attrs`:
+     * ```ts
+     * const handle = await dialogueMgr.open(MyDialogue, { onconfirm: (v) => doSomething(v) });
+     * // close the dialogue from outside:
+     * handle.close();
+     * ```
+     *
+     * @returns A `DialogueHandle` once the dialogue has been created and is displayed to the user.
+     */
+    open<A = {}>(dialogue: m.Component<A, any> | m.Vnode<any, any>, attrs?: A, opts?: {
+        backdropDismiss?: boolean;
+        noEscape?: boolean;
+    }): Promise<DialogueHandle>;
+    /**
+     * Close the topmost dialogue in the stack.
+     *
+     * Silently does nothing if no dialogue is open.
+     */
+    close(): void;
+    /**
+     * Close all open dialogues, from the topmost downward.
+     *
+     * Silently does nothing if no dialogues are open.
+     */
+    closeAll(): void;
+    /**
+     * Close a specific dialogue by its ID.
+     * Used internally and via `DialogueHandle.close()`.
+     */
+    private _closeById;
+    /**
+     * Unmount the Mithril root for a dialogue and remove it from the stack and the DOM.
+     * Called from each dialogue's native `onclose` event so it fires for all close paths
+     * (programmatic, Escape key, backdrop dismiss).
+     */
+    private _teardown;
+}
+/**
+ * A singleton instance of `DialogueManager` that can be imported and used throughout the application.
+ * Use this instance to open and manage dialogues.
+ */
+export declare const dialogueMgr: DialogueManager;
+/**
+ * @deprecated Use `dialogueMgr` instead. This alias is provided for backwards compatibility.
+ */
+export declare const dialogMgr: DialogueManager;

package/dist/esm/src/components/dialogue/dialogue-manager.js

@@ -0,0 +1,170 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dialogMgr = exports.dialogueMgr = exports.DialogueManager = void 0;
+const mithril_1 = __importDefault(require("mithril"));
+const utils_1 = require("../../utils");
+class DialogueManager {
+    /** True if at least one dialogue is currently open. */
+    get isOpen() { return this.stack.length > 0; }
+    /** The number of dialogues currently open. */
+    get stackDepth() { return this.stack.length; }
+    constructor(options) {
+        /** LIFO stack — the last entry is the topmost (most recently opened) dialogue. */
+        this.stack = [];
+        this.debug = false;
+        this.backdropDismissTimeout = 100;
+        if (options === null || options === void 0 ? void 0 : options.debug)
+            this.debug = options.debug;
+        if (options === null || options === void 0 ? void 0 : options.containerEl) {
+            this.parentEl = options.containerEl;
+        }
+        else {
+            this.parentEl = document.body;
+        }
+    }
+    /**
+     * Open a new dialogue with the given contents and push it onto the dialogue stack.
+     *
+     * Note: to make use of Mithril's auto-redraw system, the dialogue must be defined as a component,
+     * not a Vnode.
+     *
+     * Example:
+     * ```ts
+     * open(MyDialogue, { ... }); // WILL redraw
+     * open(m("h1", "...")); // will NOT redraw
+     * ```
+     *
+     * To pass data back from a dialogue, provide a callback in `attrs`:
+     * ```ts
+     * const handle = await dialogueMgr.open(MyDialogue, { onconfirm: (v) => doSomething(v) });
+     * // close the dialogue from outside:
+     * handle.close();
+     * ```
+     *
+     * @returns A `DialogueHandle` once the dialogue has been created and is displayed to the user.
+     */
+    open(dialogue, attrs, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const manager = this;
+            const dialogueId = `mico-dialogue-${Math.random().toString().replace("0.", "")}`;
+            // Each dialogue gets its own container div appended to the parent element.
+            const containerEl = document.createElement("div");
+            containerEl.classList.add("mico-dialogue-container", "mico-dialog-container");
+            this.parentEl.append(containerEl);
+            return new Promise((resolve) => {
+                const backdropDismissAvailableAt = Date.now() + this.backdropDismissTimeout;
+                mithril_1.default.mount(containerEl, {
+                    oncreate({ dom }) {
+                        var _a;
+                        const dialogueEl = dom;
+                        (_a = dialogueEl.showModal) === null || _a === void 0 ? void 0 : _a.call(dialogueEl);
+                        const entry = { id: dialogueId, containerEl, dialogueEl: dialogueEl };
+                        manager.stack.push(entry);
+                        // Optionally wire up the backdrop to dismiss the dialogue
+                        if ((opts === null || opts === void 0 ? void 0 : opts.backdropDismiss) === true) {
+                            dialogueEl.addEventListener("click", (ev) => {
+                                if (Date.now() < backdropDismissAvailableAt)
+                                    return;
+                                if (ev.target !== dom)
+                                    return;
+                                const isInDialogue = (0, utils_1.mouseWithinElement)(ev, dom);
+                                if (!isInDialogue)
+                                    manager._closeById(dialogueId);
+                            });
+                        }
+                        resolve({
+                            id: dialogueId,
+                            close: () => manager._closeById(dialogueId),
+                        });
+                    },
+                    view() {
+                        return (0, mithril_1.default)("dialog", {
+                            id: dialogueId,
+                            key: dialogueId,
+                            class: "mico-dialog mico-dialogue",
+                            onclose: () => {
+                                manager.debug && console.log(`dialogue onclose() id=${dialogueId}`);
+                                manager._teardown(dialogueId);
+                            },
+                            oncancel: (ev) => {
+                                if ((opts === null || opts === void 0 ? void 0 : opts.noEscape) === true) {
+                                    ev.preventDefault();
+                                }
+                            },
+                        }, [
+                            ("view" in dialogue)
+                                ? (0, mithril_1.default)(dialogue, Object.assign({}, attrs))
+                                : dialogue,
+                        ]);
+                    },
+                });
+            });
+        });
+    }
+    /**
+     * Close the topmost dialogue in the stack.
+     *
+     * Silently does nothing if no dialogue is open.
+     */
+    close() {
+        const top = this.stack[this.stack.length - 1];
+        top === null || top === void 0 ? void 0 : top.dialogueEl.close();
+    }
+    /**
+     * Close all open dialogues, from the topmost downward.
+     *
+     * Silently does nothing if no dialogues are open.
+     */
+    closeAll() {
+        // Snapshot the stack before iterating — each .close() triggers onclose → _teardown()
+        // which splices the live array, so we must not iterate the array directly.
+        const entries = this.stack.slice().reverse();
+        for (const entry of entries) {
+            entry.dialogueEl.close();
+        }
+    }
+    /**
+     * Close a specific dialogue by its ID.
+     * Used internally and via `DialogueHandle.close()`.
+     */
+    _closeById(id) {
+        const entry = this.stack.find(e => e.id === id);
+        entry === null || entry === void 0 ? void 0 : entry.dialogueEl.close();
+    }
+    /**
+     * Unmount the Mithril root for a dialogue and remove it from the stack and the DOM.
+     * Called from each dialogue's native `onclose` event so it fires for all close paths
+     * (programmatic, Escape key, backdrop dismiss).
+     */
+    _teardown(id) {
+        const index = this.stack.findIndex(e => e.id === id);
+        if (index === -1)
+            return;
+        const [entry] = this.stack.splice(index, 1);
+        mithril_1.default.mount(entry.containerEl, null);
+        entry.containerEl.remove();
+        this.debug && console.log(`dialogue _teardown() id=${id}, stackDepth=${this.stack.length}`);
+    }
+}
+exports.DialogueManager = DialogueManager;
+/**
+ * A singleton instance of `DialogueManager` that can be imported and used throughout the application.
+ * Use this instance to open and manage dialogues.
+ */
+exports.dialogueMgr = new DialogueManager();
+/**
+ * @deprecated Use `dialogueMgr` instead. This alias is provided for backwards compatibility.
+ */
+exports.dialogMgr = exports.dialogueMgr;

package/dist/esm/src/components/dialogue/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./dialogue-manager";
+/**
+ * @deprecated Use `DialogueHandle` instead. This alias is provided for backwards compatibility.
+ */
+export type { DialogueHandle as DialogHandle } from "./dialogue-manager";

package/dist/esm/src/components/dialogue/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./dialogue-manager"), exports);

package/dist/esm/{components → src/components}/index.d.ts

@@ -1,4 +1,4 @@
-export * from "./dialog";
+export * from "./dialogue";
 export * from "./drag-handler";
 export * from "./drop-target";
 export * from "./icon";

package/dist/esm/{components → src/components}/index.js

@@ -17,7 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 // export * from "./accordion";
 // export * from "./data-grid";
 // export * from "./data-table";
-__exportStar(require("./dialog"), exports);
+__exportStar(require("./dialogue"), exports);
 // export * from "./drawer";
 __exportStar(require("./drag-handler"), exports);
 __exportStar(require("./drop-target"), exports);

package/dist/esm/vitest.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite", { with: { "resolution-mode": "import" } }).UserConfig;
+export default _default;

package/dist/esm/vitest.config.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("vitest/config");
+exports.default = (0, config_1.defineConfig)({
+    test: {
+        environment: "jsdom",
+        globals: true,
+        setupFiles: ["./src/tests/setup.ts"],
+        coverage: {
+            provider: "v8",
+            include: ["src/components/**", "src/utils/**"],
+            exclude: ["src/docs/**", "src/tests/**"],
+            thresholds: { statements: 80, branches: 70, functions: 80 },
+        },
+    },
+});