@llui/components 0.0.1

package/dist/utils/aria-hidden.js

@@ -0,0 +1,72 @@
+/**
+ * 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).
+ */
+const ownership = new WeakMap();
+const snapshots = new WeakMap();
+export function setAriaHiddenOutside(target) {
+    if (typeof document === 'undefined')
+        return () => { };
+    const claimed = [];
+    walkSiblings(target, (sibling) => {
+        const count = ownership.get(sibling) ?? 0;
+        if (count === 0) {
+            snapshots.set(sibling, {
+                ariaHidden: sibling.getAttribute('aria-hidden'),
+                inert: sibling.getAttribute('inert'),
+            });
+            sibling.setAttribute('aria-hidden', 'true');
+            sibling.setAttribute('inert', '');
+        }
+        ownership.set(sibling, count + 1);
+        claimed.push(sibling);
+    });
+    return () => {
+        for (const el of claimed) {
+            const count = (ownership.get(el) ?? 1) - 1;
+            if (count <= 0) {
+                ownership.delete(el);
+                const snap = snapshots.get(el);
+                snapshots.delete(el);
+                if (snap) {
+                    if (snap.ariaHidden === null)
+                        el.removeAttribute('aria-hidden');
+                    else
+                        el.setAttribute('aria-hidden', snap.ariaHidden);
+                    if (snap.inert === null)
+                        el.removeAttribute('inert');
+                    else
+                        el.setAttribute('inert', snap.inert);
+                }
+            }
+            else {
+                ownership.set(el, count);
+            }
+        }
+    };
+}
+function walkSiblings(target, visit) {
+    let node = target;
+    while (node && node !== document.body && node !== document.documentElement) {
+        const parent = node.parentElement;
+        if (!parent)
+            break;
+        const siblings = Array.from(parent.children);
+        for (const child of siblings) {
+            if (child !== node && !shouldSkip(child)) {
+                visit(child);
+            }
+        }
+        node = parent;
+    }
+}
+function shouldSkip(el) {
+    const tag = el.tagName.toLowerCase();
+    return tag === 'script' || tag === 'style' || tag === 'link' || tag === 'meta' || tag === 'title';
+}

package/dist/utils/dismissable.d.ts

@@ -0,0 +1,25 @@
+import type { ElementSource } from './dom';
+/**
+ * Reason a dismissable layer was closed.
+ */
+export type DismissSource = 'escape' | 'outside';
+export interface DismissableOptions {
+    /** The layer element (e.g. a dialog content or popover). */
+    element: ElementSource;
+    /** Trigger / anchor elements that should not count as outside interactions. */
+    ignore?: ElementSource;
+    /** Called when the user dismisses the layer. */
+    onDismiss: (source: DismissSource, event: Event) => void;
+    /** Disable outside-click dismissal (default: false). */
+    disableOutside?: boolean;
+    /** Disable Escape-key dismissal (default: false). */
+    disableEscape?: boolean;
+}
+/**
+ * Register a dismissable layer. Handles Escape (topmost only) and
+ * outside-click. Returns a cleanup that removes the layer from the stack.
+ */
+export declare function pushDismissable(opts: DismissableOptions): () => void;
+/** @internal — for tests */
+export declare function _dismissableStackSize(): number;
+//# sourceMappingURL=dismissable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dismissable.d.ts","sourceRoot":"","sources":["../../src/utils/dismissable.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAE1C;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,SAAS,CAAA;AAEhD,MAAM,WAAW,kBAAkB;IACjC,4DAA4D;IAC5D,OAAO,EAAE,aAAa,CAAA;IACtB,+EAA+E;IAC/E,MAAM,CAAC,EAAE,aAAa,CAAA;IACtB,gDAAgD;IAChD,SAAS,EAAE,CAAC,MAAM,EAAE,aAAa,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;IACxD,wDAAwD;IACxD,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,qDAAqD;IACrD,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB;AAgCD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,kBAAkB,GAAG,MAAM,IAAI,CA6BpE;AAED,4BAA4B;AAC5B,wBAAgB,qBAAqB,IAAI,MAAM,CAE9C"}

package/dist/utils/dismissable.js

@@ -0,0 +1,65 @@
+import { watchInteractOutside } from './interact-outside';
+// Global stack — topmost layer gets to process events first. Only the
+// topmost claims the escape key.
+const stack = [];
+let keyListenerAttached = false;
+function handleKeydown(event) {
+    if (event.key !== 'Escape')
+        return;
+    const top = stack[stack.length - 1];
+    if (!top)
+        return;
+    const claimed = top.handleEscape(event);
+    if (claimed)
+        event.stopPropagation();
+}
+function ensureKeyListener() {
+    if (keyListenerAttached || typeof document === 'undefined')
+        return;
+    document.addEventListener('keydown', handleKeydown, true);
+    keyListenerAttached = true;
+}
+function maybeRemoveKeyListener() {
+    if (stack.length > 0 || !keyListenerAttached || typeof document === 'undefined')
+        return;
+    document.removeEventListener('keydown', handleKeydown, true);
+    keyListenerAttached = false;
+}
+/**
+ * Register a dismissable layer. Handles Escape (topmost only) and
+ * outside-click. Returns a cleanup that removes the layer from the stack.
+ */
+export function pushDismissable(opts) {
+    ensureKeyListener();
+    const layer = {
+        element: opts.element,
+        handleEscape(event) {
+            if (opts.disableEscape)
+                return false;
+            opts.onDismiss('escape', event);
+            return true;
+        },
+    };
+    stack.push(layer);
+    let cleanupOutside = null;
+    if (!opts.disableOutside) {
+        cleanupOutside = watchInteractOutside({
+            element: opts.element,
+            ignore: opts.ignore,
+            shouldDispatch: () => stack[stack.length - 1] === layer,
+            onInteractOutside: (event) => opts.onDismiss('outside', event),
+        });
+    }
+    return () => {
+        const idx = stack.indexOf(layer);
+        if (idx !== -1)
+            stack.splice(idx, 1);
+        if (cleanupOutside)
+            cleanupOutside();
+        maybeRemoveKeyListener();
+    };
+}
+/** @internal — for tests */
+export function _dismissableStackSize() {
+    return stack.length;
+}

package/dist/utils/dom.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Shared DOM helpers used by interaction utilities.
+ */
+export type ElementSource<T extends Element = Element> = T | T[] | (() => T | T[] | null);
+export declare function resolveElements<T extends Element>(source: ElementSource<T>): T[];
+export declare function containsOrEquals(container: Element, target: Node | null): boolean;
+export declare function isInAnyElement(target: Node | null, elements: Element[]): boolean;
+//# sourceMappingURL=dom.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dom.d.ts","sourceRoot":"","sources":["../../src/utils/dom.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC,CAAA;AAEzF,wBAAgB,eAAe,CAAC,CAAC,SAAS,OAAO,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAIhF;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,GAAG,IAAI,GAAG,OAAO,CAGjF;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,IAAI,GAAG,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,CAKhF"}

package/dist/utils/dom.js

@@ -0,0 +1,21 @@
+/**
+ * Shared DOM helpers used by interaction utilities.
+ */
+export function resolveElements(source) {
+    const resolved = typeof source === 'function' ? source() : source;
+    if (!resolved)
+        return [];
+    return Array.isArray(resolved) ? resolved : [resolved];
+}
+export function containsOrEquals(container, target) {
+    if (!target)
+        return false;
+    return container === target || container.contains(target);
+}
+export function isInAnyElement(target, elements) {
+    for (const el of elements) {
+        if (containsOrEquals(el, target))
+            return true;
+    }
+    return false;
+}

package/dist/utils/floating.d.ts

@@ -0,0 +1,44 @@
+import { type Placement } from '@floating-ui/dom';
+/**
+ * Thin wrapper around `@floating-ui/dom` for anchored positioning. Used by
+ * popover, tooltip, menu, and any other component that attaches a floating
+ * element to an anchor.
+ *
+ * Returns a cleanup function that removes scroll/resize listeners and stops
+ * position updates.
+ */
+export type { Placement };
+export interface FloatingOptions {
+    /** The reference element (trigger/anchor). */
+    anchor: Element;
+    /** The floating element (content). */
+    floating: HTMLElement;
+    /** Preferred placement (default: 'bottom'). */
+    placement?: Placement;
+    /** Gap between anchor and floating, in px (default: 0). */
+    offset?: number;
+    /** Flip to opposite side when there isn't enough room (default: true). */
+    flip?: boolean;
+    /** Shift along axis to stay in view (default: padding 8 unless false). */
+    shift?: boolean | {
+        padding?: number;
+    };
+    /** Optional arrow element to position. */
+    arrow?: HTMLElement;
+    /** Notify after each position computation. */
+    onUpdate?: (data: {
+        x: number;
+        y: number;
+        placement: Placement;
+        arrow?: {
+            x?: number;
+            y?: number;
+        };
+    }) => void;
+}
+/**
+ * Position `floating` relative to `anchor` with live updates on scroll/resize.
+ * Applies `left` + `top` styles to the floating element. Returns a cleanup.
+ */
+export declare function attachFloating(opts: FloatingOptions): () => void;
+//# sourceMappingURL=floating.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floating.d.ts","sourceRoot":"","sources":["../../src/utils/floating.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,SAAS,EAEf,MAAM,kBAAkB,CAAA;AAEzB;;;;;;;GAOG;AAEH,YAAY,EAAE,SAAS,EAAE,CAAA;AAEzB,MAAM,WAAW,eAAe;IAC9B,8CAA8C;IAC9C,MAAM,EAAE,OAAO,CAAA;IACf,sCAAsC;IACtC,QAAQ,EAAE,WAAW,CAAA;IACrB,+CAA+C;IAC/C,SAAS,CAAC,EAAE,SAAS,CAAA;IACrB,2DAA2D;IAC3D,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,0EAA0E;IAC1E,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,0EAA0E;IAC1E,KAAK,CAAC,EAAE,OAAO,GAAG;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IACtC,0CAA0C;IAC1C,KAAK,CAAC,EAAE,WAAW,CAAA;IACnB,8CAA8C;IAC9C,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE;QAChB,CAAC,EAAE,MAAM,CAAA;QACT,CAAC,EAAE,MAAM,CAAA;QACT,SAAS,EAAE,SAAS,CAAA;QACpB,KAAK,CAAC,EAAE;YAAE,CAAC,CAAC,EAAE,MAAM,CAAC;YAAC,CAAC,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KACnC,KAAK,IAAI,CAAA;CACX;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,IAAI,CAgDhE"}

package/dist/utils/floating.js

@@ -0,0 +1,44 @@
+import { computePosition, autoUpdate, offset as offsetMw, flip as flipMw, shift as shiftMw, arrow as arrowMw, } from '@floating-ui/dom';
+/**
+ * Position `floating` relative to `anchor` with live updates on scroll/resize.
+ * Applies `left` + `top` styles to the floating element. Returns a cleanup.
+ */
+export function attachFloating(opts) {
+    const { anchor, floating, placement = 'bottom', offset = 0, flip = true, shift = true, arrow, onUpdate, } = opts;
+    const middleware = [];
+    if (offset > 0)
+        middleware.push(offsetMw(offset));
+    if (flip)
+        middleware.push(flipMw());
+    if (shift !== false) {
+        const padding = typeof shift === 'object' ? (shift.padding ?? 8) : 8;
+        middleware.push(shiftMw({ padding }));
+    }
+    if (arrow)
+        middleware.push(arrowMw({ element: arrow }));
+    floating.style.position = 'absolute';
+    floating.style.top = '0';
+    floating.style.left = '0';
+    const update = () => {
+        void computePosition(anchor, floating, { placement, middleware }).then(({ x, y, placement: actual, middlewareData }) => {
+            floating.style.transform = `translate(${Math.round(x)}px, ${Math.round(y)}px)`;
+            floating.dataset.placement = actual;
+            if (arrow && middlewareData.arrow) {
+                const { x: ax, y: ay } = middlewareData.arrow;
+                if (ax != null)
+                    arrow.style.left = `${ax}px`;
+                if (ay != null)
+                    arrow.style.top = `${ay}px`;
+            }
+            onUpdate?.({
+                x,
+                y,
+                placement: actual,
+                arrow: middlewareData.arrow
+                    ? { x: middlewareData.arrow.x, y: middlewareData.arrow.y }
+                    : undefined,
+            });
+        });
+    };
+    return autoUpdate(anchor, floating, update);
+}

package/dist/utils/focus-trap.d.ts

@@ -0,0 +1,18 @@
+import { type ElementSource } from './dom';
+export interface FocusTrapOptions {
+    /** The container whose focusable descendants form the trap. */
+    container: ElementSource;
+    /** Element to focus when the trap activates. Defaults to first focusable. */
+    initialFocus?: Element | (() => Element | null);
+    /** Restore focus to the previously active element on release (default: true). */
+    restoreFocus?: boolean;
+}
+/**
+ * Push a focus trap onto the stack. Tab/Shift+Tab will cycle within the
+ * container's focusable descendants. Returns a cleanup that removes the
+ * trap and (optionally) restores focus to the element active before push.
+ */
+export declare function pushFocusTrap(opts: FocusTrapOptions): () => void;
+/** @internal — tests only */
+export declare function _focusTrapStackSize(): number;
+//# sourceMappingURL=focus-trap.d.ts.map

package/dist/utils/focus-trap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"focus-trap.d.ts","sourceRoot":"","sources":["../../src/utils/focus-trap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,OAAO,CAAA;AAG3D,MAAM,WAAW,gBAAgB;IAC/B,+DAA+D;IAC/D,SAAS,EAAE,aAAa,CAAA;IACxB,6EAA6E;IAC7E,YAAY,CAAC,EAAE,OAAO,GAAG,CAAC,MAAM,OAAO,GAAG,IAAI,CAAC,CAAA;IAC/C,iFAAiF;IACjF,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB;AAsDD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,gBAAgB,GAAG,MAAM,IAAI,CA2BhE;AAED,6BAA6B;AAC7B,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C"}

package/dist/utils/focus-trap.js

@@ -0,0 +1,85 @@
+import { resolveElements } from './dom';
+import { getFocusables } from './focusables';
+const stack = [];
+let keyListenerAttached = false;
+function handleKeydown(event) {
+    if (event.key !== 'Tab')
+        return;
+    const top = stack[stack.length - 1];
+    if (!top)
+        return;
+    const containers = resolveElements(top.container);
+    if (containers.length === 0)
+        return;
+    // Combine focusables from all container elements.
+    const focusables = [];
+    for (const c of containers)
+        focusables.push(...getFocusables(c));
+    if (focusables.length === 0) {
+        event.preventDefault();
+        return;
+    }
+    const first = focusables[0];
+    const last = focusables[focusables.length - 1];
+    const active = document.activeElement;
+    const isInside = active ? containers.some((c) => c.contains(active)) : false;
+    if (event.shiftKey) {
+        if (!isInside || active === first) {
+            event.preventDefault();
+            last.focus();
+        }
+    }
+    else {
+        if (!isInside || active === last) {
+            event.preventDefault();
+            first.focus();
+        }
+    }
+}
+function ensureListener() {
+    if (keyListenerAttached || typeof document === 'undefined')
+        return;
+    document.addEventListener('keydown', handleKeydown, true);
+    keyListenerAttached = true;
+}
+function maybeRemoveListener() {
+    if (stack.length > 0 || !keyListenerAttached || typeof document === 'undefined')
+        return;
+    document.removeEventListener('keydown', handleKeydown, true);
+    keyListenerAttached = false;
+}
+/**
+ * Push a focus trap onto the stack. Tab/Shift+Tab will cycle within the
+ * container's focusable descendants. Returns a cleanup that removes the
+ * trap and (optionally) restores focus to the element active before push.
+ */
+export function pushFocusTrap(opts) {
+    const restoreFocus = opts.restoreFocus !== false;
+    const previouslyFocused = restoreFocus ? document.activeElement : null;
+    ensureListener();
+    const trap = { container: opts.container };
+    stack.push(trap);
+    // Move focus inside the trap
+    const containers = resolveElements(opts.container);
+    const initial = typeof opts.initialFocus === 'function' ? opts.initialFocus() : (opts.initialFocus ?? null);
+    if (initial && initial instanceof HTMLElement) {
+        initial.focus();
+    }
+    else if (containers.length > 0) {
+        const focusables = getFocusables(containers[0]);
+        focusables[0]?.focus();
+    }
+    return () => {
+        const idx = stack.indexOf(trap);
+        if (idx !== -1)
+            stack.splice(idx, 1);
+        maybeRemoveListener();
+        if (restoreFocus && previouslyFocused && typeof previouslyFocused.focus === 'function') {
+            previouslyFocused.focus();
+        }
+    };
+}
+/** @internal — tests only */
+export function _focusTrapStackSize() {
+    return stack.length;
+}

package/dist/utils/focusables.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Find focusable descendants within a container.
+ */
+export declare function isFocusable(el: Element): boolean;
+export declare function getFocusables(container: Element): HTMLElement[];
+//# sourceMappingURL=focusables.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"focusables.d.ts","sourceRoot":"","sources":["../../src/utils/focusables.ts"],"names":[],"mappings":"AAAA;;GAEG;AAqBH,wBAAgB,WAAW,CAAC,EAAE,EAAE,OAAO,GAAG,OAAO,CAShD;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,OAAO,GAAG,WAAW,EAAE,CAO/D"}

package/dist/utils/focusables.js

@@ -0,0 +1,65 @@
+/**
+ * Find focusable descendants within a container.
+ */
+// Matches elements that can receive keyboard focus. Excludes elements with
+// `tabindex=-1` (programmatically focusable but not tab-reachable) and
+// elements inside `inert` subtrees.
+const FOCUSABLE_SELECTOR = [
+    'a[href]',
+    'area[href]',
+    'button:not([disabled])',
+    'input:not([disabled]):not([type="hidden"])',
+    'select:not([disabled])',
+    'textarea:not([disabled])',
+    'iframe',
+    'object',
+    'embed',
+    'audio[controls]',
+    'video[controls]',
+    '[contenteditable]:not([contenteditable="false"])',
+    '[tabindex]:not([tabindex="-1"])',
+].join(',');
+export function isFocusable(el) {
+    if (!(el instanceof HTMLElement))
+        return false;
+    if (el.hasAttribute('disabled'))
+        return false;
+    if (el.getAttribute('aria-hidden') === 'true')
+        return false;
+    if (el.hidden)
+        return false;
+    // Check tabindex
+    const tabIndex = el.getAttribute('tabindex');
+    if (tabIndex !== null && parseInt(tabIndex, 10) < 0)
+        return false;
+    return el.matches(FOCUSABLE_SELECTOR);
+}
+export function getFocusables(container) {
+    const nodes = Array.from(container.querySelectorAll(FOCUSABLE_SELECTOR));
+    const out = [];
+    for (const n of nodes) {
+        if (isVisible(n) && !isInsideInert(n, container))
+            out.push(n);
+    }
+    return out;
+}
+function isVisible(el) {
+    if (el.hidden)
+        return false;
+    // offsetParent is null for display:none (not position:fixed roots, but good enough)
+    // jsdom returns null for disconnected; skip this check there.
+    if (typeof el.offsetParent === 'undefined')
+        return true;
+    // For root elements with position:fixed, offsetParent can be null but they're visible.
+    // Use getClientRects as a fallback. jsdom returns empty rects, so accept those.
+    return true;
+}
+function isInsideInert(el, container) {
+    let current = el;
+    while (current && current !== container) {
+        if (current.hasAttribute('inert'))
+            return true;
+        current = current.parentElement;
+    }
+    return false;
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,18 @@
+export { anatomy, resetAnatomyIdCounter } from './anatomy';
+export type { Anatomy, AnatomyScope } from './anatomy';
+export { watchInteractOutside } from './interact-outside';
+export type { InteractOutsideOptions } from './interact-outside';
+export { pushDismissable } from './dismissable';
+export type { DismissableOptions, DismissSource } from './dismissable';
+export { pushFocusTrap } from './focus-trap';
+export type { FocusTrapOptions } from './focus-trap';
+export { setAriaHiddenOutside } from './aria-hidden';
+export { lockBodyScroll } from './remove-scroll';
+export { getFocusables, isFocusable } from './focusables';
+export type { ElementSource } from './dom';
+export { attachFloating } from './floating';
+export type { FloatingOptions, Placement } from './floating';
+export { typeaheadAccumulate, typeaheadMatch, typeaheadMatchByItems, isTypeaheadKey, TYPEAHEAD_TIMEOUT_MS, } from './typeahead';
+export { TreeCollection } from './tree-collection';
+export type { TreeNode } from './tree-collection';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAA;AAC1D,YAAY,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAEtD,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AACzD,YAAY,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAA;AAEhE,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAC/C,YAAY,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAEtE,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAC5C,YAAY,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAEpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAA;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAEhD,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AACzD,YAAY,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAE1C,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAC3C,YAAY,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAE5D,OAAO,EACL,mBAAmB,EACnB,cAAc,EACd,qBAAqB,EACrB,cAAc,EACd,oBAAoB,GACrB,MAAM,aAAa,CAAA;AAEpB,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAClD,YAAY,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA"}

package/dist/utils/index.js

@@ -0,0 +1,10 @@
+export { anatomy, resetAnatomyIdCounter } from './anatomy';
+export { watchInteractOutside } from './interact-outside';
+export { pushDismissable } from './dismissable';
+export { pushFocusTrap } from './focus-trap';
+export { setAriaHiddenOutside } from './aria-hidden';
+export { lockBodyScroll } from './remove-scroll';
+export { getFocusables, isFocusable } from './focusables';
+export { attachFloating } from './floating';
+export { typeaheadAccumulate, typeaheadMatch, typeaheadMatchByItems, isTypeaheadKey, TYPEAHEAD_TIMEOUT_MS, } from './typeahead';
+export { TreeCollection } from './tree-collection';

package/dist/utils/interact-outside.d.ts

@@ -0,0 +1,26 @@
+import { type ElementSource } from './dom';
+export interface InteractOutsideOptions {
+    /** Element(s) that define the "inside" region. */
+    element: ElementSource;
+    /** Additional elements whose interactions should not count as outside (e.g. triggers). */
+    ignore?: ElementSource;
+    /** Called on pointerdown or focus outside the inside region. */
+    onInteractOutside: (event: Event) => void;
+    /**
+     * If provided, called first with the event. Return `false` to suppress the
+     * outside callback (for an in-flight layer to claim the event).
+     */
+    shouldDispatch?: (event: Event) => boolean;
+}
+/**
+ * Watch for pointer or focus events outside a given element. Returns a
+ * cleanup function. Uses the capture phase so upstream `stopPropagation`
+ * calls cannot hide events.
+ *
+ * - pointerdown (or mousedown/touchstart fallback) triggers "outside" if the
+ *   target is not contained by `element` or `ignore`.
+ * - focusin triggers "outside" when focus moves outside the element, except
+ *   when the new target is in `ignore`.
+ */
+export declare function watchInteractOutside(opts: InteractOutsideOptions): () => void;
+//# sourceMappingURL=interact-outside.d.ts.map

package/dist/utils/interact-outside.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interact-outside.d.ts","sourceRoot":"","sources":["../../src/utils/interact-outside.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmC,KAAK,aAAa,EAAE,MAAM,OAAO,CAAA;AAE3E,MAAM,WAAW,sBAAsB;IACrC,kDAAkD;IAClD,OAAO,EAAE,aAAa,CAAA;IACtB,0FAA0F;IAC1F,MAAM,CAAC,EAAE,aAAa,CAAA;IACtB,gEAAgE;IAChE,iBAAiB,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;IACzC;;;OAGG;IACH,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAA;CAC3C;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,sBAAsB,GAAG,MAAM,IAAI,CA+B7E"}

package/dist/utils/interact-outside.js

@@ -0,0 +1,46 @@
+import { resolveElements, isInAnyElement } from './dom';
+/**
+ * Watch for pointer or focus events outside a given element. Returns a
+ * cleanup function. Uses the capture phase so upstream `stopPropagation`
+ * calls cannot hide events.
+ *
+ * - pointerdown (or mousedown/touchstart fallback) triggers "outside" if the
+ *   target is not contained by `element` or `ignore`.
+ * - focusin triggers "outside" when focus moves outside the element, except
+ *   when the new target is in `ignore`.
+ */
+export function watchInteractOutside(opts) {
+    if (typeof document === 'undefined')
+        return () => { };
+    const handlePointer = (event) => {
+        if (opts.shouldDispatch && !opts.shouldDispatch(event))
+            return;
+        const target = event.target;
+        const inside = resolveElements(opts.element);
+        if (isInAnyElement(target, inside))
+            return;
+        const ignore = opts.ignore ? resolveElements(opts.ignore) : [];
+        if (isInAnyElement(target, ignore))
+            return;
+        opts.onInteractOutside(event);
+    };
+    const handleFocus = (event) => {
+        if (opts.shouldDispatch && !opts.shouldDispatch(event))
+            return;
+        const target = event.target;
+        const inside = resolveElements(opts.element);
+        if (isInAnyElement(target, inside))
+            return;
+        const ignore = opts.ignore ? resolveElements(opts.ignore) : [];
+        if (isInAnyElement(target, ignore))
+            return;
+        opts.onInteractOutside(event);
+    };
+    // Prefer pointerdown (unified); fall back already covered by pointer events.
+    document.addEventListener('pointerdown', handlePointer, true);
+    document.addEventListener('focusin', handleFocus, true);
+    return () => {
+        document.removeEventListener('pointerdown', handlePointer, true);
+        document.removeEventListener('focusin', handleFocus, true);
+    };
+}

package/dist/utils/remove-scroll.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Lock body scroll while an overlay is open, preserving scrollbar width to
+ * avoid layout shift. Reference-counted so nested locks compose cleanly.
+ */
+export declare function lockBodyScroll(): () => void;
+/** @internal — tests only */
+export declare function _scrollLockCount(): number;
+//# sourceMappingURL=remove-scroll.d.ts.map

package/dist/utils/remove-scroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-scroll.d.ts","sourceRoot":"","sources":["../../src/utils/remove-scroll.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAUH,wBAAgB,cAAc,IAAI,MAAM,IAAI,CAyB3C;AAED,6BAA6B;AAC7B,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC"}

package/dist/utils/remove-scroll.js

@@ -0,0 +1,37 @@
+/**
+ * Lock body scroll while an overlay is open, preserving scrollbar width to
+ * avoid layout shift. Reference-counted so nested locks compose cleanly.
+ */
+let lockCount = 0;
+let snapshot = null;
+export function lockBodyScroll() {
+    if (typeof document === 'undefined')
+        return () => { };
+    lockCount++;
+    if (lockCount === 1) {
+        const body = document.body;
+        const scrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
+        snapshot = {
+            bodyOverflow: body.style.overflow,
+            bodyPaddingRight: body.style.paddingRight,
+        };
+        body.style.overflow = 'hidden';
+        if (scrollbarWidth > 0) {
+            const current = parseInt(getComputedStyle(body).paddingRight || '0', 10) || 0;
+            body.style.paddingRight = `${current + scrollbarWidth}px`;
+        }
+    }
+    return () => {
+        lockCount = Math.max(0, lockCount - 1);
+        if (lockCount === 0 && snapshot) {
+            const body = document.body;
+            body.style.overflow = snapshot.bodyOverflow;
+            body.style.paddingRight = snapshot.bodyPaddingRight;
+            snapshot = null;
+        }
+    };
+}
+/** @internal — tests only */
+export function _scrollLockCount() {
+    return lockCount;
+}