@viax.io/uxm 4.36.0

package/dist/hooks/use-dismiss.d.ts

@@ -0,0 +1,53 @@
+import { type RefObject } from 'react';
+export interface UseDismissOptions {
+    /** Only attach listeners while true. */
+    enabled: boolean;
+    /** Called when the user requests dismissal (Escape or outside click). */
+    onDismiss: () => void;
+    /**
+     * Refs whose elements are considered "inside" — clicks landing on these
+     * (or their descendants) do NOT dismiss. Pass the trigger AND the panel
+     * for popovers; pass just the panel for modal dialogs (clicks outside
+     * the panel = backdrop = dismiss).
+     *
+     * **Must be a stable/memoized array** (e.g. built with `useMemo`, or a
+     * ref/module-level constant) — it's a direct dependency of the outside-click
+     * effect below, so passing a fresh inline array literal on every render
+     * causes the `mousedown` listener to be torn down and re-subscribed on
+     * every render. See `popover.tsx`'s `dismissRefs` for the pattern.
+     */
+    refs: Array<RefObject<HTMLElement | null>>;
+    /**
+     * Selectors that also count as "inside" via `closest()`. Use for
+     * portaled child floating layers — a popover/listbox opened INSIDE a
+     * dialog mounts to `document.body`, so it's not a DOM descendant of
+     * the dialog's panel ref. Without this, picking an option in a nested
+     * dropdown would dismiss the surrounding dialog.
+     *
+     * Conventional list for dialog-like consumers: `[".uxm-popover"]`.
+     */
+    excludeClosest?: string[];
+    /** Default true. */
+    closeOnEscape?: boolean;
+    /** Default true. */
+    closeOnOutsideClick?: boolean;
+}
+/**
+ * Shared dismissal primitive for floating UI (popovers, dialogs, date/time
+ * pickers). Replaces three near-identical copies that previously lived
+ * across popover.tsx, date-input.tsx, and time-input.tsx.
+ *
+ * Why `mousedown` rather than `click`: mousedown fires BEFORE focus
+ * shifts, so clicking a different focusable element closes us cleanly
+ * without leaving the floating panel briefly focused.
+ *
+ * Why `stopPropagation` on Escape: nested floating things (popover
+ * inside a dialog) should close one layer at a time. The innermost
+ * handler stops propagation so the outer's Escape doesn't also fire.
+ *
+ * Caller contract: `refs` (and `excludeClosest`, if passed) must be
+ * stable/memoized — see the `refs` option doc below. An inline array
+ * literal re-subscribes the outside-click listener on every render.
+ */
+export declare function useDismiss({ enabled, onDismiss, refs, excludeClosest, closeOnEscape, closeOnOutsideClick, }: UseDismissOptions): void;
+//# sourceMappingURL=use-dismiss.d.ts.map

package/dist/hooks/use-dismiss.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-dismiss.d.ts","sourceRoot":"","sources":["../../src/hooks/use-dismiss.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAElD,MAAM,WAAW,iBAAiB;IAChC,wCAAwC;IACxC,OAAO,EAAE,OAAO,CAAC;IACjB,yEAAyE;IACzE,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB;;;;;;;;;;;OAWG;IACH,IAAI,EAAE,KAAK,CAAC,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC,CAAC;IAC3C;;;;;;;;OAQG;IACH,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,oBAAoB;IACpB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,oBAAoB;IACpB,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,EACzB,OAAO,EACP,SAAS,EACT,IAAI,EACJ,cAAc,EACd,aAAoB,EACpB,mBAA0B,GAC3B,EAAE,iBAAiB,GAAG,IAAI,CA+B1B"}

package/dist/hooks/use-dismiss.js

@@ -0,0 +1,43 @@
+import { useEffect } from "react";
+function useDismiss({
+  enabled,
+  onDismiss,
+  refs,
+  excludeClosest,
+  closeOnEscape = true,
+  closeOnOutsideClick = true
+}) {
+  useEffect(() => {
+    if (!enabled || !closeOnOutsideClick) return;
+    function onMouseDown(e) {
+      const target = e.target;
+      if (!target) return;
+      for (const ref of refs) {
+        if (ref.current?.contains(target)) return;
+      }
+      if (excludeClosest && target instanceof Element) {
+        for (const selector of excludeClosest) {
+          if (target.closest(selector)) return;
+        }
+      }
+      onDismiss();
+    }
+    document.addEventListener("mousedown", onMouseDown);
+    return () => document.removeEventListener("mousedown", onMouseDown);
+  }, [enabled, closeOnOutsideClick, refs, excludeClosest, onDismiss]);
+  useEffect(() => {
+    if (!enabled || !closeOnEscape) return;
+    function onKeyDown(e) {
+      if (e.key === "Escape") {
+        e.stopPropagation();
+        onDismiss();
+      }
+    }
+    document.addEventListener("keydown", onKeyDown);
+    return () => document.removeEventListener("keydown", onKeyDown);
+  }, [enabled, closeOnEscape, onDismiss]);
+}
+export {
+  useDismiss
+};
+//# sourceMappingURL=use-dismiss.js.map

package/dist/hooks/use-dismiss.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/use-dismiss.ts"],"sourcesContent":["import { useEffect, type RefObject } from 'react';\n\nexport interface UseDismissOptions {\n  /** Only attach listeners while true. */\n  enabled: boolean;\n  /** Called when the user requests dismissal (Escape or outside click). */\n  onDismiss: () => void;\n  /**\n   * Refs whose elements are considered \"inside\" — clicks landing on these\n   * (or their descendants) do NOT dismiss. Pass the trigger AND the panel\n   * for popovers; pass just the panel for modal dialogs (clicks outside\n   * the panel = backdrop = dismiss).\n   *\n   * **Must be a stable/memoized array** (e.g. built with `useMemo`, or a\n   * ref/module-level constant) — it's a direct dependency of the outside-click\n   * effect below, so passing a fresh inline array literal on every render\n   * causes the `mousedown` listener to be torn down and re-subscribed on\n   * every render. See `popover.tsx`'s `dismissRefs` for the pattern.\n   */\n  refs: Array<RefObject<HTMLElement | null>>;\n  /**\n   * Selectors that also count as \"inside\" via `closest()`. Use for\n   * portaled child floating layers — a popover/listbox opened INSIDE a\n   * dialog mounts to `document.body`, so it's not a DOM descendant of\n   * the dialog's panel ref. Without this, picking an option in a nested\n   * dropdown would dismiss the surrounding dialog.\n   *\n   * Conventional list for dialog-like consumers: `[\".uxm-popover\"]`.\n   */\n  excludeClosest?: string[];\n  /** Default true. */\n  closeOnEscape?: boolean;\n  /** Default true. */\n  closeOnOutsideClick?: boolean;\n}\n\n/**\n * Shared dismissal primitive for floating UI (popovers, dialogs, date/time\n * pickers). Replaces three near-identical copies that previously lived\n * across popover.tsx, date-input.tsx, and time-input.tsx.\n *\n * Why `mousedown` rather than `click`: mousedown fires BEFORE focus\n * shifts, so clicking a different focusable element closes us cleanly\n * without leaving the floating panel briefly focused.\n *\n * Why `stopPropagation` on Escape: nested floating things (popover\n * inside a dialog) should close one layer at a time. The innermost\n * handler stops propagation so the outer's Escape doesn't also fire.\n *\n * Caller contract: `refs` (and `excludeClosest`, if passed) must be\n * stable/memoized — see the `refs` option doc below. An inline array\n * literal re-subscribes the outside-click listener on every render.\n */\nexport function useDismiss({\n  enabled,\n  onDismiss,\n  refs,\n  excludeClosest,\n  closeOnEscape = true,\n  closeOnOutsideClick = true,\n}: UseDismissOptions): void {\n  useEffect(() => {\n    if (!enabled || !closeOnOutsideClick) return;\n    function onMouseDown(e: MouseEvent) {\n      const target = e.target as Node | null;\n      if (!target) return;\n      for (const ref of refs) {\n        if (ref.current?.contains(target)) return;\n      }\n      if (excludeClosest && target instanceof Element) {\n        for (const selector of excludeClosest) {\n          if (target.closest(selector)) return;\n        }\n      }\n      onDismiss();\n    }\n    document.addEventListener('mousedown', onMouseDown);\n    return () => document.removeEventListener('mousedown', onMouseDown);\n  }, [enabled, closeOnOutsideClick, refs, excludeClosest, onDismiss]);\n\n  useEffect(() => {\n    if (!enabled || !closeOnEscape) return;\n    function onKeyDown(e: KeyboardEvent) {\n      if (e.key === 'Escape') {\n        e.stopPropagation();\n        onDismiss();\n      }\n    }\n    document.addEventListener('keydown', onKeyDown);\n    return () => document.removeEventListener('keydown', onKeyDown);\n  }, [enabled, closeOnEscape, onDismiss]);\n}\n"],"mappings":"AAAA,SAAS,iBAAiC;AAqDnC,SAAS,WAAW;AAAA,EACzB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,gBAAgB;AAAA,EAChB,sBAAsB;AACxB,GAA4B;AAC1B,YAAU,MAAM;AACd,QAAI,CAAC,WAAW,CAAC,oBAAqB;AACtC,aAAS,YAAY,GAAe;AAClC,YAAM,SAAS,EAAE;AACjB,UAAI,CAAC,OAAQ;AACb,iBAAW,OAAO,MAAM;AACtB,YAAI,IAAI,SAAS,SAAS,MAAM,EAAG;AAAA,MACrC;AACA,UAAI,kBAAkB,kBAAkB,SAAS;AAC/C,mBAAW,YAAY,gBAAgB;AACrC,cAAI,OAAO,QAAQ,QAAQ,EAAG;AAAA,QAChC;AAAA,MACF;AACA,gBAAU;AAAA,IACZ;AACA,aAAS,iBAAiB,aAAa,WAAW;AAClD,WAAO,MAAM,SAAS,oBAAoB,aAAa,WAAW;AAAA,EACpE,GAAG,CAAC,SAAS,qBAAqB,MAAM,gBAAgB,SAAS,CAAC;AAElE,YAAU,MAAM;AACd,QAAI,CAAC,WAAW,CAAC,cAAe;AAChC,aAAS,UAAU,GAAkB;AACnC,UAAI,EAAE,QAAQ,UAAU;AACtB,UAAE,gBAAgB;AAClB,kBAAU;AAAA,MACZ;AAAA,IACF;AACA,aAAS,iBAAiB,WAAW,SAAS;AAC9C,WAAO,MAAM,SAAS,oBAAoB,WAAW,SAAS;AAAA,EAChE,GAAG,CAAC,SAAS,eAAe,SAAS,CAAC;AACxC;","names":[]}

package/dist/hooks/use-focus-on-mount.cjs

@@ -0,0 +1,65 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var use_focus_on_mount_exports = {};
+__export(use_focus_on_mount_exports, {
+  useFocusOnMount: () => useFocusOnMount
+});
+module.exports = __toCommonJS(use_focus_on_mount_exports);
+var import_react = require("react");
+const FOCUSABLE_SELECTOR = [
+  "a[href]",
+  "button:not([disabled])",
+  "input:not([disabled])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  '[tabindex]:not([tabindex="-1"])'
+].join(", ");
+function firstFocusable(root) {
+  if (!root) return null;
+  return root.querySelector(FOCUSABLE_SELECTOR);
+}
+function useFocusOnMount({
+  active,
+  initialFocus,
+  focusFirstIn,
+  returnFocus = true
+}) {
+  const previousActiveRef = (0, import_react.useRef)(null);
+  (0, import_react.useEffect)(() => {
+    if (!active) return;
+    previousActiveRef.current = typeof document !== "undefined" ? document.activeElement : null;
+    const r = requestAnimationFrame(() => {
+      const target = initialFocus?.current ?? firstFocusable(focusFirstIn?.current ?? null);
+      target?.focus();
+    });
+    return () => cancelAnimationFrame(r);
+  }, [active, initialFocus, focusFirstIn]);
+  (0, import_react.useEffect)(() => {
+    if (active || !returnFocus) return;
+    const prev = previousActiveRef.current;
+    if (prev && document.contains(prev)) {
+      prev.focus();
+    }
+  }, [active, returnFocus]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useFocusOnMount
+});
+//# sourceMappingURL=use-focus-on-mount.cjs.map

package/dist/hooks/use-focus-on-mount.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/use-focus-on-mount.ts"],"sourcesContent":["import { useEffect, useRef, type RefObject } from 'react';\n\nexport interface UseFocusOnMountOptions {\n  /** When true, manage focus on activate / deactivate. */\n  active: boolean;\n  /**\n   * Element to focus when `active` flips false → true. If omitted, and\n   * `focusFirstIn` is provided, the first focusable element inside that\n   * container receives focus instead. If both are omitted, no focus\n   * move happens on activate (the consumer manages it externally).\n   */\n  initialFocus?: RefObject<HTMLElement | null>;\n  /**\n   * Container whose first focusable element should receive focus when\n   * `initialFocus` isn't provided. Useful for Dialog where we want SOME\n   * sensible default focus target inside the panel.\n   */\n  focusFirstIn?: RefObject<HTMLElement | null>;\n  /**\n   * Restore focus when `active` flips true → false. Default true. The\n   * hook captures `document.activeElement` at activate time and restores\n   * to it at deactivate time. Pass `false` to opt out (e.g. programmatic\n   * close where focus should stay where it landed).\n   */\n  returnFocus?: boolean;\n}\n\nconst FOCUSABLE_SELECTOR = [\n  'a[href]',\n  'button:not([disabled])',\n  'input:not([disabled])',\n  'select:not([disabled])',\n  'textarea:not([disabled])',\n  '[tabindex]:not([tabindex=\"-1\"])',\n].join(', ');\n\nfunction firstFocusable(root: HTMLElement | null): HTMLElement | null {\n  if (!root) return null;\n  return root.querySelector<HTMLElement>(FOCUSABLE_SELECTOR);\n}\n\n/**\n * Move focus into a floating surface when it opens, and restore focus\n * when it closes. Used by Popover and Dialog — single source of truth so\n * the library has one focus story.\n *\n * Edge cases consciously skipped (v1):\n *  - Elements inside shadow DOM aren't discovered by FOCUSABLE_SELECTOR.\n *    Not used anywhere in modo today.\n *  - If the captured `previousActive` element is removed from the DOM\n *    before deactivate, `.focus()` is a no-op and focus falls to <body>.\n *    Acceptable — better than throwing.\n */\nexport function useFocusOnMount({\n  active,\n  initialFocus,\n  focusFirstIn,\n  returnFocus = true,\n}: UseFocusOnMountOptions): void {\n  const previousActiveRef = useRef<HTMLElement | null>(null);\n\n  useEffect(() => {\n    if (!active) return;\n    previousActiveRef.current =\n      typeof document !== 'undefined'\n        ? (document.activeElement as HTMLElement | null)\n        : null;\n\n    // Defer one frame so the floating element is mounted + positioned\n    // before we focus it. Safari skips focus() on not-yet-attached nodes.\n    const r = requestAnimationFrame(() => {\n      const target =\n        initialFocus?.current ?? firstFocusable(focusFirstIn?.current ?? null);\n      target?.focus();\n    });\n    return () => cancelAnimationFrame(r);\n  }, [active, initialFocus, focusFirstIn]);\n\n  useEffect(() => {\n    if (active || !returnFocus) return;\n    const prev = previousActiveRef.current;\n    // Only restore if the previously-active element is still in the DOM\n    // AND we actually moved focus away from it. Avoids stealing focus\n    // when a programmatic close happens while the user is interacting\n    // with something else.\n    if (prev && document.contains(prev)) {\n      prev.focus();\n    }\n  }, [active, returnFocus]);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAkD;AA2BlD,MAAM,qBAAqB;AAAA,EACzB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,EAAE,KAAK,IAAI;AAEX,SAAS,eAAe,MAA8C;AACpE,MAAI,CAAC,KAAM,QAAO;AAClB,SAAO,KAAK,cAA2B,kBAAkB;AAC3D;AAcO,SAAS,gBAAgB;AAAA,EAC9B;AAAA,EACA;AAAA,EACA;AAAA,EACA,cAAc;AAChB,GAAiC;AAC/B,QAAM,wBAAoB,qBAA2B,IAAI;AAEzD,8BAAU,MAAM;AACd,QAAI,CAAC,OAAQ;AACb,sBAAkB,UAChB,OAAO,aAAa,cACf,SAAS,gBACV;AAIN,UAAM,IAAI,sBAAsB,MAAM;AACpC,YAAM,SACJ,cAAc,WAAW,eAAe,cAAc,WAAW,IAAI;AACvE,cAAQ,MAAM;AAAA,IAChB,CAAC;AACD,WAAO,MAAM,qBAAqB,CAAC;AAAA,EACrC,GAAG,CAAC,QAAQ,cAAc,YAAY,CAAC;AAEvC,8BAAU,MAAM;AACd,QAAI,UAAU,CAAC,YAAa;AAC5B,UAAM,OAAO,kBAAkB;AAK/B,QAAI,QAAQ,SAAS,SAAS,IAAI,GAAG;AACnC,WAAK,MAAM;AAAA,IACb;AAAA,EACF,GAAG,CAAC,QAAQ,WAAW,CAAC;AAC1B;","names":[]}

package/dist/hooks/use-focus-on-mount.d.ts

@@ -0,0 +1,39 @@
+import { type RefObject } from 'react';
+export interface UseFocusOnMountOptions {
+    /** When true, manage focus on activate / deactivate. */
+    active: boolean;
+    /**
+     * Element to focus when `active` flips false → true. If omitted, and
+     * `focusFirstIn` is provided, the first focusable element inside that
+     * container receives focus instead. If both are omitted, no focus
+     * move happens on activate (the consumer manages it externally).
+     */
+    initialFocus?: RefObject<HTMLElement | null>;
+    /**
+     * Container whose first focusable element should receive focus when
+     * `initialFocus` isn't provided. Useful for Dialog where we want SOME
+     * sensible default focus target inside the panel.
+     */
+    focusFirstIn?: RefObject<HTMLElement | null>;
+    /**
+     * Restore focus when `active` flips true → false. Default true. The
+     * hook captures `document.activeElement` at activate time and restores
+     * to it at deactivate time. Pass `false` to opt out (e.g. programmatic
+     * close where focus should stay where it landed).
+     */
+    returnFocus?: boolean;
+}
+/**
+ * Move focus into a floating surface when it opens, and restore focus
+ * when it closes. Used by Popover and Dialog — single source of truth so
+ * the library has one focus story.
+ *
+ * Edge cases consciously skipped (v1):
+ *  - Elements inside shadow DOM aren't discovered by FOCUSABLE_SELECTOR.
+ *    Not used anywhere in modo today.
+ *  - If the captured `previousActive` element is removed from the DOM
+ *    before deactivate, `.focus()` is a no-op and focus falls to <body>.
+ *    Acceptable — better than throwing.
+ */
+export declare function useFocusOnMount({ active, initialFocus, focusFirstIn, returnFocus, }: UseFocusOnMountOptions): void;
+//# sourceMappingURL=use-focus-on-mount.d.ts.map

package/dist/hooks/use-focus-on-mount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-focus-on-mount.d.ts","sourceRoot":"","sources":["../../src/hooks/use-focus-on-mount.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAE1D,MAAM,WAAW,sBAAsB;IACrC,wDAAwD;IACxD,MAAM,EAAE,OAAO,CAAC;IAChB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;IAC7C;;;;OAIG;IACH,YAAY,CAAC,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;IAC7C;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAgBD;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,EAC9B,MAAM,EACN,YAAY,EACZ,YAAY,EACZ,WAAkB,GACnB,EAAE,sBAAsB,GAAG,IAAI,CA+B/B"}

package/dist/hooks/use-focus-on-mount.js

@@ -0,0 +1,41 @@
+import { useEffect, useRef } from "react";
+const FOCUSABLE_SELECTOR = [
+  "a[href]",
+  "button:not([disabled])",
+  "input:not([disabled])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  '[tabindex]:not([tabindex="-1"])'
+].join(", ");
+function firstFocusable(root) {
+  if (!root) return null;
+  return root.querySelector(FOCUSABLE_SELECTOR);
+}
+function useFocusOnMount({
+  active,
+  initialFocus,
+  focusFirstIn,
+  returnFocus = true
+}) {
+  const previousActiveRef = useRef(null);
+  useEffect(() => {
+    if (!active) return;
+    previousActiveRef.current = typeof document !== "undefined" ? document.activeElement : null;
+    const r = requestAnimationFrame(() => {
+      const target = initialFocus?.current ?? firstFocusable(focusFirstIn?.current ?? null);
+      target?.focus();
+    });
+    return () => cancelAnimationFrame(r);
+  }, [active, initialFocus, focusFirstIn]);
+  useEffect(() => {
+    if (active || !returnFocus) return;
+    const prev = previousActiveRef.current;
+    if (prev && document.contains(prev)) {
+      prev.focus();
+    }
+  }, [active, returnFocus]);
+}
+export {
+  useFocusOnMount
+};
+//# sourceMappingURL=use-focus-on-mount.js.map

package/dist/hooks/use-focus-on-mount.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/use-focus-on-mount.ts"],"sourcesContent":["import { useEffect, useRef, type RefObject } from 'react';\n\nexport interface UseFocusOnMountOptions {\n  /** When true, manage focus on activate / deactivate. */\n  active: boolean;\n  /**\n   * Element to focus when `active` flips false → true. If omitted, and\n   * `focusFirstIn` is provided, the first focusable element inside that\n   * container receives focus instead. If both are omitted, no focus\n   * move happens on activate (the consumer manages it externally).\n   */\n  initialFocus?: RefObject<HTMLElement | null>;\n  /**\n   * Container whose first focusable element should receive focus when\n   * `initialFocus` isn't provided. Useful for Dialog where we want SOME\n   * sensible default focus target inside the panel.\n   */\n  focusFirstIn?: RefObject<HTMLElement | null>;\n  /**\n   * Restore focus when `active` flips true → false. Default true. The\n   * hook captures `document.activeElement` at activate time and restores\n   * to it at deactivate time. Pass `false` to opt out (e.g. programmatic\n   * close where focus should stay where it landed).\n   */\n  returnFocus?: boolean;\n}\n\nconst FOCUSABLE_SELECTOR = [\n  'a[href]',\n  'button:not([disabled])',\n  'input:not([disabled])',\n  'select:not([disabled])',\n  'textarea:not([disabled])',\n  '[tabindex]:not([tabindex=\"-1\"])',\n].join(', ');\n\nfunction firstFocusable(root: HTMLElement | null): HTMLElement | null {\n  if (!root) return null;\n  return root.querySelector<HTMLElement>(FOCUSABLE_SELECTOR);\n}\n\n/**\n * Move focus into a floating surface when it opens, and restore focus\n * when it closes. Used by Popover and Dialog — single source of truth so\n * the library has one focus story.\n *\n * Edge cases consciously skipped (v1):\n *  - Elements inside shadow DOM aren't discovered by FOCUSABLE_SELECTOR.\n *    Not used anywhere in modo today.\n *  - If the captured `previousActive` element is removed from the DOM\n *    before deactivate, `.focus()` is a no-op and focus falls to <body>.\n *    Acceptable — better than throwing.\n */\nexport function useFocusOnMount({\n  active,\n  initialFocus,\n  focusFirstIn,\n  returnFocus = true,\n}: UseFocusOnMountOptions): void {\n  const previousActiveRef = useRef<HTMLElement | null>(null);\n\n  useEffect(() => {\n    if (!active) return;\n    previousActiveRef.current =\n      typeof document !== 'undefined'\n        ? (document.activeElement as HTMLElement | null)\n        : null;\n\n    // Defer one frame so the floating element is mounted + positioned\n    // before we focus it. Safari skips focus() on not-yet-attached nodes.\n    const r = requestAnimationFrame(() => {\n      const target =\n        initialFocus?.current ?? firstFocusable(focusFirstIn?.current ?? null);\n      target?.focus();\n    });\n    return () => cancelAnimationFrame(r);\n  }, [active, initialFocus, focusFirstIn]);\n\n  useEffect(() => {\n    if (active || !returnFocus) return;\n    const prev = previousActiveRef.current;\n    // Only restore if the previously-active element is still in the DOM\n    // AND we actually moved focus away from it. Avoids stealing focus\n    // when a programmatic close happens while the user is interacting\n    // with something else.\n    if (prev && document.contains(prev)) {\n      prev.focus();\n    }\n  }, [active, returnFocus]);\n}\n"],"mappings":"AAAA,SAAS,WAAW,cAA8B;AA2BlD,MAAM,qBAAqB;AAAA,EACzB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,EAAE,KAAK,IAAI;AAEX,SAAS,eAAe,MAA8C;AACpE,MAAI,CAAC,KAAM,QAAO;AAClB,SAAO,KAAK,cAA2B,kBAAkB;AAC3D;AAcO,SAAS,gBAAgB;AAAA,EAC9B;AAAA,EACA;AAAA,EACA;AAAA,EACA,cAAc;AAChB,GAAiC;AAC/B,QAAM,oBAAoB,OAA2B,IAAI;AAEzD,YAAU,MAAM;AACd,QAAI,CAAC,OAAQ;AACb,sBAAkB,UAChB,OAAO,aAAa,cACf,SAAS,gBACV;AAIN,UAAM,IAAI,sBAAsB,MAAM;AACpC,YAAM,SACJ,cAAc,WAAW,eAAe,cAAc,WAAW,IAAI;AACvE,cAAQ,MAAM;AAAA,IAChB,CAAC;AACD,WAAO,MAAM,qBAAqB,CAAC;AAAA,EACrC,GAAG,CAAC,QAAQ,cAAc,YAAY,CAAC;AAEvC,YAAU,MAAM;AACd,QAAI,UAAU,CAAC,YAAa;AAC5B,UAAM,OAAO,kBAAkB;AAK/B,QAAI,QAAQ,SAAS,SAAS,IAAI,GAAG;AACnC,WAAK,MAAM;AAAA,IACb;AAAA,EACF,GAAG,CAAC,QAAQ,WAAW,CAAC;AAC1B;","names":[]}

package/dist/hooks/use-focus-trap.cjs

@@ -0,0 +1,78 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var use_focus_trap_exports = {};
+__export(use_focus_trap_exports, {
+  useFocusTrap: () => useFocusTrap
+});
+module.exports = __toCommonJS(use_focus_trap_exports);
+var import_react = require("react");
+const FOCUSABLE_SELECTOR = [
+  "a[href]",
+  "button:not([disabled])",
+  "input:not([disabled])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  '[tabindex]:not([tabindex="-1"])'
+].join(", ");
+function focusableWithin(root) {
+  if (!root) return [];
+  return Array.from(root.querySelectorAll(FOCUSABLE_SELECTOR)).filter(
+    (el) => el.offsetParent !== null || el === document.activeElement
+  );
+}
+function useFocusTrap({ active, container }) {
+  (0, import_react.useEffect)(() => {
+    if (!active) return;
+    function onKeyDown(e) {
+      if (e.key !== "Tab") return;
+      const root = container.current;
+      if (!root) return;
+      const focusables = focusableWithin(root);
+      if (focusables.length === 0) {
+        e.preventDefault();
+        root.focus();
+        return;
+      }
+      const first = focusables[0];
+      const last = focusables[focusables.length - 1];
+      const current = document.activeElement;
+      if (!root.contains(current)) {
+        e.preventDefault();
+        first.focus();
+        return;
+      }
+      if (e.shiftKey && current === first) {
+        e.preventDefault();
+        last.focus();
+        return;
+      }
+      if (!e.shiftKey && current === last) {
+        e.preventDefault();
+        first.focus();
+      }
+    }
+    document.addEventListener("keydown", onKeyDown);
+    return () => document.removeEventListener("keydown", onKeyDown);
+  }, [active, container]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useFocusTrap
+});
+//# sourceMappingURL=use-focus-trap.cjs.map

package/dist/hooks/use-focus-trap.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/use-focus-trap.ts"],"sourcesContent":["import { useEffect, type RefObject } from 'react';\n\nconst FOCUSABLE_SELECTOR = [\n  'a[href]',\n  'button:not([disabled])',\n  'input:not([disabled])',\n  'select:not([disabled])',\n  'textarea:not([disabled])',\n  '[tabindex]:not([tabindex=\"-1\"])',\n].join(', ');\n\nfunction focusableWithin(root: HTMLElement | null): HTMLElement[] {\n  if (!root) return [];\n  return Array.from(root.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR)).filter(\n    (el) => el.offsetParent !== null || el === document.activeElement,\n  );\n}\n\nexport interface UseFocusTrapOptions {\n  active: boolean;\n  /** Container whose focusable descendants form the trap boundary. */\n  container: RefObject<HTMLElement | null>;\n}\n\n/**\n * Trap Tab / Shift+Tab cycling within `container` while `active` is true.\n * Used by Dialog (modal interruption); Popover does NOT use this — popovers\n * are non-modal and Tab should be able to leave them.\n *\n * Implementation: keydown listener at document level (capture phase) so it\n * sees Tab presses regardless of what's currently focused inside the\n * container. On Tab at the last focusable, wrap to first; on Shift+Tab at\n * the first, wrap to last. If focus is somehow OUTSIDE the container while\n * the trap is active, the next Tab pulls it back to the first focusable.\n *\n * Edge cases consciously skipped (v1):\n *  - Focusables added/removed dynamically during the open lifetime are\n *    re-queried on every Tab — correct, but O(n) per keydown. Negligible\n *    for realistic modal contents.\n *  - Elements made focusable via shadow DOM. Not used in modo today.\n *  - User Cmd-Tab / Alt-Tab away from the browser — out of scope; the\n *    trap is intra-document only.\n */\nexport function useFocusTrap({ active, container }: UseFocusTrapOptions): void {\n  useEffect(() => {\n    if (!active) return;\n    function onKeyDown(e: KeyboardEvent) {\n      if (e.key !== 'Tab') return;\n      const root = container.current;\n      if (!root) return;\n      const focusables = focusableWithin(root);\n      if (focusables.length === 0) {\n        // Nothing to focus inside the panel — keep focus on the root\n        // itself so Tab doesn't escape to the page behind. Container\n        // needs tabIndex={-1} for this to succeed; consumers set that.\n        e.preventDefault();\n        root.focus();\n        return;\n      }\n      const first = focusables[0];\n      const last = focusables[focusables.length - 1];\n      const current = document.activeElement as HTMLElement | null;\n\n      if (!root.contains(current)) {\n        e.preventDefault();\n        first.focus();\n        return;\n      }\n      if (e.shiftKey && current === first) {\n        e.preventDefault();\n        last.focus();\n        return;\n      }\n      if (!e.shiftKey && current === last) {\n        e.preventDefault();\n        first.focus();\n      }\n    }\n    document.addEventListener('keydown', onKeyDown);\n    return () => document.removeEventListener('keydown', onKeyDown);\n  }, [active, container]);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA0C;AAE1C,MAAM,qBAAqB;AAAA,EACzB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,EAAE,KAAK,IAAI;AAEX,SAAS,gBAAgB,MAAyC;AAChE,MAAI,CAAC,KAAM,QAAO,CAAC;AACnB,SAAO,MAAM,KAAK,KAAK,iBAA8B,kBAAkB,CAAC,EAAE;AAAA,IACxE,CAAC,OAAO,GAAG,iBAAiB,QAAQ,OAAO,SAAS;AAAA,EACtD;AACF;AA2BO,SAAS,aAAa,EAAE,QAAQ,UAAU,GAA8B;AAC7E,8BAAU,MAAM;AACd,QAAI,CAAC,OAAQ;AACb,aAAS,UAAU,GAAkB;AACnC,UAAI,EAAE,QAAQ,MAAO;AACrB,YAAM,OAAO,UAAU;AACvB,UAAI,CAAC,KAAM;AACX,YAAM,aAAa,gBAAgB,IAAI;AACvC,UAAI,WAAW,WAAW,GAAG;AAI3B,UAAE,eAAe;AACjB,aAAK,MAAM;AACX;AAAA,MACF;AACA,YAAM,QAAQ,WAAW,CAAC;AAC1B,YAAM,OAAO,WAAW,WAAW,SAAS,CAAC;AAC7C,YAAM,UAAU,SAAS;AAEzB,UAAI,CAAC,KAAK,SAAS,OAAO,GAAG;AAC3B,UAAE,eAAe;AACjB,cAAM,MAAM;AACZ;AAAA,MACF;AACA,UAAI,EAAE,YAAY,YAAY,OAAO;AACnC,UAAE,eAAe;AACjB,aAAK,MAAM;AACX;AAAA,MACF;AACA,UAAI,CAAC,EAAE,YAAY,YAAY,MAAM;AACnC,UAAE,eAAe;AACjB,cAAM,MAAM;AAAA,MACd;AAAA,IACF;AACA,aAAS,iBAAiB,WAAW,SAAS;AAC9C,WAAO,MAAM,SAAS,oBAAoB,WAAW,SAAS;AAAA,EAChE,GAAG,CAAC,QAAQ,SAAS,CAAC;AACxB;","names":[]}

package/dist/hooks/use-focus-trap.d.ts

@@ -0,0 +1,27 @@
+import { type RefObject } from 'react';
+export interface UseFocusTrapOptions {
+    active: boolean;
+    /** Container whose focusable descendants form the trap boundary. */
+    container: RefObject<HTMLElement | null>;
+}
+/**
+ * Trap Tab / Shift+Tab cycling within `container` while `active` is true.
+ * Used by Dialog (modal interruption); Popover does NOT use this — popovers
+ * are non-modal and Tab should be able to leave them.
+ *
+ * Implementation: keydown listener at document level (capture phase) so it
+ * sees Tab presses regardless of what's currently focused inside the
+ * container. On Tab at the last focusable, wrap to first; on Shift+Tab at
+ * the first, wrap to last. If focus is somehow OUTSIDE the container while
+ * the trap is active, the next Tab pulls it back to the first focusable.
+ *
+ * Edge cases consciously skipped (v1):
+ *  - Focusables added/removed dynamically during the open lifetime are
+ *    re-queried on every Tab — correct, but O(n) per keydown. Negligible
+ *    for realistic modal contents.
+ *  - Elements made focusable via shadow DOM. Not used in modo today.
+ *  - User Cmd-Tab / Alt-Tab away from the browser — out of scope; the
+ *    trap is intra-document only.
+ */
+export declare function useFocusTrap({ active, container }: UseFocusTrapOptions): void;
+//# sourceMappingURL=use-focus-trap.d.ts.map

package/dist/hooks/use-focus-trap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-focus-trap.d.ts","sourceRoot":"","sources":["../../src/hooks/use-focus-trap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAkBlD,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,OAAO,CAAC;IAChB,oEAAoE;IACpE,SAAS,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,mBAAmB,GAAG,IAAI,CAsC7E"}

package/dist/hooks/use-focus-trap.js

@@ -0,0 +1,54 @@
+import { useEffect } from "react";
+const FOCUSABLE_SELECTOR = [
+  "a[href]",
+  "button:not([disabled])",
+  "input:not([disabled])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  '[tabindex]:not([tabindex="-1"])'
+].join(", ");
+function focusableWithin(root) {
+  if (!root) return [];
+  return Array.from(root.querySelectorAll(FOCUSABLE_SELECTOR)).filter(
+    (el) => el.offsetParent !== null || el === document.activeElement
+  );
+}
+function useFocusTrap({ active, container }) {
+  useEffect(() => {
+    if (!active) return;
+    function onKeyDown(e) {
+      if (e.key !== "Tab") return;
+      const root = container.current;
+      if (!root) return;
+      const focusables = focusableWithin(root);
+      if (focusables.length === 0) {
+        e.preventDefault();
+        root.focus();
+        return;
+      }
+      const first = focusables[0];
+      const last = focusables[focusables.length - 1];
+      const current = document.activeElement;
+      if (!root.contains(current)) {
+        e.preventDefault();
+        first.focus();
+        return;
+      }
+      if (e.shiftKey && current === first) {
+        e.preventDefault();
+        last.focus();
+        return;
+      }
+      if (!e.shiftKey && current === last) {
+        e.preventDefault();
+        first.focus();
+      }
+    }
+    document.addEventListener("keydown", onKeyDown);
+    return () => document.removeEventListener("keydown", onKeyDown);
+  }, [active, container]);
+}
+export {
+  useFocusTrap
+};
+//# sourceMappingURL=use-focus-trap.js.map

package/dist/hooks/use-focus-trap.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/use-focus-trap.ts"],"sourcesContent":["import { useEffect, type RefObject } from 'react';\n\nconst FOCUSABLE_SELECTOR = [\n  'a[href]',\n  'button:not([disabled])',\n  'input:not([disabled])',\n  'select:not([disabled])',\n  'textarea:not([disabled])',\n  '[tabindex]:not([tabindex=\"-1\"])',\n].join(', ');\n\nfunction focusableWithin(root: HTMLElement | null): HTMLElement[] {\n  if (!root) return [];\n  return Array.from(root.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR)).filter(\n    (el) => el.offsetParent !== null || el === document.activeElement,\n  );\n}\n\nexport interface UseFocusTrapOptions {\n  active: boolean;\n  /** Container whose focusable descendants form the trap boundary. */\n  container: RefObject<HTMLElement | null>;\n}\n\n/**\n * Trap Tab / Shift+Tab cycling within `container` while `active` is true.\n * Used by Dialog (modal interruption); Popover does NOT use this — popovers\n * are non-modal and Tab should be able to leave them.\n *\n * Implementation: keydown listener at document level (capture phase) so it\n * sees Tab presses regardless of what's currently focused inside the\n * container. On Tab at the last focusable, wrap to first; on Shift+Tab at\n * the first, wrap to last. If focus is somehow OUTSIDE the container while\n * the trap is active, the next Tab pulls it back to the first focusable.\n *\n * Edge cases consciously skipped (v1):\n *  - Focusables added/removed dynamically during the open lifetime are\n *    re-queried on every Tab — correct, but O(n) per keydown. Negligible\n *    for realistic modal contents.\n *  - Elements made focusable via shadow DOM. Not used in modo today.\n *  - User Cmd-Tab / Alt-Tab away from the browser — out of scope; the\n *    trap is intra-document only.\n */\nexport function useFocusTrap({ active, container }: UseFocusTrapOptions): void {\n  useEffect(() => {\n    if (!active) return;\n    function onKeyDown(e: KeyboardEvent) {\n      if (e.key !== 'Tab') return;\n      const root = container.current;\n      if (!root) return;\n      const focusables = focusableWithin(root);\n      if (focusables.length === 0) {\n        // Nothing to focus inside the panel — keep focus on the root\n        // itself so Tab doesn't escape to the page behind. Container\n        // needs tabIndex={-1} for this to succeed; consumers set that.\n        e.preventDefault();\n        root.focus();\n        return;\n      }\n      const first = focusables[0];\n      const last = focusables[focusables.length - 1];\n      const current = document.activeElement as HTMLElement | null;\n\n      if (!root.contains(current)) {\n        e.preventDefault();\n        first.focus();\n        return;\n      }\n      if (e.shiftKey && current === first) {\n        e.preventDefault();\n        last.focus();\n        return;\n      }\n      if (!e.shiftKey && current === last) {\n        e.preventDefault();\n        first.focus();\n      }\n    }\n    document.addEventListener('keydown', onKeyDown);\n    return () => document.removeEventListener('keydown', onKeyDown);\n  }, [active, container]);\n}\n"],"mappings":"AAAA,SAAS,iBAAiC;AAE1C,MAAM,qBAAqB;AAAA,EACzB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,EAAE,KAAK,IAAI;AAEX,SAAS,gBAAgB,MAAyC;AAChE,MAAI,CAAC,KAAM,QAAO,CAAC;AACnB,SAAO,MAAM,KAAK,KAAK,iBAA8B,kBAAkB,CAAC,EAAE;AAAA,IACxE,CAAC,OAAO,GAAG,iBAAiB,QAAQ,OAAO,SAAS;AAAA,EACtD;AACF;AA2BO,SAAS,aAAa,EAAE,QAAQ,UAAU,GAA8B;AAC7E,YAAU,MAAM;AACd,QAAI,CAAC,OAAQ;AACb,aAAS,UAAU,GAAkB;AACnC,UAAI,EAAE,QAAQ,MAAO;AACrB,YAAM,OAAO,UAAU;AACvB,UAAI,CAAC,KAAM;AACX,YAAM,aAAa,gBAAgB,IAAI;AACvC,UAAI,WAAW,WAAW,GAAG;AAI3B,UAAE,eAAe;AACjB,aAAK,MAAM;AACX;AAAA,MACF;AACA,YAAM,QAAQ,WAAW,CAAC;AAC1B,YAAM,OAAO,WAAW,WAAW,SAAS,CAAC;AAC7C,YAAM,UAAU,SAAS;AAEzB,UAAI,CAAC,KAAK,SAAS,OAAO,GAAG;AAC3B,UAAE,eAAe;AACjB,cAAM,MAAM;AACZ;AAAA,MACF;AACA,UAAI,EAAE,YAAY,YAAY,OAAO;AACnC,UAAE,eAAe;AACjB,aAAK,MAAM;AACX;AAAA,MACF;AACA,UAAI,CAAC,EAAE,YAAY,YAAY,MAAM;AACnC,UAAE,eAAe;AACjB,cAAM,MAAM;AAAA,MACd;AAAA,IACF;AACA,aAAS,iBAAiB,WAAW,SAAS;AAC9C,WAAO,MAAM,SAAS,oBAAoB,WAAW,SAAS;AAAA,EAChE,GAAG,CAAC,QAAQ,SAAS,CAAC;AACxB;","names":[]}

package/dist/hooks/use-portal.cjs

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var use_portal_exports = {};
+__export(use_portal_exports, {
+  usePortal: () => usePortal
+});
+module.exports = __toCommonJS(use_portal_exports);
+var import_react = require("react");
+function usePortal() {
+  const [mounted, setMounted] = (0, import_react.useState)(false);
+  (0, import_react.useEffect)(() => setMounted(true), []);
+  return mounted;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  usePortal
+});
+//# sourceMappingURL=use-portal.cjs.map

package/dist/hooks/use-portal.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/use-portal.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\n\n/**\n * SSR-safe \"are we mounted on the client yet\" gate for portal-rendering\n * components. The portal target (`document.body`) doesn't exist on the\n * first server render — gating on this flag lets the component return\n * `null` during SSR and re-render once on the client to mount the portal.\n *\n * Use:\n *\n *   const mounted = usePortal();\n *   if (!open || !mounted) return null;\n *   return createPortal(<Panel />, document.body);\n */\nexport function usePortal(): boolean {\n  const [mounted, setMounted] = useState(false);\n  // eslint-disable-next-line react-hooks/set-state-in-effect -- the entire purpose of this hook is to flip from false (SSR) to true (after first client commit). The state change IS the signal; there is no derived value to compute via useMemo and no external store to subscribe to.\n  useEffect(() => setMounted(true), []);\n  return mounted;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAoC;AAc7B,SAAS,YAAqB;AACnC,QAAM,CAAC,SAAS,UAAU,QAAI,uBAAS,KAAK;AAE5C,8BAAU,MAAM,WAAW,IAAI,GAAG,CAAC,CAAC;AACpC,SAAO;AACT;","names":[]}

package/dist/hooks/use-portal.d.ts

@@ -0,0 +1,14 @@
+/**
+ * SSR-safe "are we mounted on the client yet" gate for portal-rendering
+ * components. The portal target (`document.body`) doesn't exist on the
+ * first server render — gating on this flag lets the component return
+ * `null` during SSR and re-render once on the client to mount the portal.
+ *
+ * Use:
+ *
+ *   const mounted = usePortal();
+ *   if (!open || !mounted) return null;
+ *   return createPortal(<Panel />, document.body);
+ */
+export declare function usePortal(): boolean;
+//# sourceMappingURL=use-portal.d.ts.map

package/dist/hooks/use-portal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-portal.d.ts","sourceRoot":"","sources":["../../src/hooks/use-portal.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAKnC"}

package/dist/hooks/use-portal.js

@@ -0,0 +1,10 @@
+import { useEffect, useState } from "react";
+function usePortal() {
+  const [mounted, setMounted] = useState(false);
+  useEffect(() => setMounted(true), []);
+  return mounted;
+}
+export {
+  usePortal
+};
+//# sourceMappingURL=use-portal.js.map

package/dist/hooks/use-portal.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/use-portal.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\n\n/**\n * SSR-safe \"are we mounted on the client yet\" gate for portal-rendering\n * components. The portal target (`document.body`) doesn't exist on the\n * first server render — gating on this flag lets the component return\n * `null` during SSR and re-render once on the client to mount the portal.\n *\n * Use:\n *\n *   const mounted = usePortal();\n *   if (!open || !mounted) return null;\n *   return createPortal(<Panel />, document.body);\n */\nexport function usePortal(): boolean {\n  const [mounted, setMounted] = useState(false);\n  // eslint-disable-next-line react-hooks/set-state-in-effect -- the entire purpose of this hook is to flip from false (SSR) to true (after first client commit). The state change IS the signal; there is no derived value to compute via useMemo and no external store to subscribe to.\n  useEffect(() => setMounted(true), []);\n  return mounted;\n}\n"],"mappings":"AAAA,SAAS,WAAW,gBAAgB;AAc7B,SAAS,YAAqB;AACnC,QAAM,CAAC,SAAS,UAAU,IAAI,SAAS,KAAK;AAE5C,YAAU,MAAM,WAAW,IAAI,GAAG,CAAC,CAAC;AACpC,SAAO;AACT;","names":[]}

package/dist/hooks/use-roving-tab-index.cjs

@@ -0,0 +1,78 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var use_roving_tab_index_exports = {};
+__export(use_roving_tab_index_exports, {
+  useRovingTabIndex: () => useRovingTabIndex
+});
+module.exports = __toCommonJS(use_roving_tab_index_exports);
+var import_react = require("react");
+function useRovingTabIndex({
+  count,
+  // `activeIndex` stays in the options type (consumers read it for their own
+  // `tabIndex={i === activeIndex ? 0 : -1}`) but the hook body doesn't need it.
+  orientation = "horizontal",
+  isDisabled,
+  onNavigate
+}) {
+  const itemRefs = (0, import_react.useRef)([]);
+  const getItemRef = (0, import_react.useCallback)(
+    (index) => (el) => {
+      itemRefs.current[index] = el;
+    },
+    []
+  );
+  const moveTo = (0, import_react.useCallback)(
+    (index) => {
+      onNavigate(index);
+      itemRefs.current[index]?.focus();
+    },
+    [onNavigate]
+  );
+  const onItemKeyDown = (0, import_react.useCallback)(
+    (e, index) => {
+      const prevKey = orientation === "vertical" ? "ArrowUp" : "ArrowLeft";
+      const nextKey = orientation === "vertical" ? "ArrowDown" : "ArrowRight";
+      if (e.key === "Home" || e.key === "End") {
+        e.preventDefault();
+        const step2 = e.key === "Home" ? 1 : -1;
+        let candidate = e.key === "Home" ? 0 : count - 1;
+        while (candidate >= 0 && candidate < count && isDisabled?.(candidate)) {
+          candidate += step2;
+        }
+        if (candidate >= 0 && candidate < count) moveTo(candidate);
+        return;
+      }
+      let step = 0;
+      if (e.key === prevKey) step = -1;
+      else if (e.key === nextKey) step = 1;
+      else return;
+      e.preventDefault();
+      let next = index + step;
+      while (next >= 0 && next < count && isDisabled?.(next)) next += step;
+      if (next >= 0 && next < count) moveTo(next);
+    },
+    [count, isDisabled, orientation, moveTo]
+  );
+  return { getItemRef, onItemKeyDown };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useRovingTabIndex
+});
+//# sourceMappingURL=use-roving-tab-index.cjs.map