@llui/components 0.0.1

package/dist/components/tree-view.js

@@ -0,0 +1,293 @@
+import { typeaheadAccumulate, typeaheadMatch, isTypeaheadKey, TYPEAHEAD_TIMEOUT_MS, } from '../utils/typeahead';
+export function init(opts = {}) {
+    return {
+        expanded: opts.expanded ?? [],
+        selected: opts.selected ?? [],
+        checked: opts.checked ?? [],
+        indeterminate: opts.indeterminate ?? [],
+        focused: null,
+        selectionMode: opts.selectionMode ?? 'single',
+        visibleItems: opts.visibleItems ?? [],
+        visibleLabels: opts.visibleLabels ?? [],
+        disabled: opts.disabled ?? false,
+        typeahead: '',
+        typeaheadExpiresAt: 0,
+        renaming: null,
+        renameDraft: '',
+        loading: [],
+    };
+}
+export function update(state, msg) {
+    if (state.disabled && msg.type !== 'setVisibleItems')
+        return [state, []];
+    switch (msg.type) {
+        case 'toggleBranch': {
+            const expanded = state.expanded.includes(msg.id)
+                ? state.expanded.filter((id) => id !== msg.id)
+                : [...state.expanded, msg.id];
+            return [{ ...state, expanded }, []];
+        }
+        case 'expand':
+            if (state.expanded.includes(msg.id))
+                return [state, []];
+            return [{ ...state, expanded: [...state.expanded, msg.id] }, []];
+        case 'collapse':
+            if (!state.expanded.includes(msg.id))
+                return [state, []];
+            return [{ ...state, expanded: state.expanded.filter((id) => id !== msg.id) }, []];
+        case 'expandAll':
+            return [{ ...state, expanded: msg.ids }, []];
+        case 'collapseAll':
+            return [{ ...state, expanded: [] }, []];
+        case 'select': {
+            if (state.selectionMode === 'single') {
+                return [{ ...state, selected: [msg.id] }, []];
+            }
+            if (msg.additive) {
+                const isSelected = state.selected.includes(msg.id);
+                const selected = isSelected
+                    ? state.selected.filter((id) => id !== msg.id)
+                    : [...state.selected, msg.id];
+                return [{ ...state, selected }, []];
+            }
+            return [{ ...state, selected: [msg.id] }, []];
+        }
+        case 'setSelected':
+            return [{ ...state, selected: msg.ids }, []];
+        case 'focus':
+            return [{ ...state, focused: msg.id }, []];
+        case 'focusNext': {
+            if (state.visibleItems.length === 0)
+                return [state, []];
+            const idx = state.focused ? state.visibleItems.indexOf(state.focused) : -1;
+            const next = state.visibleItems[Math.min(idx + 1, state.visibleItems.length - 1)];
+            return [{ ...state, focused: next ?? state.focused }, []];
+        }
+        case 'focusPrev': {
+            if (state.visibleItems.length === 0)
+                return [state, []];
+            const idx = state.focused
+                ? state.visibleItems.indexOf(state.focused)
+                : state.visibleItems.length;
+            const prev = state.visibleItems[Math.max(0, idx - 1)];
+            return [{ ...state, focused: prev ?? state.focused }, []];
+        }
+        case 'focusFirst':
+            return [{ ...state, focused: state.visibleItems[0] ?? null }, []];
+        case 'focusLast':
+            return [{ ...state, focused: state.visibleItems[state.visibleItems.length - 1] ?? null }, []];
+        case 'setVisibleItems':
+            return [
+                { ...state, visibleItems: msg.ids, visibleLabels: msg.labels ?? state.visibleLabels },
+                [],
+            ];
+        case 'arrowLeftFrom': {
+            // If this is an expanded branch, collapse it and stay focused.
+            if (msg.isBranch && state.expanded.includes(msg.id)) {
+                return [{ ...state, expanded: state.expanded.filter((id) => id !== msg.id) }, []];
+            }
+            // Otherwise, move focus to parent if provided (WAI-ARIA).
+            if (msg.parentId !== null) {
+                return [{ ...state, focused: msg.parentId }, []];
+            }
+            return [state, []];
+        }
+        case 'arrowRightFrom': {
+            // If this branch is closed, expand it; otherwise focus the first
+            // visible child (the next item in depth-first visibleItems order).
+            if (!state.expanded.includes(msg.id)) {
+                return [{ ...state, expanded: [...state.expanded, msg.id] }, []];
+            }
+            const idx = state.visibleItems.indexOf(msg.id);
+            if (idx === -1 || idx === state.visibleItems.length - 1)
+                return [state, []];
+            const next = state.visibleItems[idx + 1];
+            return [{ ...state, focused: next }, []];
+        }
+        case 'typeahead': {
+            if (state.visibleItems.length === 0)
+                return [state, []];
+            const acc = typeaheadAccumulate(state.typeahead, msg.char, msg.now, state.typeaheadExpiresAt);
+            // Fall back to matching ids if labels weren't provided.
+            const labels = state.visibleLabels.length > 0 ? state.visibleLabels : state.visibleItems;
+            const disabledMask = new Array(labels.length).fill(false);
+            const startIdx = state.focused ? state.visibleItems.indexOf(state.focused) : null;
+            const matchIdx = typeaheadMatch(labels, disabledMask, acc, startIdx);
+            const focused = matchIdx === null ? state.focused : (state.visibleItems[matchIdx] ?? state.focused);
+            return [
+                { ...state, typeahead: acc, typeaheadExpiresAt: msg.now + TYPEAHEAD_TIMEOUT_MS, focused },
+                [],
+            ];
+        }
+        case 'toggleChecked': {
+            // Toggle the item's checked state, propagating to descendants if any.
+            // The caller passes `descendantIds` for branches; for leaves, pass
+            // an empty list or omit. Indeterminate flag is cleared on the id
+            // (a deliberate toggle is a definite state). The caller is
+            // responsible for recomputing `indeterminate` on ancestors via
+            // setIndeterminate after this message.
+            const desc = msg.descendantIds ?? [];
+            const all = [msg.id, ...desc];
+            const isChecked = state.checked.includes(msg.id);
+            const next = isChecked
+                ? state.checked.filter((id) => !all.includes(id))
+                : Array.from(new Set([...state.checked, ...all]));
+            const indeterminate = state.indeterminate.filter((id) => !all.includes(id));
+            return [{ ...state, checked: next, indeterminate }, []];
+        }
+        case 'setChecked':
+            return [{ ...state, checked: msg.ids }, []];
+        case 'setIndeterminate':
+            return [{ ...state, indeterminate: msg.ids }, []];
+        case 'renameStart':
+            return [{ ...state, renaming: msg.id, renameDraft: msg.initial }, []];
+        case 'renameChange':
+            return [{ ...state, renameDraft: msg.value }, []];
+        case 'renameCommit':
+        case 'renameCancel':
+            return [{ ...state, renaming: null, renameDraft: '' }, []];
+        case 'loadingStart':
+            if (state.loading.includes(msg.id))
+                return [state, []];
+            return [{ ...state, loading: [...state.loading, msg.id] }, []];
+        case 'loadingEnd':
+            return [{ ...state, loading: state.loading.filter((id) => id !== msg.id) }, []];
+    }
+}
+export function isExpanded(state, id) {
+    return state.expanded.includes(id);
+}
+export function isSelected(state, id) {
+    return state.selected.includes(id);
+}
+export function isChecked(state, id) {
+    return state.checked.includes(id);
+}
+export function isIndeterminate(state, id) {
+    return state.indeterminate.includes(id);
+}
+export function isRenaming(state, id) {
+    return state.renaming === id;
+}
+export function isLoading(state, id) {
+    return state.loading.includes(id);
+}
+export function connect(get, send, opts) {
+    const itemId = (v) => `${opts.id}:item:${v}`;
+    const expandOnClick = opts.expandOnClick === true;
+    return {
+        root: {
+            role: 'tree',
+            'aria-multiselectable': (s) => (get(s).selectionMode === 'multiple' ? 'true' : undefined),
+            'aria-disabled': (s) => (get(s).disabled ? 'true' : undefined),
+            'data-scope': 'tree-view',
+            'data-part': 'root',
+            'data-disabled': (s) => (get(s).disabled ? '' : undefined),
+        },
+        item: (id, depth, isBranch, parentId = null) => ({
+            item: {
+                role: 'treeitem',
+                id: itemId(id),
+                'aria-expanded': (s) => (isBranch ? isExpanded(get(s), id) : undefined),
+                'aria-selected': (s) => get(s).selectionMode === 'single' ? isSelected(get(s), id) : undefined,
+                'aria-level': depth + 1,
+                'aria-busy': (s) => (isLoading(get(s), id) ? 'true' : undefined),
+                tabIndex: (s) => (get(s).focused === id ? 0 : -1),
+                'data-scope': 'tree-view',
+                'data-part': 'item',
+                'data-value': id,
+                'data-depth': String(depth),
+                'data-selected': (s) => (isSelected(get(s), id) ? '' : undefined),
+                'data-focused': (s) => (get(s).focused === id ? '' : undefined),
+                'data-loading': (s) => (isLoading(get(s), id) ? '' : undefined),
+                onClick: (e) => {
+                    send({ type: 'select', id, additive: e.metaKey || e.ctrlKey });
+                    if (expandOnClick && isBranch)
+                        send({ type: 'toggleBranch', id });
+                },
+                onFocus: () => send({ type: 'focus', id }),
+                onKeyDown: (e) => {
+                    switch (e.key) {
+                        case 'ArrowDown':
+                            e.preventDefault();
+                            send({ type: 'focusNext' });
+                            return;
+                        case 'ArrowUp':
+                            e.preventDefault();
+                            send({ type: 'focusPrev' });
+                            return;
+                        case 'ArrowRight':
+                            // WAI-ARIA: closed branch → expand (stay); open branch →
+                            // focus first child. Leaf → nothing. The reducer decides
+                            // based on current expanded state.
+                            if (!isBranch)
+                                return;
+                            e.preventDefault();
+                            send({ type: 'arrowRightFrom', id });
+                            return;
+                        case 'ArrowLeft':
+                            // WAI-ARIA: open branch → collapse (stay); closed branch or
+                            // leaf → focus parent (if known). Root end-nodes → nothing.
+                            e.preventDefault();
+                            send({ type: 'arrowLeftFrom', id, isBranch, parentId });
+                            return;
+                        case 'Home':
+                            e.preventDefault();
+                            send({ type: 'focusFirst' });
+                            return;
+                        case 'End':
+                            e.preventDefault();
+                            send({ type: 'focusLast' });
+                            return;
+                        case 'Enter':
+                        case ' ':
+                            e.preventDefault();
+                            send({ type: 'select', id, additive: e.metaKey || e.ctrlKey });
+                            if (isBranch)
+                                send({ type: 'toggleBranch', id });
+                            return;
+                        default:
+                            if (isTypeaheadKey(e)) {
+                                send({ type: 'typeahead', char: e.key, now: Date.now() });
+                            }
+                    }
+                },
+            },
+            branchTrigger: {
+                'data-scope': 'tree-view',
+                'data-part': 'branch-trigger',
+                'data-state': (s) => (isExpanded(get(s), id) ? 'open' : 'closed'),
+                onClick: (e) => {
+                    e.stopPropagation();
+                    send({ type: 'toggleBranch', id });
+                },
+            },
+            checkbox: {
+                role: 'checkbox',
+                'aria-checked': (s) => {
+                    if (isIndeterminate(get(s), id))
+                        return 'mixed';
+                    return isChecked(get(s), id) ? 'true' : 'false';
+                },
+                'data-scope': 'tree-view',
+                'data-part': 'checkbox',
+                'data-state': (s) => {
+                    if (isIndeterminate(get(s), id))
+                        return 'indeterminate';
+                    return isChecked(get(s), id) ? 'checked' : 'unchecked';
+                },
+            },
+        }),
+    };
+}
+export const treeView = {
+    init,
+    update,
+    connect,
+    isExpanded,
+    isSelected,
+    isChecked,
+    isIndeterminate,
+    isRenaming,
+    isLoading,
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './utils/index';
+export * from './components/index';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,eAAe,CAAA;AAE7B,cAAc,oBAAoB,CAAA"}

package/dist/index.js

@@ -0,0 +1,4 @@
+// Utilities — re-exported from @llui/components/utils for convenience.
+export * from './utils/index';
+// Components
+export * from './components/index';

package/dist/patterns/confirm-dialog.d.ts

@@ -0,0 +1,92 @@
+import type { Send, TransitionOptions } from '@llui/dom';
+import { init as dialogInit, update as dialogUpdate } from '../components/dialog';
+/**
+ * ConfirmDialog — a pre-wired dialog pattern for confirmations.
+ *
+ * Composes `dialog` with conventional content: title, description, cancel,
+ * confirm. Carries an opaque `tag` so the consumer's update handler can
+ * recognize which confirmation resolved.
+ *
+ * Usage in consumer's update:
+ *
+ * ```ts
+ * case 'confirm': {
+ *   const [s, fx] = confirmDialog.update(state.confirm, msg.msg)
+ *   // When the user clicks confirm, branch on the tag:
+ *   if (msg.msg.type === 'confirm') {
+ *     switch (state.confirm.tag) {
+ *       case 'delete-user': return [{ ...state, confirm: s, users: ... }, fx]
+ *       case 'logout': return [{ ...state, confirm: s }, [...fx, logoutEffect]]
+ *     }
+ *   }
+ *   return [{ ...state, confirm: s }, fx]
+ * }
+ * ```
+ */
+export interface ConfirmDialogState {
+    open: boolean;
+    tag: string;
+    title: string;
+    description: string;
+    confirmLabel: string;
+    cancelLabel: string;
+    destructive: boolean;
+}
+export type ConfirmDialogMsg = {
+    type: 'openWith';
+    tag: string;
+    title: string;
+    description?: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    destructive?: boolean;
+} | {
+    type: 'confirm';
+} | {
+    type: 'cancel';
+} | {
+    type: 'setOpen';
+    open: boolean;
+};
+export interface ConfirmDialogInit {
+    tag?: string;
+    title?: string;
+    description?: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    destructive?: boolean;
+}
+export declare function init(opts?: ConfirmDialogInit): ConfirmDialogState;
+export declare function update(state: ConfirmDialogState, msg: ConfirmDialogMsg): [ConfirmDialogState, never[]];
+/**
+ * View the ConfirmDialog. Returns a `show`-wrapped tree that appears when
+ * the dialog is open, renders default content (title/description/buttons).
+ * Uses role="alertdialog" for destructive confirms.
+ */
+export interface ConfirmDialogViewOptions<S> {
+    get: (s: S) => ConfirmDialogState;
+    send: Send<ConfirmDialogMsg>;
+    id: string;
+    transition?: TransitionOptions;
+    /** Custom class for content root. */
+    contentClass?: string;
+    /** Custom class for destructive confirm button. */
+    destructiveClass?: string;
+}
+export declare function view<S>(opts: ConfirmDialogViewOptions<S>): Node[];
+/** Helper to create an openWith message builder. */
+export declare function openWith(tag: string, opts: {
+    title: string;
+    description?: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    destructive?: boolean;
+}): ConfirmDialogMsg;
+export declare const confirmDialog: {
+    init: typeof init;
+    update: typeof update;
+    view: typeof view;
+    openWith: typeof openWith;
+};
+export { dialogInit, dialogUpdate };
+//# sourceMappingURL=confirm-dialog.d.ts.map

package/dist/patterns/confirm-dialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"confirm-dialog.d.ts","sourceRoot":"","sources":["../../src/patterns/confirm-dialog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAExD,OAAO,EACL,IAAI,IAAI,UAAU,EAClB,MAAM,IAAI,YAAY,EAIvB,MAAM,sBAAsB,CAAA;AAE7B;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,OAAO,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,YAAY,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,EAAE,OAAO,CAAA;CACrB;AAED,MAAM,MAAM,gBAAgB,GACxB;IACE,IAAI,EAAE,UAAU,CAAA;IAChB,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB,GACD;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAClB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAA;AAEtC,MAAM,WAAW,iBAAiB;IAChC,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB;AAED,wBAAgB,IAAI,CAAC,IAAI,GAAE,iBAAsB,GAAG,kBAAkB,CAUrE;AAED,wBAAgB,MAAM,CACpB,KAAK,EAAE,kBAAkB,EACzB,GAAG,EAAE,gBAAgB,GACpB,CAAC,kBAAkB,EAAE,KAAK,EAAE,CAAC,CAuB/B;AAED;;;;GAIG;AACH,MAAM,WAAW,wBAAwB,CAAC,CAAC;IACzC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,kBAAkB,CAAA;IACjC,IAAI,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAA;IAC5B,EAAE,EAAE,MAAM,CAAA;IACV,UAAU,CAAC,EAAE,iBAAiB,CAAA;IAC9B,qCAAqC;IACrC,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,mDAAmD;IACnD,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B;AAED,wBAAgB,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,wBAAwB,CAAC,CAAC,CAAC,GAAG,IAAI,EAAE,CAkDjE;AAED,oDAAoD;AACpD,wBAAgB,QAAQ,CACtB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE;IACJ,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB,GACA,gBAAgB,CAUlB;AAED,eAAO,MAAM,aAAa;;;;;CAAmC,CAAA;AAG7D,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,CAAA"}

package/dist/patterns/confirm-dialog.js

@@ -0,0 +1,92 @@
+import { button, text, div, h2, p } from '@llui/dom';
+import { init as dialogInit, update as dialogUpdate, connect as dialogConnect, overlay as dialogOverlay, } from '../components/dialog';
+export function init(opts = {}) {
+    return {
+        open: false,
+        tag: opts.tag ?? '',
+        title: opts.title ?? '',
+        description: opts.description ?? '',
+        confirmLabel: opts.confirmLabel ?? 'Confirm',
+        cancelLabel: opts.cancelLabel ?? 'Cancel',
+        destructive: opts.destructive ?? false,
+    };
+}
+export function update(state, msg) {
+    switch (msg.type) {
+        case 'openWith':
+            return [
+                {
+                    ...state,
+                    open: true,
+                    tag: msg.tag,
+                    title: msg.title,
+                    description: msg.description ?? '',
+                    confirmLabel: msg.confirmLabel ?? state.confirmLabel,
+                    cancelLabel: msg.cancelLabel ?? state.cancelLabel,
+                    destructive: msg.destructive ?? false,
+                },
+                [],
+            ];
+        case 'confirm':
+            return [{ ...state, open: false }, []];
+        case 'cancel':
+            return [{ ...state, open: false }, []];
+        case 'setOpen':
+            return [{ ...state, open: msg.open }, []];
+    }
+}
+export function view(opts) {
+    // Build dialog parts — role='alertdialog' for proper modal semantics.
+    // Trigger + closeTrigger parts are unused (we provide our own buttons);
+    // their send is a no-op.
+    const parts = dialogConnect((s) => ({ open: opts.get(s).open }), () => {
+        /* unused — our buttons dispatch directly via opts.send */
+    }, { id: opts.id, role: 'alertdialog', closeLabel: 'Cancel' });
+    return dialogOverlay({
+        get: (s) => ({ open: opts.get(s).open }),
+        // Dismissable (Esc/outside-click) dispatches dialog.close, which we
+        // translate into confirm-dialog.cancel.
+        send: (m) => {
+            if (m.type === 'close')
+                opts.send({ type: 'cancel' });
+        },
+        parts,
+        content: () => [
+            div({ ...parts.content, class: opts.contentClass ?? 'confirm-dialog' }, [
+                h2({ ...parts.title }, [text((s) => opts.get(s).title)]),
+                p({ ...parts.description }, [text((s) => opts.get(s).description)]),
+                div({ class: 'confirm-dialog__actions' }, [
+                    button({
+                        type: 'button',
+                        class: 'btn btn-secondary',
+                        onClick: () => opts.send({ type: 'cancel' }),
+                    }, [text((s) => opts.get(s).cancelLabel)]),
+                    button({
+                        type: 'button',
+                        class: (s) => opts.get(s).destructive
+                            ? (opts.destructiveClass ?? 'btn btn-danger')
+                            : 'btn btn-primary',
+                        onClick: () => opts.send({ type: 'confirm' }),
+                    }, [text((s) => opts.get(s).confirmLabel)]),
+                ]),
+            ]),
+        ],
+        transition: opts.transition,
+        closeOnOutsideClick: false, // alertdialog default
+    });
+}
+/** Helper to create an openWith message builder. */
+export function openWith(tag, opts) {
+    return {
+        type: 'openWith',
+        tag,
+        title: opts.title,
+        description: opts.description,
+        confirmLabel: opts.confirmLabel,
+        cancelLabel: opts.cancelLabel,
+        destructive: opts.destructive,
+    };
+}
+export const confirmDialog = { init, update, view, openWith };
+// Re-exported dialog primitives (available for advanced use cases)
+export { dialogInit, dialogUpdate };

package/dist/patterns/index.d.ts

@@ -0,0 +1,3 @@
+export * as confirmDialog from './confirm-dialog';
+export type { ConfirmDialogState, ConfirmDialogMsg, ConfirmDialogInit, ConfirmDialogViewOptions, } from './confirm-dialog';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/patterns/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,aAAa,MAAM,kBAAkB,CAAA;AACjD,YAAY,EACV,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,wBAAwB,GACzB,MAAM,kBAAkB,CAAA"}

package/dist/patterns/index.js

@@ -0,0 +1 @@
+export * as confirmDialog from './confirm-dialog';

package/dist/utils/anatomy.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Anatomy — describes a component's parts and assigns unique ids per instance.
+ *
+ * Each component (dialog, menu, tabs, ...) declares its parts once. Every
+ * mount creates a fresh scope with unique ids used for ARIA wiring
+ * (`aria-controls`, `aria-labelledby`) and `data-scope`/`data-part` for CSS.
+ *
+ * ```ts
+ * const DialogAnatomy = anatomy('dialog', [
+ *   'trigger', 'positioner', 'backdrop', 'content', 'title', 'description', 'closeTrigger',
+ * ] as const)
+ *
+ * // Per instance:
+ * const parts = DialogAnatomy.scope()
+ * parts.attrs('trigger')       // { id: 'dialog-1:trigger', 'data-scope': 'dialog', 'data-part': 'trigger' }
+ * parts.idFor('content')       // 'dialog-1:content'
+ * ```
+ */
+/** Reset the internal id counter — tests only. */
+export declare function resetAnatomyIdCounter(): void;
+export interface AnatomyScope<P extends string> {
+    /** Instance id — unique across all anatomy scopes. */
+    readonly id: string;
+    /** Resolve the id for a specific part (for ARIA wiring). */
+    idFor(part: P): string;
+    /** Build the common data-attrs + id for a part. */
+    attrs(part: P): {
+        id: string;
+        'data-scope': string;
+        'data-part': P;
+    };
+}
+export interface Anatomy<P extends string> {
+    readonly name: string;
+    readonly parts: readonly P[];
+    /** Create a new scope instance. Pass an explicit id to force a value (SSR). */
+    scope(id?: string): AnatomyScope<P>;
+}
+export declare function anatomy<P extends string>(name: string, parts: readonly P[]): Anatomy<P>;
+//# sourceMappingURL=anatomy.d.ts.map

package/dist/utils/anatomy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anatomy.d.ts","sourceRoot":"","sources":["../../src/utils/anatomy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,kDAAkD;AAClD,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C;AAED,MAAM,WAAW,YAAY,CAAC,CAAC,SAAS,MAAM;IAC5C,sDAAsD;IACtD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,4DAA4D;IAC5D,KAAK,CAAC,IAAI,EAAE,CAAC,GAAG,MAAM,CAAA;IACtB,mDAAmD;IACnD,KAAK,CAAC,IAAI,EAAE,CAAC,GAAG;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,CAAC,CAAA;KAAE,CAAA;CACrE;AAED,MAAM,WAAW,OAAO,CAAC,CAAC,SAAS,MAAM;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,CAAA;IAC5B,+EAA+E;IAC/E,KAAK,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,CAAA;CACpC;AAED,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAiBvF"}

package/dist/utils/anatomy.js

@@ -0,0 +1,41 @@
+/**
+ * Anatomy — describes a component's parts and assigns unique ids per instance.
+ *
+ * Each component (dialog, menu, tabs, ...) declares its parts once. Every
+ * mount creates a fresh scope with unique ids used for ARIA wiring
+ * (`aria-controls`, `aria-labelledby`) and `data-scope`/`data-part` for CSS.
+ *
+ * ```ts
+ * const DialogAnatomy = anatomy('dialog', [
+ *   'trigger', 'positioner', 'backdrop', 'content', 'title', 'description', 'closeTrigger',
+ * ] as const)
+ *
+ * // Per instance:
+ * const parts = DialogAnatomy.scope()
+ * parts.attrs('trigger')       // { id: 'dialog-1:trigger', 'data-scope': 'dialog', 'data-part': 'trigger' }
+ * parts.idFor('content')       // 'dialog-1:content'
+ * ```
+ */
+let counter = 0;
+/** Reset the internal id counter — tests only. */
+export function resetAnatomyIdCounter() {
+    counter = 0;
+}
+export function anatomy(name, parts) {
+    return {
+        name,
+        parts,
+        scope(id) {
+            const scopeId = id ?? `${name}-${++counter}`;
+            return {
+                id: scopeId,
+                idFor: (part) => `${scopeId}:${part}`,
+                attrs: (part) => ({
+                    id: `${scopeId}:${part}`,
+                    'data-scope': name,
+                    'data-part': part,
+                }),
+            };
+        },
+    };
+}

package/dist/utils/aria-hidden.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Hide sibling subtrees from assistive tech while an overlay is open.
+ *
+ * Walks from `target` up to the document root, applying `aria-hidden="true"`
+ * and `inert` to every sibling at each level. Previous attribute values are
+ * recorded and restored on cleanup.
+ *
+ * Nested calls are supported — each layer only touches elements that haven't
+ * been claimed by a higher layer (tracked via a WeakMap reference count).
+ */
+export declare function setAriaHiddenOutside(target: Element): () => void;
+//# sourceMappingURL=aria-hidden.d.ts.map

package/dist/utils/aria-hidden.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aria-hidden.d.ts","sourceRoot":"","sources":["../../src/utils/aria-hidden.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAUH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,CAoChE"}