@smwb/ui-react 2.7.0 → 2.9.0

package/dist/headless/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/headless/utils/controlProps.js

@@ -0,0 +1,14 @@
+function u(o) {
+  return o === "role" || o === "tabIndex" || o === "onFocus" || o === "onBlur" || o.startsWith("aria-") && o !== "aria-hidden";
+}
+function c(o, i = !0) {
+  if (!i) return [{}, o];
+  const t = {}, r = {};
+  for (const [n, s] of Object.entries(o))
+    (u(n) ? t : r)[n] = s;
+  return [t, r];
+}
+export {
+  c as splitControlProps
+};
+//# sourceMappingURL=controlProps.js.map

package/dist/headless/utils/controlProps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"controlProps.js","sources":["../../../src/utils/controlProps.ts"],"sourcesContent":["import type React from \"react\";\n\n/** What an element is to the keyboard and to assistive tech. */\nexport type ControlProps = Pick<React.HTMLAttributes<HTMLElement>, \"role\" | \"tabIndex\" | \"onFocus\" | \"onBlur\"> &\n  React.AriaAttributes;\n\nfunction isControlProp(key: string): boolean {\n  return (\n    key === \"role\" ||\n    key === \"tabIndex\" ||\n    key === \"onFocus\" ||\n    key === \"onBlur\" ||\n    (key.startsWith(\"aria-\") && key !== \"aria-hidden\")\n  );\n}\n\n/**\n * Splits the caller's props of a component whose root is a box around its\n * control and other content beside it: a card's button and its footer or\n * corner slots, a chip's button and its delete button.\n *\n * What the component is to the keyboard and to assistive tech goes to the\n * control, the element that takes focus: `role`, `tabIndex`, `onFocus`,\n * `onBlur` and the `aria-*` attributes. The rest stays on the box, and so does\n * `aria-hidden`, which hides the whole component. While `toControl` is false\n * (the component is not a control, e.g. a card without `onClick`), all of them\n * stay on the box.\n */\nexport function splitControlProps<T extends object>(props: T, toControl = true): [ControlProps, T] {\n  if (!toControl) return [{}, props];\n  const control: Record<string, unknown> = {};\n  const box: Record<string, unknown> = {};\n  for (const [key, value] of Object.entries(props)) {\n    (isControlProp(key) ? control : box)[key] = value;\n  }\n  return [control, box as T];\n}\n"],"names":["isControlProp","key","splitControlProps","props","toControl","control","box","value"],"mappings":"AAMA,SAASA,EAAcC,GAAsB;AAC3C,SACEA,MAAQ,UACRA,MAAQ,cACRA,MAAQ,aACRA,MAAQ,YACPA,EAAI,WAAW,OAAO,KAAKA,MAAQ;AAExC;AAcO,SAASC,EAAoCC,GAAUC,IAAY,IAAyB;AACjG,MAAI,CAACA,EAAW,QAAO,CAAC,CAAA,GAAID,CAAK;AACjC,QAAME,IAAmC,CAAA,GACnCC,IAA+B,CAAA;AACrC,aAAW,CAACL,GAAKM,CAAK,KAAK,OAAO,QAAQJ,CAAK;AAC7C,KAACH,EAAcC,CAAG,IAAII,IAAUC,GAAKL,CAAG,IAAIM;AAE9C,SAAO,CAACF,GAASC,CAAQ;AAC3B;"}

package/dist/headless/utils/keyboardShortcut.js

@@ -0,0 +1,49 @@
+import { detectKbdPlatform as d } from "../components/dataDisplay/kbd/kbdKeys.js";
+const p = {
+  mod: "mod",
+  ctrl: "ctrl",
+  control: "ctrl",
+  alt: "alt",
+  option: "alt",
+  shift: "shift",
+  meta: "meta",
+  cmd: "meta",
+  command: "meta"
+}, h = {
+  esc: "escape",
+  space: " ",
+  spacebar: " ",
+  up: "arrowup",
+  down: "arrowdown",
+  left: "arrowleft",
+  right: "arrowright",
+  plus: "+",
+  return: "enter",
+  del: "delete"
+};
+function y(t, m, n = d()) {
+  var i, c;
+  let l = !1, s = !1, f = !1, a = !1, e = null;
+  for (const u of m) {
+    const o = u.trim().toLowerCase() || u, r = p[o];
+    if (r === "mod")
+      n === "mac" ? a = !0 : l = !0;
+    else if (r === "ctrl")
+      l = !0;
+    else if (r === "alt")
+      s = !0;
+    else if (r === "shift")
+      f = !0;
+    else if (r === "meta")
+      a = !0;
+    else if (e === null)
+      e = (i = h[o]) != null ? i : o;
+    else
+      return !1;
+  }
+  return e === null || t.ctrlKey !== l || t.altKey !== s || t.shiftKey !== f || t.metaKey !== a ? !1 : ((c = t.key) != null ? c : "").toLowerCase() === e ? !0 : /^[a-z]$/.test(e) ? t.code === `Key${e.toUpperCase()}` : /^[0-9]$/.test(e) ? t.code === `Digit${e}` : !1;
+}
+export {
+  y as matchesKeyboardShortcut
+};
+//# sourceMappingURL=keyboardShortcut.js.map

package/dist/headless/utils/keyboardShortcut.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboardShortcut.js","sources":["../../../src/utils/keyboardShortcut.ts"],"sourcesContent":["import { detectKbdPlatform, type KbdPlatform } from \"../components/dataDisplay/kbd/kbdKeys\";\n\ntype ShortcutEvent = Pick<KeyboardEvent, \"key\" | \"code\" | \"ctrlKey\" | \"metaKey\" | \"altKey\" | \"shiftKey\">;\n\n// Modifier names (lower case) and the flag each one asks for. `mod` is resolved per platform.\nconst MODIFIERS: Record<string, \"mod\" | \"ctrl\" | \"alt\" | \"shift\" | \"meta\"> = {\n  mod: \"mod\",\n  ctrl: \"ctrl\",\n  control: \"ctrl\",\n  alt: \"alt\",\n  option: \"alt\",\n  shift: \"shift\",\n  meta: \"meta\",\n  cmd: \"meta\",\n  command: \"meta\",\n};\n\n// Names (lower case) that stand for another `KeyboardEvent.key`.\nconst KEY_ALIASES: Record<string, string> = {\n  esc: \"escape\",\n  space: \" \",\n  spacebar: \" \",\n  up: \"arrowup\",\n  down: \"arrowdown\",\n  left: \"arrowleft\",\n  right: \"arrowright\",\n  plus: \"+\",\n  return: \"enter\",\n  del: \"delete\",\n};\n\n/**\n * Whether a keyboard event is the shortcut `keys` (in `Kbd` key names, e.g. `[\"Mod\", \"K\"]`).\n * `Mod` is Meta on `mac` and Ctrl elsewhere. The modifiers must match exactly, so Mod+K does not\n * match Mod+Shift+K. The list needs exactly one key that is not a modifier. It is compared with\n * `event.key` ignoring case; a single ASCII letter or digit also matches `event.code`\n * (`KeyK`, `Digit1`), so a shortcut keeps working on a layout that types other letters.\n * `platform` is the running browser's by default.\n */\nexport function matchesKeyboardShortcut(\n  event: ShortcutEvent,\n  keys: string[],\n  platform: KbdPlatform = detectKbdPlatform()\n): boolean {\n  let ctrl = false;\n  let alt = false;\n  let shift = false;\n  let meta = false;\n  let main: string | null = null;\n  for (const key of keys) {\n    const lower = key.trim().toLowerCase() || key; // a lone \" \" is the space bar\n    const modifier = MODIFIERS[lower];\n    if (modifier === \"mod\") {\n      if (platform === \"mac\") {\n        meta = true;\n      } else {\n        ctrl = true;\n      }\n    } else if (modifier === \"ctrl\") {\n      ctrl = true;\n    } else if (modifier === \"alt\") {\n      alt = true;\n    } else if (modifier === \"shift\") {\n      shift = true;\n    } else if (modifier === \"meta\") {\n      meta = true;\n    } else if (main === null) {\n      main = KEY_ALIASES[lower] ?? lower;\n    } else {\n      return false;\n    }\n  }\n  if (main === null) {\n    return false;\n  }\n  if (event.ctrlKey !== ctrl || event.altKey !== alt || event.shiftKey !== shift || event.metaKey !== meta) {\n    return false;\n  }\n  if ((event.key ?? \"\").toLowerCase() === main) {\n    return true;\n  }\n  if (/^[a-z]$/.test(main)) {\n    return event.code === `Key${main.toUpperCase()}`;\n  }\n  if (/^[0-9]$/.test(main)) {\n    return event.code === `Digit${main}`;\n  }\n  return false;\n}\n"],"names":["MODIFIERS","KEY_ALIASES","matchesKeyboardShortcut","event","keys","platform","detectKbdPlatform","ctrl","alt","shift","meta","main","key","lower","modifier","_a","_b"],"mappings":";AAKA,MAAMA,IAAuE;AAAA,EAC3E,KAAK;AAAA,EACL,MAAM;AAAA,EACN,SAAS;AAAA,EACT,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,OAAO;AAAA,EACP,MAAM;AAAA,EACN,KAAK;AAAA,EACL,SAAS;AACX,GAGMC,IAAsC;AAAA,EAC1C,KAAK;AAAA,EACL,OAAO;AAAA,EACP,UAAU;AAAA,EACV,IAAI;AAAA,EACJ,MAAM;AAAA,EACN,MAAM;AAAA,EACN,OAAO;AAAA,EACP,MAAM;AAAA,EACN,QAAQ;AAAA,EACR,KAAK;AACP;AAUO,SAASC,EACdC,GACAC,GACAC,IAAwBC,KACf;;AACT,MAAIC,IAAO,IACPC,IAAM,IACNC,IAAQ,IACRC,IAAO,IACPC,IAAsB;AAC1B,aAAWC,KAAOR,GAAM;AACtB,UAAMS,IAAQD,EAAI,KAAA,EAAO,iBAAiBA,GACpCE,IAAWd,EAAUa,CAAK;AAChC,QAAIC,MAAa;AACf,MAAIT,MAAa,QACfK,IAAO,KAEPH,IAAO;AAAA,aAEAO,MAAa;AACtB,MAAAP,IAAO;AAAA,aACEO,MAAa;AACtB,MAAAN,IAAM;AAAA,aACGM,MAAa;AACtB,MAAAL,IAAQ;AAAA,aACCK,MAAa;AACtB,MAAAJ,IAAO;AAAA,aACEC,MAAS;AAClB,MAAAA,KAAOI,IAAAd,EAAYY,CAAK,MAAjB,OAAAE,IAAsBF;AAAA;AAE7B,aAAO;AAAA,EAEX;AAIA,SAHIF,MAAS,QAGTR,EAAM,YAAYI,KAAQJ,EAAM,WAAWK,KAAOL,EAAM,aAAaM,KAASN,EAAM,YAAYO,IAC3F,OAEJM,IAAAb,EAAM,QAAN,OAAAa,IAAa,IAAI,YAAA,MAAkBL,IAC/B,KAEL,UAAU,KAAKA,CAAI,IACdR,EAAM,SAAS,MAAMQ,EAAK,aAAa,KAE5C,UAAU,KAAKA,CAAI,IACdR,EAAM,SAAS,QAAQQ,CAAI,KAE7B;AACT;"}

package/dist/headless/utils/linkAttrs.js

@@ -0,0 +1,13 @@
+const o = "_blank";
+function r(e) {
+  return e === void 0 ? o : e === null || e === "" ? void 0 : e;
+}
+function l(e, n) {
+  return e !== void 0 ? e || void 0 : n !== void 0 && n !== "_self" && n !== "_parent" && n !== "_top" ? "noreferrer" : void 0;
+}
+export {
+  o as DEFAULT_LINK_TARGET,
+  l as resolveLinkRel,
+  r as resolveLinkTarget
+};
+//# sourceMappingURL=linkAttrs.js.map

package/dist/headless/utils/linkAttrs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"linkAttrs.js","sources":["../../../src/utils/linkAttrs.ts"],"sourcesContent":["/** Where a link opens unless its `target` says otherwise. */\nexport const DEFAULT_LINK_TARGET = \"_blank\";\n\n/**\n * The `target` attribute for a link: `undefined` (not given) keeps `\"_blank\"`, `null` (or an\n * empty string) leaves the attribute out so the link opens in place, any other string is used as is.\n */\nexport function resolveLinkTarget(target: string | null | undefined): string | undefined {\n  if (target === undefined) return DEFAULT_LINK_TARGET;\n  return target === null || target === \"\" ? undefined : target;\n}\n\n/**\n * The `rel` attribute for a link: the caller's wins (an empty string drops it), `undefined` keeps the\n * default. The default is `\"noreferrer\"` for a link that opens another browsing context (a new tab or\n * a named window), which also implies `noopener`, and none for a link that opens in place.\n */\nexport function resolveLinkRel(rel: string | undefined, target: string | undefined): string | undefined {\n  if (rel !== undefined) return rel || undefined;\n  const elsewhere = target !== undefined && target !== \"_self\" && target !== \"_parent\" && target !== \"_top\";\n  return elsewhere ? \"noreferrer\" : undefined;\n}\n"],"names":["DEFAULT_LINK_TARGET","resolveLinkTarget","target","resolveLinkRel","rel"],"mappings":"AACO,MAAMA,IAAsB;AAM5B,SAASC,EAAkBC,GAAuD;AACvF,SAAIA,MAAW,SAAkBF,IAC1BE,MAAW,QAAQA,MAAW,KAAK,SAAYA;AACxD;AAOO,SAASC,EAAeC,GAAyBF,GAAgD;AACtG,SAAIE,MAAQ,SAAkBA,KAAO,SACnBF,MAAW,UAAaA,MAAW,WAAWA,MAAW,aAAaA,MAAW,SAChF,eAAe;AACpC;"}

package/dist/headless/utils/overlayLayer.js

@@ -1,11 +1,18 @@
-const e = "data-smwb-overlay-layer", r = () => typeof document == "undefined" ? [] : Array.from(document.querySelectorAll(`[${e}]`)), a = (n, o) => typeof n.composedPath != "function" ? !1 : n.composedPath().some((t) => t instanceof Element && t.hasAttribute(e) && !t.contains(o)), s = (n) => {
-  if (!n) return !0;
-  const o = r(), t = o[o.length - 1];
-  return !t || t === n || t.contains(n) || n.contains(t);
-};
+const r = "data-smwb-overlay-layer", s = () => typeof document == "undefined" ? [] : Array.from(document.querySelectorAll(`[${r}]`)), a = (o, e) => {
+  if (typeof o.composedPath != "function") return !1;
+  const t = Node.DOCUMENT_POSITION_FOLLOWING | Node.DOCUMENT_POSITION_DISCONNECTED;
+  return o.composedPath().some(
+    (n) => n instanceof Element && n.hasAttribute(r) && (e.compareDocumentPosition(n) & t) !== 0
+  );
+}, c = (o) => {
+  if (!o) return !0;
+  const e = s(), t = e[e.length - 1];
+  return !t || t === o || t.contains(o);
+}, O = (o) => !o || !o.isConnected ? !1 : s().some((e) => (o.compareDocumentPosition(e) & Node.DOCUMENT_POSITION_FOLLOWING) !== 0);
 export {
-  e as OVERLAY_LAYER_ATTR,
+  r as OVERLAY_LAYER_ATTR,
+  O as hasOverlayLayerAbove,
   a as isEventInForeignOverlay,
-  s as isTopOverlayLayer
+  c as isTopOverlayLayer
 };
 //# sourceMappingURL=overlayLayer.js.map

package/dist/headless/utils/overlayLayer.js.map

@@ -1 +1 @@
-{"version":3,"file":"overlayLayer.js","sources":["../../../src/utils/overlayLayer.ts"],"sourcesContent":["/** Attribute marking the root of a portaled overlay layer (modal, sheet wrapper, dropdown, …). */\nexport const OVERLAY_LAYER_ATTR = \"data-smwb-overlay-layer\";\n\n/** All open overlay layers in document order (last = topmost). */\nconst overlayLayers = (): Element[] =>\n  typeof document === \"undefined\" ? [] : Array.from(document.querySelectorAll(`[${OVERLAY_LAYER_ATTR}]`));\n\n/**\n * True when `event` happened inside an overlay layer that does NOT contain\n * `node` — i.e. `node` sits underneath that layer, so the interaction is not\n * a \"click away\" from `node`.\n */\nexport const isEventInForeignOverlay = (event: Event, node: Element): boolean => {\n  if (typeof event.composedPath !== \"function\") return false;\n  return event\n    .composedPath()\n    .some((el) => el instanceof Element && el.hasAttribute(OVERLAY_LAYER_ATTR) && !el.contains(node));\n};\n\n/**\n * True when `el` belongs to the topmost open overlay layer (or no layers are\n * open). Used to make Escape close only the top layer instead of every layer.\n */\nexport const isTopOverlayLayer = (el: Element | null | undefined): boolean => {\n  if (!el) return true;\n  const all = overlayLayers();\n  const top = all[all.length - 1];\n  return !top || top === el || top.contains(el) || el.contains(top);\n};\n"],"names":["OVERLAY_LAYER_ATTR","overlayLayers","isEventInForeignOverlay","event","node","el","isTopOverlayLayer","all","top"],"mappings":"AACO,MAAMA,IAAqB,2BAG5BC,IAAgB,MACpB,OAAO,YAAa,cAAc,CAAA,IAAK,MAAM,KAAK,SAAS,iBAAiB,IAAID,CAAkB,GAAG,CAAC,GAO3FE,IAA0B,CAACC,GAAcC,MAChD,OAAOD,EAAM,gBAAiB,aAAmB,KAC9CA,EACJ,aAAA,EACA,KAAK,CAACE,MAAOA,aAAc,WAAWA,EAAG,aAAaL,CAAkB,KAAK,CAACK,EAAG,SAASD,CAAI,CAAC,GAOvFE,IAAoB,CAACD,MAA4C;AAC5E,MAAI,CAACA,EAAI,QAAO;AAChB,QAAME,IAAMN,EAAA,GACNO,IAAMD,EAAIA,EAAI,SAAS,CAAC;AAC9B,SAAO,CAACC,KAAOA,MAAQH,KAAMG,EAAI,SAASH,CAAE,KAAKA,EAAG,SAASG,CAAG;AAClE;"}
+{"version":3,"file":"overlayLayer.js","sources":["../../../src/utils/overlayLayer.ts"],"sourcesContent":["/** Attribute marking the root of a portaled overlay layer (modal, sheet wrapper, dropdown, …). */\nexport const OVERLAY_LAYER_ATTR = \"data-smwb-overlay-layer\";\n\n/** All open overlay layers in document order (last = topmost). */\nconst overlayLayers = (): Element[] =>\n  typeof document === \"undefined\" ? [] : Array.from(document.querySelectorAll(`[${OVERLAY_LAYER_ATTR}]`));\n\n/**\n * True when `event` happened inside an overlay layer above `node`, so the\n * interaction is not a \"click away\" from `node`. A layer is above `node` when it\n * comes later in document order (portaled after it, as everything opened from\n * inside `node` is) or sits inside it. A layer that holds `node` or comes before\n * it is below: a click in the Modal a select menu was opened from is a click away\n * from the menu.\n */\nexport const isEventInForeignOverlay = (event: Event, node: Element): boolean => {\n  if (typeof event.composedPath !== \"function\") return false;\n  // A layer detached during the dispatch can't be ranked; it counts as above.\n  const above = Node.DOCUMENT_POSITION_FOLLOWING | Node.DOCUMENT_POSITION_DISCONNECTED;\n  return event\n    .composedPath()\n    .some(\n      (el) =>\n        el instanceof Element && el.hasAttribute(OVERLAY_LAYER_ATTR) && (node.compareDocumentPosition(el) & above) !== 0\n    );\n};\n\n/**\n * True when `el` belongs to the topmost open overlay layer (or no layers are\n * open). Used to make Escape close only the top layer instead of every layer.\n * A layer inside `el`, such as a select menu rendered into a Modal through\n * `menuContainer`, is above `el` rather than part of it.\n */\nexport const isTopOverlayLayer = (el: Element | null | undefined): boolean => {\n  if (!el) return true;\n  const all = overlayLayers();\n  const top = all[all.length - 1];\n  return !top || top === el || top.contains(el);\n};\n\n/**\n * True when an open overlay layer other than `el` sits above it: inside it, or\n * later in document order (portaled after it). FloatingWindow and the fullscreen\n * ExpansionPanel leave Escape to such a layer, e.g. a select menu opened from\n * inside them. Layers earlier in document order are below `el`.\n */\nexport const hasOverlayLayerAbove = (el: Element | null | undefined): boolean => {\n  if (!el || !el.isConnected) return false;\n  return overlayLayers().some((layer) => (el.compareDocumentPosition(layer) & Node.DOCUMENT_POSITION_FOLLOWING) !== 0);\n};\n"],"names":["OVERLAY_LAYER_ATTR","overlayLayers","isEventInForeignOverlay","event","node","above","el","isTopOverlayLayer","all","top","hasOverlayLayerAbove","layer"],"mappings":"AACO,MAAMA,IAAqB,2BAG5BC,IAAgB,MACpB,OAAO,YAAa,cAAc,CAAA,IAAK,MAAM,KAAK,SAAS,iBAAiB,IAAID,CAAkB,GAAG,CAAC,GAU3FE,IAA0B,CAACC,GAAcC,MAA2B;AAC/E,MAAI,OAAOD,EAAM,gBAAiB,WAAY,QAAO;AAErD,QAAME,IAAQ,KAAK,8BAA8B,KAAK;AACtD,SAAOF,EACJ,eACA;AAAA,IACC,CAACG,MACCA,aAAc,WAAWA,EAAG,aAAaN,CAAkB,MAAMI,EAAK,wBAAwBE,CAAE,IAAID,OAAW;AAAA,EAAA;AAEvH,GAQaE,IAAoB,CAACD,MAA4C;AAC5E,MAAI,CAACA,EAAI,QAAO;AAChB,QAAME,IAAMP,EAAA,GACNQ,IAAMD,EAAIA,EAAI,SAAS,CAAC;AAC9B,SAAO,CAACC,KAAOA,MAAQH,KAAMG,EAAI,SAASH,CAAE;AAC9C,GAQaI,IAAuB,CAACJ,MAC/B,CAACA,KAAM,CAACA,EAAG,cAAoB,KAC5BL,EAAA,EAAgB,KAAK,CAACU,OAAWL,EAAG,wBAAwBK,CAAK,IAAI,KAAK,iCAAiC,CAAC;"}

package/dist/headless/utils/ownClick.js

@@ -0,0 +1,40 @@
+const a = [
+  "a[href]",
+  "button",
+  "input",
+  "select",
+  "textarea",
+  "label",
+  "summary",
+  "[tabindex]",
+  "[contenteditable]:not([contenteditable='false'])",
+  ...[
+    "button",
+    "link",
+    "checkbox",
+    "radio",
+    "switch",
+    "textbox",
+    "searchbox",
+    "combobox",
+    "spinbutton",
+    "slider",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "option",
+    "tab"
+  ].map((t) => `[role='${t}']`)
+].join(",");
+function c(t, r = t.currentTarget) {
+  var i;
+  if (t.defaultPrevented) return !1;
+  const e = t.target, o = (i = e == null ? void 0 : e.closest(a)) != null ? i : null;
+  if (o !== null && o === r) return !0;
+  const n = t.currentTarget;
+  return r === n || !e || !(n != null && n.contains(e)) ? !1 : !(o && n.contains(o));
+}
+export {
+  c as isOwnClick
+};
+//# sourceMappingURL=ownClick.js.map

package/dist/headless/utils/ownClick.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ownClick.js","sources":["../../../src/utils/ownClick.ts"],"sourcesContent":["/**\n * Whatever takes a click of its own: a native control or link, a label,\n * anything focusable, a widget role, editable content.\n */\nconst INTERACTIVE = [\n  \"a[href]\",\n  \"button\",\n  \"input\",\n  \"select\",\n  \"textarea\",\n  \"label\",\n  \"summary\",\n  \"[tabindex]\",\n  \"[contenteditable]:not([contenteditable='false'])\",\n  ...[\n    \"button\",\n    \"link\",\n    \"checkbox\",\n    \"radio\",\n    \"switch\",\n    \"textbox\",\n    \"searchbox\",\n    \"combobox\",\n    \"spinbutton\",\n    \"slider\",\n    \"menuitem\",\n    \"menuitemcheckbox\",\n    \"menuitemradio\",\n    \"option\",\n    \"tab\",\n  ].map((role) => `[role='${role}']`),\n].join(\",\");\n\n/**\n * Whether a click belongs to the control that listens for it on a wrapper (a\n * sortable header, a selectable card) rather than to something inside it.\n *\n * The control must match `INTERACTIVE` itself (`role=\"button\"`, `tabindex`), and\n * then a click is its own when it is the nearest match from the click's target\n * up, and no handler has prevented the click's default yet. So a click in a\n * nested control is that control's, and so is a click in a portal rendered\n * inside: React delivers it to the wrapper, though it landed outside.\n *\n * The control is the element that listens (`currentTarget`), unless the caller\n * passes another: a box that holds a control and other content beside it (a\n * card's button and its corner slots) listens for both. A click on that content\n * is then the control's too, unless it lands in a control of its own there.\n */\nexport function isOwnClick(\n  event: Pick<Event, \"target\" | \"currentTarget\" | \"defaultPrevented\">,\n  control: Element | null = event.currentTarget as Element | null\n): boolean {\n  if (event.defaultPrevented) return false;\n  const target = event.target as Element | null;\n  const nearest = target?.closest(INTERACTIVE) ?? null;\n  if (nearest !== null && nearest === control) return true;\n  const box = event.currentTarget as Element | null;\n  if (control === box || !target || !box?.contains(target)) return false;\n  return !(nearest && box.contains(nearest));\n}\n"],"names":["INTERACTIVE","role","isOwnClick","event","control","_a","target","nearest","box"],"mappings":"AAIA,MAAMA,IAAc;AAAA,EAClB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,GAAG;AAAA,IACD;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EAAA,EACA,IAAI,CAACC,MAAS,UAAUA,CAAI,IAAI;AACpC,EAAE,KAAK,GAAG;AAiBH,SAASC,EACdC,GACAC,IAA0BD,EAAM,eACvB;AA/CX,MAAAE;AAgDE,MAAIF,EAAM,iBAAkB,QAAO;AACnC,QAAMG,IAASH,EAAM,QACfI,KAAUF,IAAAC,KAAA,gBAAAA,EAAQ,QAAQN,OAAhB,OAAAK,IAAgC;AAChD,MAAIE,MAAY,QAAQA,MAAYH,EAAS,QAAO;AACpD,QAAMI,IAAML,EAAM;AAClB,SAAIC,MAAYI,KAAO,CAACF,KAAU,EAACE,KAAA,QAAAA,EAAK,SAASF,MAAgB,KAC1D,EAAEC,KAAWC,EAAI,SAASD,CAAO;AAC1C;"}

package/dist/headless/utils/readOnlyToggle.js

@@ -0,0 +1,14 @@
+function r(e, t) {
+  t == null && e.preventDefault();
+}
+function g(e, t) {
+  var l, o;
+  if (t != null) return;
+  const c = e.currentTarget, n = c.checked;
+  c.checked = !n, (o = (l = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, "checked")) == null ? void 0 : l.set) == null || o.call(c, n);
+}
+export {
+  r as cancelToggle,
+  g as forgetCancelledToggle
+};
+//# sourceMappingURL=readOnlyToggle.js.map

package/dist/headless/utils/readOnlyToggle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readOnlyToggle.js","sources":["../../../src/utils/readOnlyToggle.ts"],"sourcesContent":["import type React from \"react\";\n\n// `readonly` means nothing to a checkbox or radio input: a click on it or on its label, Space, and\n// the arrow keys in a radio group still toggle it, each through a click on the input. Checkbox,\n// RadioButton and Toggle call these two while read-only.\n//\n// A controlled input (`checked` given) needs neither: after every click React puts it back to\n// `checked`, and the rest of its named radio group to theirs. Cancelling the click as well would\n// give the last word to the browser, which restores the state from before the click even when the\n// click changed `checked` (say, a row that selects itself on click).\n\n/**\n * Call from the input's `onClick`. Cancels the click on an uncontrolled input; the browser then\n * restores its previous state, and re-checks the radio that was checked before.\n */\nexport function cancelToggle(event: React.MouseEvent<HTMLInputElement>, checked: boolean | null | undefined): void {\n  if (checked == null) event.preventDefault();\n}\n\n/**\n * Call from the input's `onChange`. React has recorded the toggled state of an uncontrolled input,\n * and the browser puts the old one back after the cancelled click without React noticing; React\n * would then take the next real change for no change and skip `onChange`. Record the old state\n * instead: set it through the input's own `checked` (the property React watches), then put the\n * toggled one back through the prototype's setter, which React doesn't watch, so the input stays\n * as it is until the browser restores it.\n */\nexport function forgetCancelledToggle(\n  event: React.ChangeEvent<HTMLInputElement>,\n  checked: boolean | null | undefined\n): void {\n  if (checked != null) return;\n  const input = event.currentTarget;\n  const toggled = input.checked;\n  input.checked = !toggled;\n  Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, \"checked\")?.set?.call(input, toggled);\n}\n"],"names":["cancelToggle","event","checked","forgetCancelledToggle","_a","_b","input","toggled"],"mappings":"AAeO,SAASA,EAAaC,GAA2CC,GAA2C;AACjH,EAAIA,KAAW,QAAMD,EAAM,eAAA;AAC7B;AAUO,SAASE,EACdF,GACAC,GACM;AAfD,MAAAE,GAAAC;AAgBL,MAAIH,KAAW,KAAM;AACrB,QAAMI,IAAQL,EAAM,eACdM,IAAUD,EAAM;AACtB,EAAAA,EAAM,UAAU,CAACC,IACjBF,KAAAD,IAAA,OAAO,yBAAyB,iBAAiB,WAAW,SAAS,MAArE,gBAAAA,EAAwE,QAAxE,QAAAC,EAA6E,KAAKC,GAAOC;AAC3F;"}

package/dist/headless/utils/restoreFocus.js

@@ -0,0 +1,10 @@
+function c(e, n) {
+  if (!(e instanceof HTMLElement) || e === document.body || !e.isConnected)
+    return;
+  const t = document.activeElement;
+  t && t !== document.body && !(n != null && n.contains(t)) || e.focus({ preventScroll: !0 });
+}
+export {
+  c as restoreFocus
+};
+//# sourceMappingURL=restoreFocus.js.map

package/dist/headless/utils/restoreFocus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"restoreFocus.js","sources":["../../../src/utils/restoreFocus.ts"],"sourcesContent":["/**\n * Hands focus back to `opener`, the element that had it when an overlay opened, once the\n * overlay `root` closes. Focus the app moved elsewhere on purpose stays where it is: it\n * is restored only while it is still inside `root` or has been dropped on the body (the\n * root is gone, or the element that had it was removed). An opener that left the document\n * is skipped, and one that cannot take focus (disabled, hidden) simply ignores the call.\n */\nexport function restoreFocus(opener: Element | null, root: Element | null | undefined): void {\n  if (!(opener instanceof HTMLElement) || opener === document.body || !opener.isConnected) {\n    return;\n  }\n  const active = document.activeElement;\n  if (active && active !== document.body && !root?.contains(active)) {\n    return;\n  }\n  opener.focus({ preventScroll: true });\n}\n"],"names":["restoreFocus","opener","root","active"],"mappings":"AAOO,SAASA,EAAaC,GAAwBC,GAAwC;AAC3F,MAAI,EAAED,aAAkB,gBAAgBA,MAAW,SAAS,QAAQ,CAACA,EAAO;AAC1E;AAEF,QAAME,IAAS,SAAS;AACxB,EAAIA,KAAUA,MAAW,SAAS,QAAQ,EAACD,KAAA,QAAAA,EAAM,SAASC,OAG1DF,EAAO,MAAM,EAAE,eAAe,GAAA,CAAM;AACtC;"}

package/dist/hooks/useDismissOnEscape.d.ts

@@ -0,0 +1,11 @@
+/**
+ * While `active`, Escape calls `onDismiss` wherever focus is and is marked as handled
+ * (`preventDefault()`), so a window, fullscreen panel, Modal or Sheet around stays open
+ * until the next press. For content shown on hover or focus, such as a tooltip, which
+ * Escape must hide without moving the pointer or focus (WCAG 1.4.13).
+ *
+ * The listener runs in the capture phase on `document`: those surfaces listen on
+ * `document` in the bubble phase, and one opened before the content showed would
+ * otherwise see the key first.
+ */
+export declare function useDismissOnEscape(active: boolean, onDismiss: () => void): void;

package/dist/hooks/useDismissOnEscape.js

@@ -0,0 +1,16 @@
+import { useEffect as s } from "react";
+import { useEventCallback as u } from "./useEventCallback.js";
+function c(e, o) {
+  const n = u(o);
+  s(() => {
+    if (!e) return;
+    const t = (r) => {
+      r.key === "Escape" && (r.preventDefault(), n());
+    };
+    return document.addEventListener("keydown", t, !0), () => document.removeEventListener("keydown", t, !0);
+  }, [e, n]);
+}
+export {
+  c as useDismissOnEscape
+};
+//# sourceMappingURL=useDismissOnEscape.js.map

package/dist/hooks/useDismissOnEscape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDismissOnEscape.js","sources":["../../src/hooks/useDismissOnEscape.ts"],"sourcesContent":["import { useEffect } from \"react\";\nimport { useEventCallback } from \"./useEventCallback\";\n\n/**\n * While `active`, Escape calls `onDismiss` wherever focus is and is marked as handled\n * (`preventDefault()`), so a window, fullscreen panel, Modal or Sheet around stays open\n * until the next press. For content shown on hover or focus, such as a tooltip, which\n * Escape must hide without moving the pointer or focus (WCAG 1.4.13).\n *\n * The listener runs in the capture phase on `document`: those surfaces listen on\n * `document` in the bubble phase, and one opened before the content showed would\n * otherwise see the key first.\n */\nexport function useDismissOnEscape(active: boolean, onDismiss: () => void): void {\n  const dismiss = useEventCallback(onDismiss);\n  useEffect(() => {\n    if (!active) return undefined;\n    const onKeyDown = (event: KeyboardEvent): void => {\n      if (event.key !== \"Escape\") return;\n      event.preventDefault();\n      dismiss();\n    };\n    document.addEventListener(\"keydown\", onKeyDown, true);\n    return () => document.removeEventListener(\"keydown\", onKeyDown, true);\n  }, [active, dismiss]);\n}\n"],"names":["useDismissOnEscape","active","onDismiss","dismiss","useEventCallback","useEffect","onKeyDown","event"],"mappings":";;AAaO,SAASA,EAAmBC,GAAiBC,GAA6B;AAC/E,QAAMC,IAAUC,EAAiBF,CAAS;AAC1C,EAAAG,EAAU,MAAM;AACd,QAAI,CAACJ,EAAQ;AACb,UAAMK,IAAY,CAACC,MAA+B;AAChD,MAAIA,EAAM,QAAQ,aAClBA,EAAM,eAAA,GACNJ,EAAA;AAAA,IACF;AACA,oBAAS,iBAAiB,WAAWG,GAAW,EAAI,GAC7C,MAAM,SAAS,oBAAoB,WAAWA,GAAW,EAAI;AAAA,EACtE,GAAG,CAACL,GAAQE,CAAO,CAAC;AACtB;"}

package/dist/hooks/useFocusTrap.d.ts

@@ -1,4 +1,6 @@
 import { RefObject } from "react";
+/** Elements in the Tab order (hidden ones match too). */
+export declare const FOCUSABLE = "a[href],button:not([disabled]),textarea:not([disabled]),input:not([disabled]),select:not([disabled]),[tabindex]:not([tabindex=\"-1\"])";
 export interface UseFocusTrapOptions {
     /** Trap is active only while true. */
     active: boolean;
@@ -6,10 +8,15 @@ export interface UseFocusTrapOptions {
     restoreFocus?: boolean;
     /** Focus the first focusable element on activate. */
     autoFocus?: boolean;
+    /**
+     * Checked on every Tab. While it returns false the trap leaves the key alone, so a trap stacked above
+     * this one (a dialog opened from inside the container) handles it. Defaults to always true.
+     */
+    isTopmost?: () => boolean;
 }
 /**
  * Confines Tab/Shift+Tab focus within `containerRef` while `active`.
  * Restores focus to the previously focused element on teardown.
  */
-export declare function useFocusTrap<T extends HTMLElement>(containerRef: RefObject<T>, { active, restoreFocus, autoFocus }: UseFocusTrapOptions): void;
+export declare function useFocusTrap<T extends HTMLElement>(containerRef: RefObject<T>, { active, restoreFocus, autoFocus, isTopmost }: UseFocusTrapOptions): void;
 export default useFocusTrap;

package/dist/hooks/useFocusTrap.js

@@ -1,38 +1,42 @@
-import { useRef as m, useEffect as p } from "react";
-const b = 'a[href],button:not([disabled]),textarea:not([disabled]),input:not([disabled]),select:not([disabled]),[tabindex]:not([tabindex="-1"])';
-function E(c, { active: s, restoreFocus: f = !0, autoFocus: l = !0 }) {
-  const r = m(null);
-  p(() => {
-    if (!s)
+import { useRef as y, useEffect as E } from "react";
+const v = 'a[href],button:not([disabled]),textarea:not([disabled]),input:not([disabled]),select:not([disabled]),[tabindex]:not([tabindex="-1"])';
+function D(s, { active: f, restoreFocus: l = !0, autoFocus: i = !0, isTopmost: a }) {
+  const u = y(null), d = y(a);
+  d.current = a, E(() => {
+    if (!f)
       return;
-    const t = c.current;
+    const t = s.current;
     if (!t)
       return;
-    r.current = document.activeElement;
-    const i = () => Array.from(t.querySelectorAll(b)).filter(
+    u.current = document.activeElement;
+    const m = () => Array.from(t.querySelectorAll(v)).filter(
       (e) => e.offsetParent !== null || e === document.activeElement
     );
-    if (l) {
-      const e = i()[0];
+    if (i && !t.contains(document.activeElement)) {
+      const e = m()[0];
       (e != null ? e : t).focus({ preventScroll: !0 });
     }
-    const a = (e) => {
+    const p = (e) => {
       if (e.key !== "Tab")
         return;
-      const n = i();
+      const b = d.current;
+      if (b && !b())
+        return;
+      const n = m();
       if (n.length === 0) {
-        e.preventDefault();
+        e.preventDefault(), t.focus({ preventScroll: !0 });
         return;
       }
-      const o = n[0], d = n[n.length - 1], u = document.activeElement;
-      e.shiftKey && u === o ? (e.preventDefault(), d.focus()) : !e.shiftKey && u === d ? (e.preventDefault(), o.focus()) : t.contains(u) || (e.preventDefault(), o.focus());
+      const r = n[0], c = n[n.length - 1], o = document.activeElement;
+      o === t ? (e.preventDefault(), (e.shiftKey ? c : r).focus()) : e.shiftKey && o === r ? (e.preventDefault(), c.focus()) : !e.shiftKey && o === c ? (e.preventDefault(), r.focus()) : t.contains(o) || (e.preventDefault(), r.focus());
     };
-    return document.addEventListener("keydown", a, !0), () => {
-      document.removeEventListener("keydown", a, !0), f && r.current && r.current.focus({ preventScroll: !0 });
+    return document.addEventListener("keydown", p, !0), () => {
+      document.removeEventListener("keydown", p, !0), l && u.current && u.current.focus({ preventScroll: !0 });
     };
-  }, [s, l, f, c]);
+  }, [f, i, l, s]);
 }
 export {
-  E as useFocusTrap
+  v as FOCUSABLE,
+  D as useFocusTrap
 };
 //# sourceMappingURL=useFocusTrap.js.map

package/dist/hooks/useFocusTrap.js.map

@@ -1 +1 @@
-{"version":3,"file":"useFocusTrap.js","sources":["../../src/hooks/useFocusTrap.ts"],"sourcesContent":["import { RefObject, useEffect, useRef } from \"react\";\n\nconst FOCUSABLE =\n  'a[href],button:not([disabled]),textarea:not([disabled]),input:not([disabled]),select:not([disabled]),[tabindex]:not([tabindex=\"-1\"])';\n\nexport interface UseFocusTrapOptions {\n  /** Trap is active only while true. */\n  active: boolean;\n  /** Restore focus to the previously focused element on deactivate. */\n  restoreFocus?: boolean;\n  /** Focus the first focusable element on activate. */\n  autoFocus?: boolean;\n}\n\n/**\n * Confines Tab/Shift+Tab focus within `containerRef` while `active`.\n * Restores focus to the previously focused element on teardown.\n */\nexport function useFocusTrap<T extends HTMLElement>(\n  containerRef: RefObject<T>,\n  { active, restoreFocus = true, autoFocus = true }: UseFocusTrapOptions\n): void {\n  const prevFocused = useRef<HTMLElement | null>(null);\n\n  useEffect(() => {\n    if (!active) {\n      return;\n    }\n    const container = containerRef.current;\n    if (!container) {\n      return;\n    }\n\n    prevFocused.current = document.activeElement as HTMLElement | null;\n\n    const focusables = () =>\n      Array.from(container.querySelectorAll<HTMLElement>(FOCUSABLE)).filter(\n        (el) => el.offsetParent !== null || el === document.activeElement\n      );\n\n    if (autoFocus) {\n      const first = focusables()[0];\n      (first ?? container).focus({ preventScroll: true });\n    }\n\n    const onKeyDown = (event: KeyboardEvent) => {\n      if (event.key !== \"Tab\") {\n        return;\n      }\n      const items = focusables();\n      if (items.length === 0) {\n        event.preventDefault();\n        return;\n      }\n      const first = items[0];\n      const last = items[items.length - 1];\n      const activeEl = document.activeElement;\n\n      if (event.shiftKey && activeEl === first) {\n        event.preventDefault();\n        last.focus();\n      } else if (!event.shiftKey && activeEl === last) {\n        event.preventDefault();\n        first.focus();\n      } else if (!container.contains(activeEl)) {\n        event.preventDefault();\n        first.focus();\n      }\n    };\n\n    document.addEventListener(\"keydown\", onKeyDown, true);\n    return () => {\n      document.removeEventListener(\"keydown\", onKeyDown, true);\n      if (restoreFocus && prevFocused.current) {\n        prevFocused.current.focus({ preventScroll: true });\n      }\n    };\n  }, [active, autoFocus, restoreFocus, containerRef]);\n}\n\nexport default useFocusTrap;\n"],"names":["FOCUSABLE","useFocusTrap","containerRef","active","restoreFocus","autoFocus","prevFocused","useRef","useEffect","container","focusables","el","first","onKeyDown","event","items","last","activeEl"],"mappings":";AAEA,MAAMA,IACJ;AAeK,SAASC,EACdC,GACA,EAAE,QAAAC,GAAQ,cAAAC,IAAe,IAAM,WAAAC,IAAY,MACrC;AACN,QAAMC,IAAcC,EAA2B,IAAI;AAEnD,EAAAC,EAAU,MAAM;AACd,QAAI,CAACL;AACH;AAEF,UAAMM,IAAYP,EAAa;AAC/B,QAAI,CAACO;AACH;AAGF,IAAAH,EAAY,UAAU,SAAS;AAE/B,UAAMI,IAAa,MACjB,MAAM,KAAKD,EAAU,iBAA8BT,CAAS,CAAC,EAAE;AAAA,MAC7D,CAACW,MAAOA,EAAG,iBAAiB,QAAQA,MAAO,SAAS;AAAA,IAAA;AAGxD,QAAIN,GAAW;AACb,YAAMO,IAAQF,EAAA,EAAa,CAAC;AAC5B,OAACE,KAAA,OAAAA,IAASH,GAAW,MAAM,EAAE,eAAe,IAAM;AAAA,IACpD;AAEA,UAAMI,IAAY,CAACC,MAAyB;AAC1C,UAAIA,EAAM,QAAQ;AAChB;AAEF,YAAMC,IAAQL,EAAA;AACd,UAAIK,EAAM,WAAW,GAAG;AACtB,QAAAD,EAAM,eAAA;AACN;AAAA,MACF;AACA,YAAMF,IAAQG,EAAM,CAAC,GACfC,IAAOD,EAAMA,EAAM,SAAS,CAAC,GAC7BE,IAAW,SAAS;AAE1B,MAAIH,EAAM,YAAYG,MAAaL,KACjCE,EAAM,eAAA,GACNE,EAAK,MAAA,KACI,CAACF,EAAM,YAAYG,MAAaD,KACzCF,EAAM,eAAA,GACNF,EAAM,MAAA,KACIH,EAAU,SAASQ,CAAQ,MACrCH,EAAM,eAAA,GACNF,EAAM,MAAA;AAAA,IAEV;AAEA,oBAAS,iBAAiB,WAAWC,GAAW,EAAI,GAC7C,MAAM;AACX,eAAS,oBAAoB,WAAWA,GAAW,EAAI,GACnDT,KAAgBE,EAAY,WAC9BA,EAAY,QAAQ,MAAM,EAAE,eAAe,IAAM;AAAA,IAErD;AAAA,EACF,GAAG,CAACH,GAAQE,GAAWD,GAAcF,CAAY,CAAC;AACpD;"}
+{"version":3,"file":"useFocusTrap.js","sources":["../../src/hooks/useFocusTrap.ts"],"sourcesContent":["import { RefObject, useEffect, useRef } from \"react\";\n\n/** Elements in the Tab order (hidden ones match too). */\nexport const FOCUSABLE =\n  'a[href],button:not([disabled]),textarea:not([disabled]),input:not([disabled]),select:not([disabled]),[tabindex]:not([tabindex=\"-1\"])';\n\nexport interface UseFocusTrapOptions {\n  /** Trap is active only while true. */\n  active: boolean;\n  /** Restore focus to the previously focused element on deactivate. */\n  restoreFocus?: boolean;\n  /** Focus the first focusable element on activate. */\n  autoFocus?: boolean;\n  /**\n   * Checked on every Tab. While it returns false the trap leaves the key alone, so a trap stacked above\n   * this one (a dialog opened from inside the container) handles it. Defaults to always true.\n   */\n  isTopmost?: () => boolean;\n}\n\n/**\n * Confines Tab/Shift+Tab focus within `containerRef` while `active`.\n * Restores focus to the previously focused element on teardown.\n */\nexport function useFocusTrap<T extends HTMLElement>(\n  containerRef: RefObject<T>,\n  { active, restoreFocus = true, autoFocus = true, isTopmost }: UseFocusTrapOptions\n): void {\n  const prevFocused = useRef<HTMLElement | null>(null);\n  // Read at key time, never as an effect dependency: an inline callback would re-arm the trap on every\n  // render and re-run `autoFocus`.\n  const isTopmostRef = useRef(isTopmost);\n  isTopmostRef.current = isTopmost;\n\n  useEffect(() => {\n    if (!active) {\n      return;\n    }\n    const container = containerRef.current;\n    if (!container) {\n      return;\n    }\n\n    prevFocused.current = document.activeElement as HTMLElement | null;\n\n    const focusables = () =>\n      Array.from(container.querySelectorAll<HTMLElement>(FOCUSABLE)).filter(\n        (el) => el.offsetParent !== null || el === document.activeElement\n      );\n\n    // A child that has already taken the focus (an `autoFocus` field, or one focusing itself in an\n    // effect) keeps it; the trap only brings in a focus that is still outside.\n    if (autoFocus && !container.contains(document.activeElement)) {\n      const first = focusables()[0];\n      (first ?? container).focus({ preventScroll: true });\n    }\n\n    const onKeyDown = (event: KeyboardEvent) => {\n      if (event.key !== \"Tab\") {\n        return;\n      }\n      const isTopmost = isTopmostRef.current;\n      if (isTopmost && !isTopmost()) {\n        return;\n      }\n      const items = focusables();\n      if (items.length === 0) {\n        event.preventDefault();\n        // Nothing left to tab through (e.g. every control disabled) and Chromium has dropped the\n        // focus to <body>: pull it back into the container instead of leaving it behind the dialog.\n        container.focus({ preventScroll: true });\n        return;\n      }\n      const first = items[0];\n      const last = items[items.length - 1];\n      const activeEl = document.activeElement;\n\n      if (activeEl === container) {\n        // The container itself holds the focus (a press on its empty area, or the `autoFocus`\n        // fallback): it is not a tab stop, so the browser would step to the page behind it.\n        event.preventDefault();\n        (event.shiftKey ? last : first).focus();\n      } else if (event.shiftKey && activeEl === first) {\n        event.preventDefault();\n        last.focus();\n      } else if (!event.shiftKey && activeEl === last) {\n        event.preventDefault();\n        first.focus();\n      } else if (!container.contains(activeEl)) {\n        event.preventDefault();\n        first.focus();\n      }\n    };\n\n    document.addEventListener(\"keydown\", onKeyDown, true);\n    return () => {\n      document.removeEventListener(\"keydown\", onKeyDown, true);\n      if (restoreFocus && prevFocused.current) {\n        prevFocused.current.focus({ preventScroll: true });\n      }\n    };\n  }, [active, autoFocus, restoreFocus, containerRef]);\n}\n\nexport default useFocusTrap;\n"],"names":["FOCUSABLE","useFocusTrap","containerRef","active","restoreFocus","autoFocus","isTopmost","prevFocused","useRef","isTopmostRef","useEffect","container","focusables","el","first","onKeyDown","event","items","last","activeEl"],"mappings":";AAGO,MAAMA,IACX;AAoBK,SAASC,EACdC,GACA,EAAE,QAAAC,GAAQ,cAAAC,IAAe,IAAM,WAAAC,IAAY,IAAM,WAAAC,KAC3C;AACN,QAAMC,IAAcC,EAA2B,IAAI,GAG7CC,IAAeD,EAAOF,CAAS;AACrC,EAAAG,EAAa,UAAUH,GAEvBI,EAAU,MAAM;AACd,QAAI,CAACP;AACH;AAEF,UAAMQ,IAAYT,EAAa;AAC/B,QAAI,CAACS;AACH;AAGF,IAAAJ,EAAY,UAAU,SAAS;AAE/B,UAAMK,IAAa,MACjB,MAAM,KAAKD,EAAU,iBAA8BX,CAAS,CAAC,EAAE;AAAA,MAC7D,CAACa,MAAOA,EAAG,iBAAiB,QAAQA,MAAO,SAAS;AAAA,IAAA;AAKxD,QAAIR,KAAa,CAACM,EAAU,SAAS,SAAS,aAAa,GAAG;AAC5D,YAAMG,IAAQF,EAAA,EAAa,CAAC;AAC5B,OAACE,KAAA,OAAAA,IAASH,GAAW,MAAM,EAAE,eAAe,IAAM;AAAA,IACpD;AAEA,UAAMI,IAAY,CAACC,MAAyB;AAC1C,UAAIA,EAAM,QAAQ;AAChB;AAEF,YAAMV,IAAYG,EAAa;AAC/B,UAAIH,KAAa,CAACA;AAChB;AAEF,YAAMW,IAAQL,EAAA;AACd,UAAIK,EAAM,WAAW,GAAG;AACtB,QAAAD,EAAM,eAAA,GAGNL,EAAU,MAAM,EAAE,eAAe,GAAA,CAAM;AACvC;AAAA,MACF;AACA,YAAMG,IAAQG,EAAM,CAAC,GACfC,IAAOD,EAAMA,EAAM,SAAS,CAAC,GAC7BE,IAAW,SAAS;AAE1B,MAAIA,MAAaR,KAGfK,EAAM,eAAA,IACLA,EAAM,WAAWE,IAAOJ,GAAO,MAAA,KACvBE,EAAM,YAAYG,MAAaL,KACxCE,EAAM,eAAA,GACNE,EAAK,MAAA,KACI,CAACF,EAAM,YAAYG,MAAaD,KACzCF,EAAM,eAAA,GACNF,EAAM,MAAA,KACIH,EAAU,SAASQ,CAAQ,MACrCH,EAAM,eAAA,GACNF,EAAM,MAAA;AAAA,IAEV;AAEA,oBAAS,iBAAiB,WAAWC,GAAW,EAAI,GAC7C,MAAM;AACX,eAAS,oBAAoB,WAAWA,GAAW,EAAI,GACnDX,KAAgBG,EAAY,WAC9BA,EAAY,QAAQ,MAAM,EAAE,eAAe,IAAM;AAAA,IAErD;AAAA,EACF,GAAG,CAACJ,GAAQE,GAAWD,GAAcF,CAAY,CAAC;AACpD;"}

package/dist/hooks/useHelperText.d.ts

@@ -0,0 +1,21 @@
+import type React from "react";
+/**
+ * Whether `helperText` is shown under its control, so that it describes the control. TextFieldWrapper shows none for
+ * an inline field, and without helper text it draws a blank line in its place, which describes nothing.
+ */
+export declare function hasHelperText(helperText: React.ReactNode, inline?: boolean): boolean;
+export interface HelperTextOptions {
+    /** The field is inline: TextFieldWrapper draws no helper text for it. */
+    inline?: boolean;
+    /** The caller's own `aria-describedby`, kept after the helper text. */
+    describedBy?: string;
+}
+/**
+ * Links a control to the helper text drawn under it, by TextFieldWrapper or by the component itself (Rating). Put
+ * `id` on the helper text (TextFieldWrapper takes it as `helperTextId`) and `describedBy` on the control's
+ * `aria-describedby`: the helper text's id while it is shown, then the caller's own ids.
+ */
+export declare function useHelperText(helperText: React.ReactNode, { inline, describedBy }?: HelperTextOptions): {
+    id: string;
+    describedBy: string | undefined;
+};

package/dist/hooks/useHelperText.js

@@ -0,0 +1,13 @@
+import { useId as n } from "./useId.js";
+function d(e, o) {
+  return !o && !!e;
+}
+function l(e, { inline: o, describedBy: r } = {}) {
+  const t = n(void 0, "smwb-helper-text"), i = [d(e, o) ? t : void 0, r].filter(Boolean).join(" ");
+  return { id: t, describedBy: i || void 0 };
+}
+export {
+  d as hasHelperText,
+  l as useHelperText
+};
+//# sourceMappingURL=useHelperText.js.map

package/dist/hooks/useHelperText.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useHelperText.js","sources":["../../src/hooks/useHelperText.ts"],"sourcesContent":["import type React from \"react\";\nimport { useId } from \"./useId\";\n\n/**\n * Whether `helperText` is shown under its control, so that it describes the control. TextFieldWrapper shows none for\n * an inline field, and without helper text it draws a blank line in its place, which describes nothing.\n */\nexport function hasHelperText(helperText: React.ReactNode, inline?: boolean): boolean {\n  return !inline && Boolean(helperText);\n}\n\nexport interface HelperTextOptions {\n  /** The field is inline: TextFieldWrapper draws no helper text for it. */\n  inline?: boolean;\n  /** The caller's own `aria-describedby`, kept after the helper text. */\n  describedBy?: string;\n}\n\n/**\n * Links a control to the helper text drawn under it, by TextFieldWrapper or by the component itself (Rating). Put\n * `id` on the helper text (TextFieldWrapper takes it as `helperTextId`) and `describedBy` on the control's\n * `aria-describedby`: the helper text's id while it is shown, then the caller's own ids.\n */\nexport function useHelperText(\n  helperText: React.ReactNode,\n  { inline, describedBy }: HelperTextOptions = {}\n): { id: string; describedBy: string | undefined } {\n  const id = useId(undefined, \"smwb-helper-text\");\n  const ids = [hasHelperText(helperText, inline) ? id : undefined, describedBy].filter(Boolean).join(\" \");\n  return { id, describedBy: ids || undefined };\n}\n"],"names":["hasHelperText","helperText","inline","useHelperText","describedBy","id","useId","ids"],"mappings":";AAOO,SAASA,EAAcC,GAA6BC,GAA2B;AACpF,SAAO,CAACA,KAAU,EAAQD;AAC5B;AAcO,SAASE,EACdF,GACA,EAAE,QAAAC,GAAQ,aAAAE,EAAA,IAAmC,CAAA,GACI;AACjD,QAAMC,IAAKC,EAAM,QAAW,kBAAkB,GACxCC,IAAM,CAACP,EAAcC,GAAYC,CAAM,IAAIG,IAAK,QAAWD,CAAW,EAAE,OAAO,OAAO,EAAE,KAAK,GAAG;AACtG,SAAO,EAAE,IAAAC,GAAI,aAAaE,KAAO,OAAA;AACnC;"}

package/dist/hooks/useKeyboardShortcut.d.ts

@@ -0,0 +1,30 @@
+export interface UseKeyboardShortcutOptions {
+    /** The shortcut in `Kbd` key names, e.g. `["Mod", "K"]` (Command on macOS, Ctrl elsewhere). */
+    keys: string[];
+    /** Runs on a matching keydown anywhere in the document; the event's default action is prevented. */
+    onTrigger: (event: KeyboardEvent) => void;
+    /** Listen only while true; `true` by default. */
+    enabled?: boolean;
+}
+/**
+ * Binds a global keyboard shortcut while the component is mounted — the Mod+K that opens a
+ * `CommandPalette`, or any other app-wide key. One `keydown` listener on the document, added while
+ * `enabled` and removed on cleanup; nothing runs on the server.
+ *
+ * An event another handler already used (`defaultPrevented`), a key repeat and an IME composition
+ * are ignored. On a match the default action is prevented first — Chrome and Firefox otherwise take
+ * Ctrl+K for their own search — and then `onTrigger` runs. Modifiers must match exactly, so Mod+K
+ * does not fire on Mod+Shift+K, and a single letter or digit also matches by `event.code`, so the
+ * shortcut keeps working on a keyboard layout that types other letters.
+ *
+ * `keys` and `onTrigger` are read when the event arrives, so a new function identity on each render
+ * never re-subscribes the listener.
+ *
+ * ```tsx
+ * const [open, setOpen] = useState(false);
+ * useKeyboardShortcut({ keys: ["Mod", "K"], onTrigger: () => setOpen((was) => !was) });
+ * <Kbd keys={["Mod", "K"]} />
+ * ```
+ */
+export declare function useKeyboardShortcut({ keys, onTrigger, enabled }: UseKeyboardShortcutOptions): void;
+export default useKeyboardShortcut;

package/dist/hooks/useKeyboardShortcut.js

@@ -0,0 +1,19 @@
+import { useRef as c, useEffect as f } from "react";
+import { matchesKeyboardShortcut as s } from "../utils/keyboardShortcut.js";
+function m({ keys: t, onTrigger: o, enabled: u = !0 }) {
+  const e = c({ keys: t, onTrigger: o });
+  e.current = { keys: t, onTrigger: o }, f(() => {
+    if (!u)
+      return;
+    const n = (r) => {
+      r.defaultPrevented || r.repeat || r.isComposing || r.keyCode === 229 || s(r, e.current.keys) && (r.preventDefault(), e.current.onTrigger(r));
+    };
+    return document.addEventListener("keydown", n), () => {
+      document.removeEventListener("keydown", n);
+    };
+  }, [u]);
+}
+export {
+  m as useKeyboardShortcut
+};
+//# sourceMappingURL=useKeyboardShortcut.js.map

package/dist/hooks/useKeyboardShortcut.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKeyboardShortcut.js","sources":["../../src/hooks/useKeyboardShortcut.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\nimport { matchesKeyboardShortcut } from \"../utils/keyboardShortcut\";\n\nexport interface UseKeyboardShortcutOptions {\n  /** The shortcut in `Kbd` key names, e.g. `[\"Mod\", \"K\"]` (Command on macOS, Ctrl elsewhere). */\n  keys: string[];\n  /** Runs on a matching keydown anywhere in the document; the event's default action is prevented. */\n  onTrigger: (event: KeyboardEvent) => void;\n  /** Listen only while true; `true` by default. */\n  enabled?: boolean;\n}\n\n/**\n * Binds a global keyboard shortcut while the component is mounted — the Mod+K that opens a\n * `CommandPalette`, or any other app-wide key. One `keydown` listener on the document, added while\n * `enabled` and removed on cleanup; nothing runs on the server.\n *\n * An event another handler already used (`defaultPrevented`), a key repeat and an IME composition\n * are ignored. On a match the default action is prevented first — Chrome and Firefox otherwise take\n * Ctrl+K for their own search — and then `onTrigger` runs. Modifiers must match exactly, so Mod+K\n * does not fire on Mod+Shift+K, and a single letter or digit also matches by `event.code`, so the\n * shortcut keeps working on a keyboard layout that types other letters.\n *\n * `keys` and `onTrigger` are read when the event arrives, so a new function identity on each render\n * never re-subscribes the listener.\n *\n * ```tsx\n * const [open, setOpen] = useState(false);\n * useKeyboardShortcut({ keys: [\"Mod\", \"K\"], onTrigger: () => setOpen((was) => !was) });\n * <Kbd keys={[\"Mod\", \"K\"]} />\n * ```\n */\nexport function useKeyboardShortcut({ keys, onTrigger, enabled = true }: UseKeyboardShortcutOptions): void {\n  const latest = useRef({ keys, onTrigger });\n  latest.current = { keys, onTrigger };\n\n  useEffect(() => {\n    if (!enabled) {\n      return;\n    }\n    const onKeyDown = (event: KeyboardEvent) => {\n      if (event.defaultPrevented || event.repeat || event.isComposing || event.keyCode === 229) {\n        return;\n      }\n      if (!matchesKeyboardShortcut(event, latest.current.keys)) {\n        return;\n      }\n      event.preventDefault();\n      latest.current.onTrigger(event);\n    };\n    document.addEventListener(\"keydown\", onKeyDown);\n    return () => {\n      document.removeEventListener(\"keydown\", onKeyDown);\n    };\n  }, [enabled]);\n}\n\nexport default useKeyboardShortcut;\n"],"names":["useKeyboardShortcut","keys","onTrigger","enabled","latest","useRef","useEffect","onKeyDown","event","matchesKeyboardShortcut"],"mappings":";;AAgCO,SAASA,EAAoB,EAAE,MAAAC,GAAM,WAAAC,GAAW,SAAAC,IAAU,MAA0C;AACzG,QAAMC,IAASC,EAAO,EAAE,MAAAJ,GAAM,WAAAC,GAAW;AACzC,EAAAE,EAAO,UAAU,EAAE,MAAAH,GAAM,WAAAC,EAAA,GAEzBI,EAAU,MAAM;AACd,QAAI,CAACH;AACH;AAEF,UAAMI,IAAY,CAACC,MAAyB;AAC1C,MAAIA,EAAM,oBAAoBA,EAAM,UAAUA,EAAM,eAAeA,EAAM,YAAY,OAGhFC,EAAwBD,GAAOJ,EAAO,QAAQ,IAAI,MAGvDI,EAAM,eAAA,GACNJ,EAAO,QAAQ,UAAUI,CAAK;AAAA,IAChC;AACA,oBAAS,iBAAiB,WAAWD,CAAS,GACvC,MAAM;AACX,eAAS,oBAAoB,WAAWA,CAAS;AAAA,IACnD;AAAA,EACF,GAAG,CAACJ,CAAO,CAAC;AACd;"}