@windmorph/react 0.0.0-stage → 0.1.0

package/dist/utils/natural-size.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"natural-size.js","names":[],"sources":["../../src/utils/natural-size.ts"],"sourcesContent":["'use client';\n\nimport { useEffect, useLayoutEffect, useRef, useState } from 'react';\n\n/**\n * Measures an element's natural length on one axis (its used `width` or `height`, in\n * fractional px and untouched by transforms, as a scaled-down hidden FAB is), again whenever\n * it resizes, so a wrapper can animate its own width or height between 0 and that length.\n * A length in px lets a spring's overshoot show, which a `0fr ↔ 1fr` grid track can't (it\n * never passes its content's size). The element must keep its natural size while the\n * wrapper is closed (`w-max` / `h-max`, or `shrink-0`). The size is `undefined` until\n * measured (and on the server), so the wrapper can fall back to its natural size.\n *\n * `resized` is true for one frame after the content itself changed size (a web font\n * arriving, new text): the wrapper should follow it at once (`data-resized`, no\n * transition), as a grid track would, instead of springing to it.\n */\nexport function useNaturalSize<T extends HTMLElement = HTMLElement>(\n  axis: 'width' | 'height' = 'width',\n  enabled = true,\n) {\n  const ref = useRef<T>(null);\n  const [size, setSize] = useState<number>();\n  const [resized, setResized] = useState(false);\n  useLayoutEffect(() => {\n    const element = ref.current;\n    if (!enabled || !element) return;\n    let measured: number | undefined;\n    const measure = () => {\n      const used = parseFloat(getComputedStyle(element)[axis]);\n      const next = Number.isNaN(used) ? undefined : used;\n      if (next === measured) return;\n      if (measured !== undefined) setResized(true);\n      measured = next;\n      setSize(next);\n    };\n    measure();\n    if (typeof ResizeObserver === 'undefined') return;\n    const observer = new ResizeObserver(measure);\n    observer.observe(element);\n    return () => observer.disconnect();\n  }, [axis, enabled]);\n  useEffect(() => {\n    if (!resized) return;\n    const frame = requestAnimationFrame(() => setResized(false));\n    return () => cancelAnimationFrame(frame);\n  }, [resized, size]);\n  return [ref, size, resized] as const;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAiBA,SAAgB,eACd,OAA2B,SAC3B,UAAU,MACV;CACA,MAAM,MAAM,OAAU,IAAI;CAC1B,MAAM,CAAC,MAAM,WAAW,SAAiB;CACzC,MAAM,CAAC,SAAS,cAAc,SAAS,KAAK;CAC5C,sBAAsB;EACpB,MAAM,UAAU,IAAI;EACpB,IAAI,CAAC,WAAW,CAAC,SAAS;EAC1B,IAAI;EACJ,MAAM,gBAAgB;GACpB,MAAM,OAAO,WAAW,iBAAiB,OAAO,CAAC,CAAC,KAAK;GACvD,MAAM,OAAO,OAAO,MAAM,IAAI,IAAI,KAAA,IAAY;GAC9C,IAAI,SAAS,UAAU;GACvB,IAAI,aAAa,KAAA,GAAW,WAAW,IAAI;GAC3C,WAAW;GACX,QAAQ,IAAI;EACd;EACA,QAAQ;EACR,IAAI,OAAO,mBAAmB,aAAa;EAC3C,MAAM,WAAW,IAAI,eAAe,OAAO;EAC3C,SAAS,QAAQ,OAAO;EACxB,aAAa,SAAS,WAAW;CACnC,GAAG,CAAC,MAAM,OAAO,CAAC;CAClB,gBAAgB;EACd,IAAI,CAAC,SAAS;EACd,MAAM,QAAQ,4BAA4B,WAAW,KAAK,CAAC;EAC3D,aAAa,qBAAqB,KAAK;CACzC,GAAG,CAAC,SAAS,IAAI,CAAC;CAClB,OAAO;EAAC;EAAK;EAAM;CAAO;AAC5B"}

package/dist/utils/nearest-reveal.js

@@ -0,0 +1,28 @@
+import { useLayoutEffect } from "react";
+//#region src/utils/nearest-reveal.ts
+/**
+* Arrow keys must not jump the page. When keyboard focus moves to an item, React Aria
+* reveals it by calling `scrollIntoView({ block: 'center', inline: 'center' })` on the
+* collection's root whenever the root isn't wholly on screen, which scrolls every ancestor,
+* the window included, to centre the root (176px for a tab row, 200px for a list taller
+* than the window), and then reveals the item. The root's own `scrollIntoView` asks for the
+* nearest position instead, so the page moves only as far as the item needs (2026-10-15).
+*/
+function useNearestReveal(rootRef) {
+	useLayoutEffect(() => {
+		const root = rootRef.current;
+		if (!root) return;
+		root.scrollIntoView = (arg) => Element.prototype.scrollIntoView?.call(root, typeof arg === "object" ? {
+			...arg,
+			block: "nearest",
+			inline: "nearest"
+		} : arg);
+		return () => {
+			Reflect.deleteProperty(root, "scrollIntoView");
+		};
+	}, [rootRef]);
+}
+//#endregion
+export { useNearestReveal };
+
+//# sourceMappingURL=nearest-reveal.js.map

package/dist/utils/nearest-reveal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nearest-reveal.js","names":[],"sources":["../../src/utils/nearest-reveal.ts"],"sourcesContent":["import { useLayoutEffect, type RefObject } from 'react';\n\n/**\n * Arrow keys must not jump the page. When keyboard focus moves to an item, React Aria\n * reveals it by calling `scrollIntoView({ block: 'center', inline: 'center' })` on the\n * collection's root whenever the root isn't wholly on screen, which scrolls every ancestor,\n * the window included, to centre the root (176px for a tab row, 200px for a list taller\n * than the window), and then reveals the item. The root's own `scrollIntoView` asks for the\n * nearest position instead, so the page moves only as far as the item needs (2026-10-15).\n */\nexport function useNearestReveal(rootRef: RefObject<HTMLElement | null>) {\n  useLayoutEffect(() => {\n    const root = rootRef.current;\n    if (!root) return;\n    root.scrollIntoView = (arg?: boolean | ScrollIntoViewOptions) =>\n      Element.prototype.scrollIntoView?.call(\n        root,\n        typeof arg === 'object' ? { ...arg, block: 'nearest', inline: 'nearest' } : arg,\n      );\n    return () => {\n      Reflect.deleteProperty(root, 'scrollIntoView');\n    };\n  }, [rootRef]);\n}\n"],"mappings":";;;;;;;;;;AAUA,SAAgB,iBAAiB,SAAwC;CACvE,sBAAsB;EACpB,MAAM,OAAO,QAAQ;EACrB,IAAI,CAAC,MAAM;EACX,KAAK,kBAAkB,QACrB,QAAQ,UAAU,gBAAgB,KAChC,MACA,OAAO,QAAQ,WAAW;GAAE,GAAG;GAAK,OAAO;GAAW,QAAQ;EAAU,IAAI,GAC9E;EACF,aAAa;GACX,QAAQ,eAAe,MAAM,gBAAgB;EAC/C;CACF,GAAG,CAAC,OAAO,CAAC;AACd"}

package/dist/utils/placement.js

@@ -0,0 +1,14 @@
+//#region src/utils/placement.ts
+/**
+* React Aria's placement for one of ours: a hyphenated, logical value (`'bottom-start'`, as
+* Floating UI and most libraries write it) becomes its spaced, physical form (`'bottom left'`),
+* resolving `start` / `end` from the laid-out direction, since React Aria reads its locale
+* rather than the DOM's `dir`.
+*/
+function toAriaPlacement(placement, rtl) {
+	return placement.replace("-", " ").replace("start", rtl ? "right" : "left").replace("end", rtl ? "left" : "right");
+}
+//#endregion
+export { toAriaPlacement };
+
+//# sourceMappingURL=placement.js.map

package/dist/utils/placement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"placement.js","names":[],"sources":["../../src/utils/placement.ts"],"sourcesContent":["import type { Placement } from 'react-aria';\n\n/**\n * React Aria's placement for one of ours: a hyphenated, logical value (`'bottom-start'`, as\n * Floating UI and most libraries write it) becomes its spaced, physical form (`'bottom left'`),\n * resolving `start` / `end` from the laid-out direction, since React Aria reads its locale\n * rather than the DOM's `dir`.\n */\nexport function toAriaPlacement(placement: string, rtl: boolean): Placement {\n  return placement\n    .replace('-', ' ')\n    .replace('start', rtl ? 'right' : 'left')\n    .replace('end', rtl ? 'left' : 'right') as Placement;\n}\n"],"mappings":";;;;;;;AAQA,SAAgB,gBAAgB,WAAmB,KAAyB;CAC1E,OAAO,UACJ,QAAQ,KAAK,GAAG,CAAC,CACjB,QAAQ,SAAS,MAAM,UAAU,MAAM,CAAC,CACxC,QAAQ,OAAO,MAAM,SAAS,OAAO;AAC1C"}

package/dist/utils/radio-group-keys.js

@@ -0,0 +1,74 @@
+import { hasModifier, isRtl, moveFor, target } from "./composite-keys.js";
+import { tabbables } from "./focus.js";
+//#region src/utils/radio-group-keys.ts
+/** A group's radios that can be checked, in order. */
+function radios(root) {
+	return [...root.querySelectorAll("[role=\"radio\"]")].filter((radio) => !radio.matches(":disabled, [aria-disabled=\"true\"]") && !radio.closest("[hidden], [inert]") && (!("checkVisibility" in radio) || radio.checkVisibility()));
+}
+/**
+* The WAI-ARIA APG radio group keys, for a single-selection group of toggle buttons with
+* `role="radio"`: every arrow key moves to the next or previous radio and checks it,
+* wrapping at the ends (left and right follow the laid-out direction), and Home and End
+* check the first and last. The radio is checked with a click, as a native radio's arrow
+* keys do, so its press handlers run. Other controls in the group (a button group's overflow
+* button) stay on the arrow keys' path without being checked, as in the APG toolbar that
+* holds a radio group. Returns whether the key was handled.
+*/
+function radioGroupKeyDown(event) {
+	const root = event.currentTarget;
+	const from = event.target;
+	if (hasModifier(event) || from.matches("textarea, [contenteditable]:not([contenteditable=\"false\"]), input:not([type=\"button\"], [type=\"checkbox\"], [type=\"radio\"], [type=\"submit\"], [type=\"reset\"], [type=\"image\"], [type=\"range\"], [type=\"color\"], [type=\"file\"])")) return false;
+	const move = moveFor(event.key, "both", isRtl(root));
+	if (move === null) return false;
+	const choices = radios(root);
+	const items = [.../* @__PURE__ */ new Set([...tabbables(root), ...choices])].sort((a, b) => a.compareDocumentPosition(b) & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1);
+	const current = items.findIndex((item) => item === from || item.contains(from));
+	if (current < 0) return false;
+	event.preventDefault();
+	event.stopPropagation();
+	const next = target(items, current, move);
+	if (!next || next === items[current]) return true;
+	next.focus();
+	if (choices.includes(next) && next.getAttribute("aria-checked") !== "true") next.click();
+	return true;
+}
+/** Groups a pointer is pressing in: focus there comes from the press, not from Tab. */
+const pressed = /* @__PURE__ */ new WeakSet();
+/**
+* For a radio group's `onPointerDownCapture`: marks the group as pressed until the pointer
+* lifts, so `focusCheckedRadio` leaves the focus the press gives where it lands.
+*/
+function notePointerDown(event) {
+	const root = event.currentTarget;
+	pressed.add(root);
+	const release = () => {
+		setTimeout(() => pressed.delete(root));
+	};
+	for (const type of ["pointerup", "pointercancel"]) root.ownerDocument.addEventListener(type, release, {
+		once: true,
+		capture: true
+	});
+}
+/**
+* Tab into a radio group lands on its checked radio (WAI-ARIA APG), for the group's
+* `onFocus`: when keyboard focus arrives from outside on another radio, it moves to the
+* checked one. A pointer press keeps focus on the radio it lands on (the group's
+* `onPointerDownCapture` calls `notePointerDown`): moving it would select one radio while
+* focusing another, and scroll the page to the checked one (2026-10-15).
+* Returns whether the group has a checked radio (so the caller's own focus restoring
+* applies only when it hasn't).
+*/
+function focusCheckedRadio(event) {
+	const root = event.currentTarget;
+	const from = event.relatedTarget;
+	if (from && root.contains(from)) return false;
+	const checked = radios(root).find((radio) => radio.getAttribute("aria-checked") === "true");
+	if (!checked) return false;
+	if (pressed.has(root)) return true;
+	if (checked !== event.target && event.target.matches("[role=\"radio\"]")) checked.focus();
+	return true;
+}
+//#endregion
+export { focusCheckedRadio, notePointerDown, radioGroupKeyDown };
+
+//# sourceMappingURL=radio-group-keys.js.map

package/dist/utils/radio-group-keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio-group-keys.js","names":[],"sources":["../../src/utils/radio-group-keys.ts"],"sourcesContent":["import type { FocusEvent, KeyboardEvent, PointerEvent } from 'react';\nimport { hasModifier, isRtl, moveFor, target, TEXT_ENTRY } from './composite-keys';\nimport { tabbables } from './focus';\n\n/** A group's radios that can be checked, in order. */\nfunction radios(root: HTMLElement): HTMLElement[] {\n  return [...root.querySelectorAll<HTMLElement>('[role=\"radio\"]')].filter(\n    (radio) =>\n      !radio.matches(':disabled, [aria-disabled=\"true\"]') &&\n      !radio.closest('[hidden], [inert]') &&\n      (!('checkVisibility' in radio) || radio.checkVisibility()),\n  );\n}\n\n/**\n * The WAI-ARIA APG radio group keys, for a single-selection group of toggle buttons with\n * `role=\"radio\"`: every arrow key moves to the next or previous radio and checks it,\n * wrapping at the ends (left and right follow the laid-out direction), and Home and End\n * check the first and last. The radio is checked with a click, as a native radio's arrow\n * keys do, so its press handlers run. Other controls in the group (a button group's overflow\n * button) stay on the arrow keys' path without being checked, as in the APG toolbar that\n * holds a radio group. Returns whether the key was handled.\n */\nexport function radioGroupKeyDown(event: KeyboardEvent<HTMLElement>) {\n  const root = event.currentTarget;\n  const from = event.target as HTMLElement;\n  if (hasModifier(event) || from.matches(TEXT_ENTRY)) return false;\n  const move = moveFor(event.key, 'both', isRtl(root));\n  if (move === null) return false;\n  const choices = radios(root);\n  const items = [...new Set([...tabbables(root), ...choices])].sort((a, b) =>\n    a.compareDocumentPosition(b) & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1,\n  );\n  const current = items.findIndex((item) => item === from || item.contains(from));\n  if (current < 0) return false;\n  event.preventDefault();\n  event.stopPropagation();\n  const next = target(items, current, move);\n  if (!next || next === items[current]) return true;\n  next.focus();\n  if (choices.includes(next) && next.getAttribute('aria-checked') !== 'true') next.click();\n  return true;\n}\n\n/** Groups a pointer is pressing in: focus there comes from the press, not from Tab. */\nconst pressed = new WeakSet<HTMLElement>();\n\n/**\n * For a radio group's `onPointerDownCapture`: marks the group as pressed until the pointer\n * lifts, so `focusCheckedRadio` leaves the focus the press gives where it lands.\n */\nexport function notePointerDown(event: PointerEvent<HTMLElement>) {\n  const root = event.currentTarget;\n  pressed.add(root);\n  const release = () => {\n    // After the press's own focus and click handlers.\n    setTimeout(() => pressed.delete(root));\n  };\n  for (const type of ['pointerup', 'pointercancel'] as const) {\n    root.ownerDocument.addEventListener(type, release, { once: true, capture: true });\n  }\n}\n\n/**\n * Tab into a radio group lands on its checked radio (WAI-ARIA APG), for the group's\n * `onFocus`: when keyboard focus arrives from outside on another radio, it moves to the\n * checked one. A pointer press keeps focus on the radio it lands on (the group's\n * `onPointerDownCapture` calls `notePointerDown`): moving it would select one radio while\n * focusing another, and scroll the page to the checked one (2026-10-15).\n * Returns whether the group has a checked radio (so the caller's own focus restoring\n * applies only when it hasn't).\n */\nexport function focusCheckedRadio(event: FocusEvent<HTMLElement>): boolean {\n  const root = event.currentTarget;\n  const from = event.relatedTarget as Node | null;\n  if (from && root.contains(from)) return false;\n  const checked = radios(root).find((radio) => radio.getAttribute('aria-checked') === 'true');\n  if (!checked) return false;\n  if (pressed.has(root)) return true;\n  if (checked !== event.target && (event.target as Element).matches('[role=\"radio\"]'))\n    checked.focus();\n  return true;\n}\n"],"mappings":";;;;AAKA,SAAS,OAAO,MAAkC;CAChD,OAAO,CAAC,GAAG,KAAK,iBAA8B,kBAAgB,CAAC,CAAC,CAAC,QAC9D,UACC,CAAC,MAAM,QAAQ,qCAAmC,KAClD,CAAC,MAAM,QAAQ,mBAAmB,MACjC,EAAE,qBAAqB,UAAU,MAAM,gBAAgB,EAC5D;AACF;;;;;;;;;;AAWA,SAAgB,kBAAkB,OAAmC;CACnE,MAAM,OAAO,MAAM;CACnB,MAAM,OAAO,MAAM;CACnB,IAAI,YAAY,KAAK,KAAK,KAAK,QAAA,+OAAkB,GAAG,OAAO;CAC3D,MAAM,OAAO,QAAQ,MAAM,KAAK,QAAQ,MAAM,IAAI,CAAC;CACnD,IAAI,SAAS,MAAM,OAAO;CAC1B,MAAM,UAAU,OAAO,IAAI;CAC3B,MAAM,QAAQ,CAAC,mBAAG,IAAI,IAAI,CAAC,GAAG,UAAU,IAAI,GAAG,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,MACpE,EAAE,wBAAwB,CAAC,IAAI,KAAK,8BAA8B,KAAK,CACzE;CACA,MAAM,UAAU,MAAM,WAAW,SAAS,SAAS,QAAQ,KAAK,SAAS,IAAI,CAAC;CAC9E,IAAI,UAAU,GAAG,OAAO;CACxB,MAAM,eAAe;CACrB,MAAM,gBAAgB;CACtB,MAAM,OAAO,OAAO,OAAO,SAAS,IAAI;CACxC,IAAI,CAAC,QAAQ,SAAS,MAAM,UAAU,OAAO;CAC7C,KAAK,MAAM;CACX,IAAI,QAAQ,SAAS,IAAI,KAAK,KAAK,aAAa,cAAc,MAAM,QAAQ,KAAK,MAAM;CACvF,OAAO;AACT;;AAGA,MAAM,0BAAU,IAAI,QAAqB;;;;;AAMzC,SAAgB,gBAAgB,OAAkC;CAChE,MAAM,OAAO,MAAM;CACnB,QAAQ,IAAI,IAAI;CAChB,MAAM,gBAAgB;EAEpB,iBAAiB,QAAQ,OAAO,IAAI,CAAC;CACvC;CACA,KAAK,MAAM,QAAQ,CAAC,aAAa,eAAe,GAC9C,KAAK,cAAc,iBAAiB,MAAM,SAAS;EAAE,MAAM;EAAM,SAAS;CAAK,CAAC;AAEpF;;;;;;;;;;AAWA,SAAgB,kBAAkB,OAAyC;CACzE,MAAM,OAAO,MAAM;CACnB,MAAM,OAAO,MAAM;CACnB,IAAI,QAAQ,KAAK,SAAS,IAAI,GAAG,OAAO;CACxC,MAAM,UAAU,OAAO,IAAI,CAAC,CAAC,MAAM,UAAU,MAAM,aAAa,cAAc,MAAM,MAAM;CAC1F,IAAI,CAAC,SAAS,OAAO;CACrB,IAAI,QAAQ,IAAI,IAAI,GAAG,OAAO;CAC9B,IAAI,YAAY,MAAM,UAAW,MAAM,OAAmB,QAAQ,kBAAgB,GAChF,QAAQ,MAAM;CAChB,OAAO;AACT"}

package/dist/utils/rendered-description.js

@@ -0,0 +1,17 @@
+//#region src/utils/rendered-description.ts
+/**
+* A field's `aria-describedby` without the ids of the parts it doesn't render (2026-10-24).
+* React Aria's field hooks name the description and error ids through `useSlotId`, which drops
+* an id whose element isn't in the page only after it mounts: on the server it can't tell, so
+* the server's HTML pointed at a supporting text or error that wasn't there until hydration.
+* `unrendered` lists the ids of the parts this render leaves out (falsy entries are ignored).
+*/
+function renderedDescription(describedBy, unrendered) {
+	if (!describedBy) return void 0;
+	const missing = new Set(unrendered.filter(Boolean));
+	return describedBy.split(/\s+/).filter((id) => id && !missing.has(id)).join(" ") || void 0;
+}
+//#endregion
+export { renderedDescription };
+
+//# sourceMappingURL=rendered-description.js.map

package/dist/utils/rendered-description.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rendered-description.js","names":[],"sources":["../../src/utils/rendered-description.ts"],"sourcesContent":["/**\n * A field's `aria-describedby` without the ids of the parts it doesn't render (2026-10-24).\n * React Aria's field hooks name the description and error ids through `useSlotId`, which drops\n * an id whose element isn't in the page only after it mounts: on the server it can't tell, so\n * the server's HTML pointed at a supporting text or error that wasn't there until hydration.\n * `unrendered` lists the ids of the parts this render leaves out (falsy entries are ignored).\n */\nexport function renderedDescription(\n  describedBy: string | undefined,\n  unrendered: readonly (string | false | null | undefined)[],\n): string | undefined {\n  if (!describedBy) return undefined;\n  const missing = new Set(unrendered.filter(Boolean));\n  return (\n    describedBy\n      .split(/\\s+/)\n      .filter((id) => id && !missing.has(id))\n      .join(' ') || undefined\n  );\n}\n"],"mappings":";;;;;;;;AAOA,SAAgB,oBACd,aACA,YACoB;CACpB,IAAI,CAAC,aAAa,OAAO,KAAA;CACzB,MAAM,UAAU,IAAI,IAAI,WAAW,OAAO,OAAO,CAAC;CAClD,OACE,YACG,MAAM,KAAK,CAAC,CACZ,QAAQ,OAAO,MAAM,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,CACtC,KAAK,GAAG,KAAK,KAAA;AAEpB"}

package/dist/utils/root-props.d.ts

@@ -0,0 +1,103 @@
+import { AriaAttributes, DOMAttributes, HTMLAttributes } from "react";
+//#region src/utils/root-props.d.ts
+/** The naming attributes React Aria puts on the element it labels (a field's input, a tablist). */
+type Labelling = 'aria-label' | 'aria-labelledby' | 'aria-describedby' | 'aria-details' | 'aria-errormessage';
+/**
+ * The attributes that describe a widget's own state and relations (2026-10-17): what it controls
+ * and whether it opens a popup, its autocompletion and active descendant, whether it is
+ * expanded, required, invalid or read-only, and a text box's `aria-multiline` and
+ * `aria-placeholder`. They belong on the widget, never on a wrapper (ARIA doesn't allow them on
+ * a generic `div` or a `label`).
+ */
+export type WidgetAria = 'aria-controls' | 'aria-haspopup' | 'aria-autocomplete' | 'aria-activedescendant' | 'aria-expanded' | 'aria-required' | 'aria-invalid' | 'aria-readonly' | 'aria-multiline' | 'aria-placeholder';
+/**
+ * The naming and description attributes React Aria's hooks don't forward (2026-10-24): a plain
+ * text description, a role description and the braille label and role description. Like the
+ * naming attributes, they belong on the element React Aria labels: ARIA prohibits
+ * `aria-roledescription` and the braille attributes on a generic `div`, and a description there
+ * describes nothing. A component takes them in its props, as {@link RootDOMProps} does; where
+ * the root wraps the labelled element, {@link splitRootProps} keeps them in `rest` and
+ * {@link pickWidgetAria} hands them over.
+ */
+export type DescriptionAria = 'aria-description' | 'aria-roledescription' | 'aria-braillelabel' | 'aria-brailleroledescription';
+/** Events about the whole component: pointer, mouse, touch, drag, wheel, scroll, animation. */
+export type RootEvent = 'onClick' | 'onAuxClick' | 'onContextMenu' | 'onDoubleClick' | `onMouse${'Down' | 'Enter' | 'Leave' | 'Move' | 'Out' | 'Over' | 'Up'}` | `onPointer${'Down' | 'Move' | 'Up' | 'Cancel' | 'Enter' | 'Leave' | 'Over' | 'Out'}` | 'onGotPointerCapture' | 'onLostPointerCapture' | `onTouch${'Start' | 'Move' | 'End' | 'Cancel'}` | `onDrag${'' | 'End' | 'Enter' | 'Exit' | 'Leave' | 'Over' | 'Start'}` | 'onDrop' | 'onWheel' | 'onScroll' | `onAnimation${'Start' | 'End' | 'Iteration'}` | `onTransition${'Start' | 'Run' | 'End' | 'Cancel'}`;
+/** Global HTML attributes about the whole component. */
+type Global = 'title' | 'lang' | 'dir' | 'hidden' | 'inert' | 'translate' | 'draggable';
+/**
+ * The DOM attributes a component passes to its root when its other props go to a React Aria
+ * hook (2026-10-17): `data-*`, `aria-*` but the naming ones, global attributes and
+ * {@link RootEvent}s. The {@link DescriptionAria} attributes are among them, for a root that is
+ * the labelled element; a wrapper hands them to that element instead. The naming attributes, focus, key and input events (which would fire twice
+ * as they bubble from the element the hook manages) and React Aria's callbacks stay with the hook.
+ */
+export type RootDOMProps<E extends Element = HTMLDivElement> = Pick<DOMAttributes<E>, Extract<keyof DOMAttributes<E>, RootEvent | `${RootEvent}Capture`>> & Omit<AriaAttributes, Labelling> & Pick<HTMLAttributes<E>, Global>;
+/**
+ * {@link RootDOMProps} for a component whose root wraps the element React Aria labels (a
+ * field's input, a checkbox's input, a select's trigger, a tab list): without the
+ * {@link WidgetAria} attributes, which describe that element. A component that lets the app set
+ * them takes them in its own props and puts them on that element. The {@link DescriptionAria}
+ * attributes stay in the type: they reach that element through {@link pickWidgetAria}.
+ */
+export type WrapperRootDOMProps<E extends Element = HTMLDivElement> = Omit<RootDOMProps<E>, WidgetAria>;
+/** Options for {@link splitRootProps}. */
+export interface SplitRootPropsOptions {
+  /**
+   * The root wraps the element React Aria labels (see {@link WrapperRootDOMProps}), so the
+   * {@link WidgetAria} and {@link DescriptionAria} attributes stay in `rest`, for that element,
+   * instead of going to the root.
+   * @default false
+   */
+  wrapper?: boolean;
+}
+/** What {@link splitRootProps} returns. */
+export interface SplitRootProps<Rest> {
+  /**
+   * `data-*`, `aria-*` but the naming ones (and, for a wrapper, the {@link WidgetAria} and
+   * {@link DescriptionAria} ones), global attributes and root events.
+   */
+  root: Record<string, unknown>;
+  /**
+   * Everything else, for the hook. Its type leaves out what went to `root`: for a wrapper, the
+   * widget and description attributes stay in it.
+   */
+  rest: Rest;
+}
+/**
+ * Splits a component's {@link RootDOMProps} (and every `data-*` attribute) from the props for its
+ * React Aria hook, for a component whose hook forwards only the attributes it knows. Spread
+ * `root` on the root element (merging its handlers with the hook's, React Aria's `mergeProps`)
+ * and pass `rest` to the hook. A component whose hook labels the root itself (a radio group, a
+ * slider's group) merges both there. One whose root wraps the labelled element passes
+ * `{ wrapper: true }`, so the attributes that describe that element (`aria-controls`,
+ * `aria-expanded`, `aria-invalid` …, {@link WidgetAria}, and `aria-description` …,
+ * {@link DescriptionAria}) stay with it; React Aria's hooks forward only some of them, so
+ * {@link pickWidgetAria} hands over the rest.
+ *
+ * @example
+ * const { root, rest } = splitRootProps(props, { wrapper: true });
+ * const { labelProps, inputProps } = useTextField(rest, inputRef);
+ * return (
+ *   <div {...root}>
+ *     <input {...mergeProps(inputProps, pickWidgetAria(rest))} />
+ *   </div>
+ * );
+ */
+export declare function splitRootProps<T extends object>(props: T, options: SplitRootPropsOptions & {
+  wrapper: true;
+}): SplitRootProps<Omit<T, Exclude<keyof WrapperRootDOMProps, DescriptionAria> | `data-${string}`>>;
+export declare function splitRootProps<T extends object>(props: T, options?: SplitRootPropsOptions): SplitRootProps<Omit<T, keyof RootDOMProps | `data-${string}`>>;
+/**
+ * The {@link WidgetAria} and {@link DescriptionAria} attributes among `props`, for the element
+ * React Aria labels: a hook forwards only those it knows (a text field's `aria-controls`, but not
+ * its `aria-expanded` or `aria-description`), so a wrapper component merges these with the
+ * hook's own props.
+ */
+export declare function pickWidgetAria(props: object): Pick<AriaAttributes, WidgetAria | DescriptionAria>;
+/**
+ * The {@link DescriptionAria} attributes among `props`, for a wrapper that sets every
+ * {@link WidgetAria} attribute of its labelled element itself (a select's trigger, a tab list).
+ */
+export declare function pickDescriptionAria(props: object): Pick<AriaAttributes, DescriptionAria>;
+//#endregion
+//# sourceMappingURL=root-props.d.ts.map

package/dist/utils/root-props.js

@@ -0,0 +1,51 @@
+//#region src/utils/root-props.ts
+/** {@link RootEvent} and its capture form, at run time. */
+const ROOT_EVENT = /^on(?:Click|AuxClick|ContextMenu|DoubleClick|Mouse(?:Down|Enter|Leave|Move|Out|Over|Up)|Pointer(?:Down|Move|Up|Cancel|Enter|Leave|Over|Out)|(?:Got|Lost)PointerCapture|Touch(?:Start|Move|End|Cancel)|Drag(?:End|Enter|Exit|Leave|Over|Start)?|Drop|Wheel|Scroll|Animation(?:Start|End|Iteration)|Transition(?:Start|Run|End|Cancel))(?:Capture)?$/;
+const LABELLING = /^aria-(?:label|labelledby|describedby|details|errormessage)$/;
+const WIDGET_ARIA = /^aria-(?:controls|haspopup|autocomplete|activedescendant|expanded|required|invalid|readonly|multiline|placeholder)$/;
+const DESCRIPTION_ARIA = /^aria-(?:description|roledescription|braillelabel|brailleroledescription)$/;
+const GLOBAL = /^(?:title|lang|dir|hidden|inert|translate|draggable)$/;
+function splitRootProps(props, options = {}) {
+	const root = {};
+	const rest = {};
+	for (const [key, value] of Object.entries(props)) if (key.startsWith("data-") || key.startsWith("aria-") && !LABELLING.test(key) && !(options.wrapper && (WIDGET_ARIA.test(key) || DESCRIPTION_ARIA.test(key))) || GLOBAL.test(key) || ROOT_EVENT.test(key)) root[key] = value;
+	else rest[key] = value;
+	return {
+		root,
+		rest
+	};
+}
+/**
+* The {@link WidgetAria} and {@link DescriptionAria} attributes among `props`, for the element
+* React Aria labels: a hook forwards only those it knows (a text field's `aria-controls`, but not
+* its `aria-expanded` or `aria-description`), so a wrapper component merges these with the
+* hook's own props.
+*/
+function pickWidgetAria(props) {
+	const picked = {};
+	for (const [key, value] of Object.entries(props)) if ((WIDGET_ARIA.test(key) || DESCRIPTION_ARIA.test(key)) && value !== void 0) picked[key] = value;
+	return picked;
+}
+/**
+* The {@link DescriptionAria} attributes among `props`, for a wrapper that sets every
+* {@link WidgetAria} attribute of its labelled element itself (a select's trigger, a tab list).
+*/
+function pickDescriptionAria(props) {
+	const picked = {};
+	for (const [key, value] of Object.entries(props)) if (DESCRIPTION_ARIA.test(key) && value !== void 0) picked[key] = value;
+	return picked;
+}
+/**
+* An `aria-invalid`, `aria-required` or `aria-readonly` value as a field's own boolean state, for
+* a field that sets these attributes itself and reads an app's (a form library's) as its
+* `invalid`, `required` or `readOnly`: `undefined` when left out, `false` for `false` or
+* `"false"`, and `true` for anything else (`aria-invalid="grammar"` too).
+*/
+function ariaFlag(value) {
+	if (value === void 0) return void 0;
+	return value !== false && value !== "false";
+}
+//#endregion
+export { ariaFlag, pickDescriptionAria, pickWidgetAria, splitRootProps };
+
+//# sourceMappingURL=root-props.js.map

package/dist/utils/root-props.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-props.js","names":[],"sources":["../../src/utils/root-props.ts"],"sourcesContent":["import type { AriaAttributes, DOMAttributes, HTMLAttributes } from 'react';\n\n/** The naming attributes React Aria puts on the element it labels (a field's input, a tablist). */\ntype Labelling =\n  'aria-label' | 'aria-labelledby' | 'aria-describedby' | 'aria-details' | 'aria-errormessage';\n\n/**\n * The attributes that describe a widget's own state and relations (2026-10-17): what it controls\n * and whether it opens a popup, its autocompletion and active descendant, whether it is\n * expanded, required, invalid or read-only, and a text box's `aria-multiline` and\n * `aria-placeholder`. They belong on the widget, never on a wrapper (ARIA doesn't allow them on\n * a generic `div` or a `label`).\n */\nexport type WidgetAria =\n  | 'aria-controls'\n  | 'aria-haspopup'\n  | 'aria-autocomplete'\n  | 'aria-activedescendant'\n  | 'aria-expanded'\n  | 'aria-required'\n  | 'aria-invalid'\n  | 'aria-readonly'\n  | 'aria-multiline'\n  | 'aria-placeholder';\n\n/**\n * The naming and description attributes React Aria's hooks don't forward (2026-10-24): a plain\n * text description, a role description and the braille label and role description. Like the\n * naming attributes, they belong on the element React Aria labels: ARIA prohibits\n * `aria-roledescription` and the braille attributes on a generic `div`, and a description there\n * describes nothing. A component takes them in its props, as {@link RootDOMProps} does; where\n * the root wraps the labelled element, {@link splitRootProps} keeps them in `rest` and\n * {@link pickWidgetAria} hands them over.\n */\nexport type DescriptionAria =\n  'aria-description' | 'aria-roledescription' | 'aria-braillelabel' | 'aria-brailleroledescription';\n\n/** Events about the whole component: pointer, mouse, touch, drag, wheel, scroll, animation. */\nexport type RootEvent =\n  | 'onClick'\n  | 'onAuxClick'\n  | 'onContextMenu'\n  | 'onDoubleClick'\n  | `onMouse${'Down' | 'Enter' | 'Leave' | 'Move' | 'Out' | 'Over' | 'Up'}`\n  | `onPointer${'Down' | 'Move' | 'Up' | 'Cancel' | 'Enter' | 'Leave' | 'Over' | 'Out'}`\n  | 'onGotPointerCapture'\n  | 'onLostPointerCapture'\n  | `onTouch${'Start' | 'Move' | 'End' | 'Cancel'}`\n  | `onDrag${'' | 'End' | 'Enter' | 'Exit' | 'Leave' | 'Over' | 'Start'}`\n  | 'onDrop'\n  | 'onWheel'\n  | 'onScroll'\n  | `onAnimation${'Start' | 'End' | 'Iteration'}`\n  | `onTransition${'Start' | 'Run' | 'End' | 'Cancel'}`;\n\n/** Global HTML attributes about the whole component. */\ntype Global = 'title' | 'lang' | 'dir' | 'hidden' | 'inert' | 'translate' | 'draggable';\n\n/** {@link RootEvent} and its capture form, at run time. */\nconst ROOT_EVENT =\n  /^on(?:Click|AuxClick|ContextMenu|DoubleClick|Mouse(?:Down|Enter|Leave|Move|Out|Over|Up)|Pointer(?:Down|Move|Up|Cancel|Enter|Leave|Over|Out)|(?:Got|Lost)PointerCapture|Touch(?:Start|Move|End|Cancel)|Drag(?:End|Enter|Exit|Leave|Over|Start)?|Drop|Wheel|Scroll|Animation(?:Start|End|Iteration)|Transition(?:Start|Run|End|Cancel))(?:Capture)?$/;\nconst LABELLING = /^aria-(?:label|labelledby|describedby|details|errormessage)$/;\nconst WIDGET_ARIA =\n  /^aria-(?:controls|haspopup|autocomplete|activedescendant|expanded|required|invalid|readonly|multiline|placeholder)$/;\nconst DESCRIPTION_ARIA =\n  /^aria-(?:description|roledescription|braillelabel|brailleroledescription)$/;\nconst GLOBAL = /^(?:title|lang|dir|hidden|inert|translate|draggable)$/;\n\n/**\n * The DOM attributes a component passes to its root when its other props go to a React Aria\n * hook (2026-10-17): `data-*`, `aria-*` but the naming ones, global attributes and\n * {@link RootEvent}s. The {@link DescriptionAria} attributes are among them, for a root that is\n * the labelled element; a wrapper hands them to that element instead. The naming attributes, focus, key and input events (which would fire twice\n * as they bubble from the element the hook manages) and React Aria's callbacks stay with the hook.\n */\nexport type RootDOMProps<E extends Element = HTMLDivElement> = Pick<\n  DOMAttributes<E>,\n  Extract<keyof DOMAttributes<E>, RootEvent | `${RootEvent}Capture`>\n> &\n  Omit<AriaAttributes, Labelling> &\n  Pick<HTMLAttributes<E>, Global>;\n\n/**\n * {@link RootDOMProps} for a component whose root wraps the element React Aria labels (a\n * field's input, a checkbox's input, a select's trigger, a tab list): without the\n * {@link WidgetAria} attributes, which describe that element. A component that lets the app set\n * them takes them in its own props and puts them on that element. The {@link DescriptionAria}\n * attributes stay in the type: they reach that element through {@link pickWidgetAria}.\n */\nexport type WrapperRootDOMProps<E extends Element = HTMLDivElement> = Omit<\n  RootDOMProps<E>,\n  WidgetAria\n>;\n\n/** Options for {@link splitRootProps}. */\nexport interface SplitRootPropsOptions {\n  /**\n   * The root wraps the element React Aria labels (see {@link WrapperRootDOMProps}), so the\n   * {@link WidgetAria} and {@link DescriptionAria} attributes stay in `rest`, for that element,\n   * instead of going to the root.\n   * @default false\n   */\n  wrapper?: boolean;\n}\n\n/** What {@link splitRootProps} returns. */\nexport interface SplitRootProps<Rest> {\n  /**\n   * `data-*`, `aria-*` but the naming ones (and, for a wrapper, the {@link WidgetAria} and\n   * {@link DescriptionAria} ones), global attributes and root events.\n   */\n  root: Record<string, unknown>;\n  /**\n   * Everything else, for the hook. Its type leaves out what went to `root`: for a wrapper, the\n   * widget and description attributes stay in it.\n   */\n  rest: Rest;\n}\n\n/**\n * Splits a component's {@link RootDOMProps} (and every `data-*` attribute) from the props for its\n * React Aria hook, for a component whose hook forwards only the attributes it knows. Spread\n * `root` on the root element (merging its handlers with the hook's, React Aria's `mergeProps`)\n * and pass `rest` to the hook. A component whose hook labels the root itself (a radio group, a\n * slider's group) merges both there. One whose root wraps the labelled element passes\n * `{ wrapper: true }`, so the attributes that describe that element (`aria-controls`,\n * `aria-expanded`, `aria-invalid` …, {@link WidgetAria}, and `aria-description` …,\n * {@link DescriptionAria}) stay with it; React Aria's hooks forward only some of them, so\n * {@link pickWidgetAria} hands over the rest.\n *\n * @example\n * const { root, rest } = splitRootProps(props, { wrapper: true });\n * const { labelProps, inputProps } = useTextField(rest, inputRef);\n * return (\n *   <div {...root}>\n *     <input {...mergeProps(inputProps, pickWidgetAria(rest))} />\n *   </div>\n * );\n */\nexport function splitRootProps<T extends object>(\n  props: T,\n  options: SplitRootPropsOptions & { wrapper: true },\n): SplitRootProps<Omit<T, Exclude<keyof WrapperRootDOMProps, DescriptionAria> | `data-${string}`>>;\nexport function splitRootProps<T extends object>(\n  props: T,\n  options?: SplitRootPropsOptions,\n): SplitRootProps<Omit<T, keyof RootDOMProps | `data-${string}`>>;\nexport function splitRootProps<T extends object>(\n  props: T,\n  options: SplitRootPropsOptions = {},\n): SplitRootProps<Partial<T>> {\n  const root: Record<string, unknown> = {};\n  const rest: Record<string, unknown> = {};\n  for (const [key, value] of Object.entries(props)) {\n    const toRoot =\n      key.startsWith('data-') ||\n      (key.startsWith('aria-') &&\n        !LABELLING.test(key) &&\n        !(options.wrapper && (WIDGET_ARIA.test(key) || DESCRIPTION_ARIA.test(key)))) ||\n      GLOBAL.test(key) ||\n      ROOT_EVENT.test(key);\n    if (toRoot) root[key] = value;\n    else rest[key] = value;\n  }\n  return { root, rest: rest as Partial<T> };\n}\n\n/**\n * The {@link WidgetAria} and {@link DescriptionAria} attributes among `props`, for the element\n * React Aria labels: a hook forwards only those it knows (a text field's `aria-controls`, but not\n * its `aria-expanded` or `aria-description`), so a wrapper component merges these with the\n * hook's own props.\n */\nexport function pickWidgetAria(props: object): Pick<AriaAttributes, WidgetAria | DescriptionAria> {\n  const picked: Record<string, unknown> = {};\n  for (const [key, value] of Object.entries(props)) {\n    if ((WIDGET_ARIA.test(key) || DESCRIPTION_ARIA.test(key)) && value !== undefined) {\n      picked[key] = value;\n    }\n  }\n  return picked as Pick<AriaAttributes, WidgetAria | DescriptionAria>;\n}\n\n/**\n * The {@link DescriptionAria} attributes among `props`, for a wrapper that sets every\n * {@link WidgetAria} attribute of its labelled element itself (a select's trigger, a tab list).\n */\nexport function pickDescriptionAria(props: object): Pick<AriaAttributes, DescriptionAria> {\n  const picked: Record<string, unknown> = {};\n  for (const [key, value] of Object.entries(props)) {\n    if (DESCRIPTION_ARIA.test(key) && value !== undefined) picked[key] = value;\n  }\n  return picked as Pick<AriaAttributes, DescriptionAria>;\n}\n\n/**\n * An `aria-invalid`, `aria-required` or `aria-readonly` value as a field's own boolean state, for\n * a field that sets these attributes itself and reads an app's (a form library's) as its\n * `invalid`, `required` or `readOnly`: `undefined` when left out, `false` for `false` or\n * `\"false\"`, and `true` for anything else (`aria-invalid=\"grammar\"` too).\n */\nexport function ariaFlag(value: AriaAttributes['aria-invalid']): boolean | undefined {\n  if (value === undefined) return undefined;\n  return value !== false && value !== 'false';\n}\n"],"mappings":";;AA2DA,MAAM,aACJ;AACF,MAAM,YAAY;AAClB,MAAM,cACJ;AACF,MAAM,mBACJ;AACF,MAAM,SAAS;AAiFf,SAAgB,eACd,OACA,UAAiC,CAAC,GACN;CAC5B,MAAM,OAAgC,CAAC;CACvC,MAAM,OAAgC,CAAC;CACvC,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,KAAK,GAQ7C,IANE,IAAI,WAAW,OAAO,KACrB,IAAI,WAAW,OAAO,KACrB,CAAC,UAAU,KAAK,GAAG,KACnB,EAAE,QAAQ,YAAY,YAAY,KAAK,GAAG,KAAK,iBAAiB,KAAK,GAAG,OAC1E,OAAO,KAAK,GAAG,KACf,WAAW,KAAK,GAAG,GACT,KAAK,OAAO;MACnB,KAAK,OAAO;CAEnB,OAAO;EAAE;EAAY;CAAmB;AAC1C;;;;;;;AAQA,SAAgB,eAAe,OAAmE;CAChG,MAAM,SAAkC,CAAC;CACzC,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,KAAK,GAC7C,KAAK,YAAY,KAAK,GAAG,KAAK,iBAAiB,KAAK,GAAG,MAAM,UAAU,KAAA,GACrE,OAAO,OAAO;CAGlB,OAAO;AACT;;;;;AAMA,SAAgB,oBAAoB,OAAsD;CACxF,MAAM,SAAkC,CAAC;CACzC,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,KAAK,GAC7C,IAAI,iBAAiB,KAAK,GAAG,KAAK,UAAU,KAAA,GAAW,OAAO,OAAO;CAEvE,OAAO;AACT;;;;;;;AAQA,SAAgB,SAAS,OAA4D;CACnF,IAAI,UAAU,KAAA,GAAW,OAAO,KAAA;CAChC,OAAO,UAAU,SAAS,UAAU;AACtC"}

package/dist/utils/search.d.ts

@@ -0,0 +1,11 @@
+//#region src/utils/search.d.ts
+/**
+ * Lower case without accents, so a search for "zurich" finds "Zürich" and "cote" finds
+ * "Côte d'Ivoire". `đ` (a letter of its own in Croatian, not a d with an
+ * accent) is folded to `d` too, so "dakovo" finds "Đakovo".
+ */
+export declare function normalizeSearch(text: string): string;
+/** Whether `text` contains `query`, ignoring case and accents. An empty query matches all. */
+export declare function matchesSearch(text: string, query: string): boolean;
+//#endregion
+//# sourceMappingURL=search.d.ts.map

package/dist/utils/search.js

@@ -0,0 +1,18 @@
+//#region src/utils/search.ts
+/**
+* Lower case without accents, so a search for "zurich" finds "Zürich" and "cote" finds
+* "Côte d'Ivoire". `đ` (a letter of its own in Croatian, not a d with an
+* accent) is folded to `d` too, so "dakovo" finds "Đakovo".
+*/
+function normalizeSearch(text) {
+	return text.normalize("NFD").replace(/\p{M}/gu, "").replace(/đ/gi, "d").toLowerCase().trim();
+}
+/** Whether `text` contains `query`, ignoring case and accents. An empty query matches all. */
+function matchesSearch(text, query) {
+	const search = normalizeSearch(query);
+	return search === "" || normalizeSearch(text).includes(search);
+}
+//#endregion
+export { matchesSearch, normalizeSearch };
+
+//# sourceMappingURL=search.js.map

package/dist/utils/search.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.js","names":[],"sources":["../../src/utils/search.ts"],"sourcesContent":["/**\n * Lower case without accents, so a search for \"zurich\" finds \"Zürich\" and \"cote\" finds\n * \"Côte d'Ivoire\". `đ` (a letter of its own in Croatian, not a d with an\n * accent) is folded to `d` too, so \"dakovo\" finds \"Đakovo\".\n */\nexport function normalizeSearch(text: string): string {\n  return text.normalize('NFD').replace(/\\p{M}/gu, '').replace(/đ/gi, 'd').toLowerCase().trim();\n}\n\n/** Whether `text` contains `query`, ignoring case and accents. An empty query matches all. */\nexport function matchesSearch(text: string, query: string): boolean {\n  const search = normalizeSearch(query);\n  return search === '' || normalizeSearch(text).includes(search);\n}\n"],"mappings":";;;;;;AAKA,SAAgB,gBAAgB,MAAsB;CACpD,OAAO,KAAK,UAAU,KAAK,CAAC,CAAC,QAAQ,WAAW,EAAE,CAAC,CAAC,QAAQ,OAAO,GAAG,CAAC,CAAC,YAAY,CAAC,CAAC,KAAK;AAC7F;;AAGA,SAAgB,cAAc,MAAc,OAAwB;CAClE,MAAM,SAAS,gBAAgB,KAAK;CACpC,OAAO,WAAW,MAAM,gBAAgB,IAAI,CAAC,CAAC,SAAS,MAAM;AAC/D"}

package/dist/utils/shortcut.js

@@ -0,0 +1,20 @@
+//#region src/utils/shortcut.ts
+/** A key combination such as `"Alt+G"` or `"Control+Shift+K"`, matched against an event. */
+function matchesShortcut(event, shortcut) {
+	const parts = shortcut.split("+").map((part) => part.trim().toLowerCase());
+	const key = parts.pop();
+	if (!key) return false;
+	const wants = (name) => parts.includes(name);
+	if (event.altKey !== wants("alt")) return false;
+	if (event.ctrlKey !== (wants("control") || wants("ctrl"))) return false;
+	if (event.shiftKey !== wants("shift")) return false;
+	if (event.metaKey !== (wants("meta") || wants("cmd"))) return false;
+	if (event.key.toLowerCase() === key) return true;
+	if (/^[a-z]$/.test(key)) return event.code === `Key${key.toUpperCase()}`;
+	if (/^[0-9]$/.test(key)) return event.code === `Digit${key}`;
+	return false;
+}
+//#endregion
+export { matchesShortcut };
+
+//# sourceMappingURL=shortcut.js.map

package/dist/utils/shortcut.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shortcut.js","names":[],"sources":["../../src/utils/shortcut.ts"],"sourcesContent":["/** A key combination such as `\"Alt+G\"` or `\"Control+Shift+K\"`, matched against an event. */\nexport function matchesShortcut(event: KeyboardEvent, shortcut: string): boolean {\n  const parts = shortcut.split('+').map((part) => part.trim().toLowerCase());\n  const key = parts.pop();\n  if (!key) return false;\n  const wants = (name: string) => parts.includes(name);\n  if (event.altKey !== wants('alt')) return false;\n  if (event.ctrlKey !== (wants('control') || wants('ctrl'))) return false;\n  if (event.shiftKey !== wants('shift')) return false;\n  if (event.metaKey !== (wants('meta') || wants('cmd'))) return false;\n  // Alt changes the character on some layouts (Alt+G types \"©\" on a Mac), so letters and\n  // digits match the physical key too.\n  if (event.key.toLowerCase() === key) return true;\n  if (/^[a-z]$/.test(key)) return event.code === `Key${key.toUpperCase()}`;\n  if (/^[0-9]$/.test(key)) return event.code === `Digit${key}`;\n  return false;\n}\n"],"mappings":";;AACA,SAAgB,gBAAgB,OAAsB,UAA2B;CAC/E,MAAM,QAAQ,SAAS,MAAM,GAAG,CAAC,CAAC,KAAK,SAAS,KAAK,KAAK,CAAC,CAAC,YAAY,CAAC;CACzE,MAAM,MAAM,MAAM,IAAI;CACtB,IAAI,CAAC,KAAK,OAAO;CACjB,MAAM,SAAS,SAAiB,MAAM,SAAS,IAAI;CACnD,IAAI,MAAM,WAAW,MAAM,KAAK,GAAG,OAAO;CAC1C,IAAI,MAAM,aAAa,MAAM,SAAS,KAAK,MAAM,MAAM,IAAI,OAAO;CAClE,IAAI,MAAM,aAAa,MAAM,OAAO,GAAG,OAAO;CAC9C,IAAI,MAAM,aAAa,MAAM,MAAM,KAAK,MAAM,KAAK,IAAI,OAAO;CAG9D,IAAI,MAAM,IAAI,YAAY,MAAM,KAAK,OAAO;CAC5C,IAAI,UAAU,KAAK,GAAG,GAAG,OAAO,MAAM,SAAS,MAAM,IAAI,YAAY;CACrE,IAAI,UAAU,KAAK,GAAG,GAAG,OAAO,MAAM,SAAS,QAAQ;CACvD,OAAO;AACT"}

package/dist/utils/split-data-attributes.d.ts

@@ -0,0 +1,12 @@
+//#region src/utils/split-data-attributes.d.ts
+/**
+ * Splits `data-*` attributes from the rest of a component's props. Components that
+ * pass their remaining props to a React Aria hook (which forwards only what it knows to
+ * the input) use this to put `data-*` attributes on their root, next to `className`.
+ */
+export declare function splitDataAttributes<T extends object>(props: T): {
+  data: Record<`data-${string}`, unknown>;
+  rest: Omit<T, `data-${string}`>;
+};
+//#endregion
+//# sourceMappingURL=split-data-attributes.d.ts.map

package/dist/utils/split-data-attributes.js

@@ -0,0 +1,20 @@
+//#region src/utils/split-data-attributes.ts
+/**
+* Splits `data-*` attributes from the rest of a component's props. Components that
+* pass their remaining props to a React Aria hook (which forwards only what it knows to
+* the input) use this to put `data-*` attributes on their root, next to `className`.
+*/
+function splitDataAttributes(props) {
+	const data = {};
+	const rest = {};
+	for (const [key, value] of Object.entries(props)) if (key.startsWith("data-")) data[key] = value;
+	else rest[key] = value;
+	return {
+		data,
+		rest
+	};
+}
+//#endregion
+export { splitDataAttributes };
+
+//# sourceMappingURL=split-data-attributes.js.map

package/dist/utils/split-data-attributes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-data-attributes.js","names":[],"sources":["../../src/utils/split-data-attributes.ts"],"sourcesContent":["/**\n * Splits `data-*` attributes from the rest of a component's props. Components that\n * pass their remaining props to a React Aria hook (which forwards only what it knows to\n * the input) use this to put `data-*` attributes on their root, next to `className`.\n */\nexport function splitDataAttributes<T extends object>(props: T) {\n  const data: Record<`data-${string}`, unknown> = {};\n  const rest: Record<string, unknown> = {};\n  for (const [key, value] of Object.entries(props)) {\n    if (key.startsWith('data-')) data[key as `data-${string}`] = value;\n    else rest[key] = value;\n  }\n  return { data, rest: rest as Omit<T, `data-${string}`> };\n}\n"],"mappings":";;;;;;AAKA,SAAgB,oBAAsC,OAAU;CAC9D,MAAM,OAA0C,CAAC;CACjD,MAAM,OAAgC,CAAC;CACvC,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,KAAK,GAC7C,IAAI,IAAI,WAAW,OAAO,GAAG,KAAK,OAA2B;MACxD,KAAK,OAAO;CAEnB,OAAO;EAAE;EAAY;CAAkC;AACzD"}

package/dist/utils/toolbar-keys.js

@@ -0,0 +1,28 @@
+import { hasModifier, isRtl, moveFor, target } from "./composite-keys.js";
+import { tabbables } from "./focus.js";
+//#region src/utils/toolbar-keys.ts
+/**
+* The WAI-ARIA APG toolbar keys, for a toolbar's `onKeyDownCapture`: the arrow keys along
+* its orientation move focus to the next or previous control, wrapping at the ends, and
+* Home and End move to the first and last (left and right follow the laid-out direction).
+* A text field keeps these keys for its caret. Handled keys stop here, so a group nested
+* in the toolbar doesn't move focus too. Returns whether the key was handled.
+*/
+function toolbarKeyDown(event, orientation) {
+	const root = event.currentTarget;
+	const from = event.target;
+	if (hasModifier(event) || from.matches("textarea, [contenteditable]:not([contenteditable=\"false\"]), input:not([type=\"button\"], [type=\"checkbox\"], [type=\"radio\"], [type=\"submit\"], [type=\"reset\"], [type=\"image\"], [type=\"range\"], [type=\"color\"], [type=\"file\"])")) return false;
+	const move = moveFor(event.key, orientation, isRtl(root));
+	if (move === null) return false;
+	const items = tabbables(root);
+	const current = items.findIndex((item) => item === from || item.contains(from));
+	if (current < 0) return false;
+	event.preventDefault();
+	event.stopPropagation();
+	target(items, current, move)?.focus();
+	return true;
+}
+//#endregion
+export { toolbarKeyDown };
+
+//# sourceMappingURL=toolbar-keys.js.map

package/dist/utils/toolbar-keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolbar-keys.js","names":[],"sources":["../../src/utils/toolbar-keys.ts"],"sourcesContent":["import type { KeyboardEvent } from 'react';\nimport {\n  hasModifier,\n  isRtl,\n  moveFor,\n  target,\n  TEXT_ENTRY,\n  type KeyOrientation,\n} from './composite-keys';\nimport { tabbables } from './focus';\n\n/**\n * The WAI-ARIA APG toolbar keys, for a toolbar's `onKeyDownCapture`: the arrow keys along\n * its orientation move focus to the next or previous control, wrapping at the ends, and\n * Home and End move to the first and last (left and right follow the laid-out direction).\n * A text field keeps these keys for its caret. Handled keys stop here, so a group nested\n * in the toolbar doesn't move focus too. Returns whether the key was handled.\n */\nexport function toolbarKeyDown(event: KeyboardEvent<HTMLElement>, orientation: KeyOrientation) {\n  const root = event.currentTarget;\n  const from = event.target as HTMLElement;\n  if (hasModifier(event) || from.matches(TEXT_ENTRY)) return false;\n  const move = moveFor(event.key, orientation, isRtl(root));\n  if (move === null) return false;\n  const items = tabbables(root);\n  const current = items.findIndex((item) => item === from || item.contains(from));\n  if (current < 0) return false;\n  event.preventDefault();\n  event.stopPropagation();\n  target(items, current, move)?.focus();\n  return true;\n}\n"],"mappings":";;;;;;;;;;AAkBA,SAAgB,eAAe,OAAmC,aAA6B;CAC7F,MAAM,OAAO,MAAM;CACnB,MAAM,OAAO,MAAM;CACnB,IAAI,YAAY,KAAK,KAAK,KAAK,QAAA,+OAAkB,GAAG,OAAO;CAC3D,MAAM,OAAO,QAAQ,MAAM,KAAK,aAAa,MAAM,IAAI,CAAC;CACxD,IAAI,SAAS,MAAM,OAAO;CAC1B,MAAM,QAAQ,UAAU,IAAI;CAC5B,MAAM,UAAU,MAAM,WAAW,SAAS,SAAS,QAAQ,KAAK,SAAS,IAAI,CAAC;CAC9E,IAAI,UAAU,GAAG,OAAO;CACxB,MAAM,eAAe;CACrB,MAAM,gBAAgB;CACtB,OAAO,OAAO,SAAS,IAAI,CAAC,EAAE,MAAM;CACpC,OAAO;AACT"}

package/dist/utils/tv.d.ts

@@ -0,0 +1,7 @@
+import { VariantProps } from "tailwind-variants";
+//#region src/utils/tv.d.ts
+/** tailwind-variants configured with the same merge rules as {@link cn}. */
+export declare const tv: import("tailwind-variants").TV;
+//#endregion
+export type { VariantProps };
+//# sourceMappingURL=tv.d.ts.map

package/dist/utils/tv.js

@@ -0,0 +1,9 @@
+import { twMergeConfig } from "./cn.js";
+import { createTV } from "tailwind-variants";
+//#region src/utils/tv.ts
+/** tailwind-variants configured with the same merge rules as {@link cn}. */
+const tv = createTV({ twMergeConfig });
+//#endregion
+export { tv };
+
+//# sourceMappingURL=tv.js.map

package/dist/utils/tv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tv.js","names":[],"sources":["../../src/utils/tv.ts"],"sourcesContent":["import { createTV } from 'tailwind-variants';\nimport { twMergeConfig } from './cn';\n\n/** tailwind-variants configured with the same merge rules as {@link cn}. */\nexport const tv = createTV({ twMergeConfig });\n\nexport type { VariantProps } from 'tailwind-variants';\n"],"mappings":";;;;AAIA,MAAa,KAAK,SAAS,EAAE,cAAc,CAAC"}

package/dist/utils/typeahead.js

@@ -0,0 +1,64 @@
+import { useMemo } from "react";
+import { ListKeyboardDelegate, useCollator } from "react-aria";
+//#region src/utils/typeahead.ts
+/** One character typed once or several times over ("p", "ppp"). */
+function repeatedCharacter(search) {
+	const [first, ...rest] = Array.from(search);
+	return first !== void 0 && rest.every((character) => character === first) ? first : null;
+}
+/**
+* A list keyboard delegate whose typeahead follows the M3 menu keyboard table: "Letters —
+* Focus moves to the next menu item starting with letter". React Aria's search starts *at*
+* the focused item, so pressing a letter again stayed put. A single character (or the same
+* one repeated, as WAI-ARIA's typeahead cycles) now searches from the item after the focused
+* one (or after `currentKey`, a closed `Select`'s chosen option, when nothing has focus),
+* wrapping to the top. A longer search still starts at the focused item, so typing on
+* refines the match.
+*/
+var TypeaheadKeyboardDelegate = class extends ListKeyboardDelegate {
+	currentKey;
+	constructor(options, currentKey = null) {
+		super(options);
+		this.currentKey = currentKey;
+	}
+	getKeyForSearch(search, fromKey) {
+		const character = repeatedCharacter(search);
+		if (character === null) return super.getKeyForSearch(search, fromKey ?? void 0);
+		const start = fromKey ?? this.currentKey;
+		const next = start == null ? null : this.getNextKey(start);
+		return (next == null ? null : super.getKeyForSearch(character, next)) ?? super.getKeyForSearch(character);
+	}
+};
+/**
+* The {@link TypeaheadKeyboardDelegate} for a collection, built as React Aria builds its
+* default list delegate (a base-sensitivity search collator, the state's disabled keys and
+* behaviour), for `useListBox`, `useMenu` or `useSelect`'s `keyboardDelegate`.
+* `disabledBehavior` overrides the state's (a closed `Select`'s typeahead skips disabled
+* options even when its list lets them take focus); `currentKey` is where a search starts
+* when nothing has focus.
+*/
+function useTypeaheadDelegate(state, ref, { disabledBehavior = state.selectionManager.disabledBehavior, currentKey = null } = {}) {
+	const collator = useCollator({
+		usage: "search",
+		sensitivity: "base"
+	});
+	const { collection, disabledKeys } = state;
+	return useMemo(() => new TypeaheadKeyboardDelegate({
+		collection,
+		disabledKeys,
+		disabledBehavior,
+		ref,
+		collator
+	}, currentKey), [
+		collection,
+		disabledKeys,
+		disabledBehavior,
+		ref,
+		collator,
+		currentKey
+	]);
+}
+//#endregion
+export { TypeaheadKeyboardDelegate, useTypeaheadDelegate };
+
+//# sourceMappingURL=typeahead.js.map

package/dist/utils/typeahead.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeahead.js","names":[],"sources":["../../src/utils/typeahead.ts"],"sourcesContent":["import { useMemo, type RefObject } from 'react';\nimport { ListKeyboardDelegate, useCollator } from 'react-aria';\nimport type { Collection, DisabledBehavior, Key, Node } from 'react-stately';\n\n/** One character typed once or several times over (\"p\", \"ppp\"). */\nfunction repeatedCharacter(search: string): string | null {\n  const [first, ...rest] = Array.from(search);\n  return first !== undefined && rest.every((character) => character === first) ? first : null;\n}\n\n/**\n * A list keyboard delegate whose typeahead follows the M3 menu keyboard table: \"Letters —\n * Focus moves to the next menu item starting with letter\". React Aria's search starts *at*\n * the focused item, so pressing a letter again stayed put. A single character (or the same\n * one repeated, as WAI-ARIA's typeahead cycles) now searches from the item after the focused\n * one (or after `currentKey`, a closed `Select`'s chosen option, when nothing has focus),\n * wrapping to the top. A longer search still starts at the focused item, so typing on\n * refines the match.\n */\nexport class TypeaheadKeyboardDelegate<T> extends ListKeyboardDelegate<T> {\n  private readonly currentKey: Key | null;\n\n  constructor(\n    options: ConstructorParameters<typeof ListKeyboardDelegate<T>>[0],\n    currentKey: Key | null = null,\n  ) {\n    super(options);\n    this.currentKey = currentKey;\n  }\n\n  override getKeyForSearch(search: string, fromKey?: Key | null): Key | null {\n    const character = repeatedCharacter(search);\n    if (character === null) return super.getKeyForSearch(search, fromKey ?? undefined);\n    const start = fromKey ?? this.currentKey;\n    const next = start == null ? null : this.getNextKey(start);\n    return (\n      (next == null ? null : super.getKeyForSearch(character, next)) ??\n      super.getKeyForSearch(character)\n    );\n  }\n}\n\n/** What {@link useTypeaheadDelegate} reads from a list or tree state. */\ninterface TypeaheadState<T> {\n  collection: Collection<Node<T>>;\n  disabledKeys: Set<Key>;\n  selectionManager: { disabledBehavior: DisabledBehavior };\n}\n\n/**\n * The {@link TypeaheadKeyboardDelegate} for a collection, built as React Aria builds its\n * default list delegate (a base-sensitivity search collator, the state's disabled keys and\n * behaviour), for `useListBox`, `useMenu` or `useSelect`'s `keyboardDelegate`.\n * `disabledBehavior` overrides the state's (a closed `Select`'s typeahead skips disabled\n * options even when its list lets them take focus); `currentKey` is where a search starts\n * when nothing has focus.\n */\nexport function useTypeaheadDelegate<T>(\n  state: TypeaheadState<T>,\n  ref: RefObject<HTMLElement | null>,\n  {\n    disabledBehavior = state.selectionManager.disabledBehavior,\n    currentKey = null,\n  }: { disabledBehavior?: DisabledBehavior; currentKey?: Key | null } = {},\n): TypeaheadKeyboardDelegate<T> {\n  const collator = useCollator({ usage: 'search', sensitivity: 'base' });\n  const { collection, disabledKeys } = state;\n  return useMemo(\n    () =>\n      new TypeaheadKeyboardDelegate<T>(\n        { collection, disabledKeys, disabledBehavior, ref, collator },\n        currentKey,\n      ),\n    [collection, disabledKeys, disabledBehavior, ref, collator, currentKey],\n  );\n}\n"],"mappings":";;;;AAKA,SAAS,kBAAkB,QAA+B;CACxD,MAAM,CAAC,OAAO,GAAG,QAAQ,MAAM,KAAK,MAAM;CAC1C,OAAO,UAAU,KAAA,KAAa,KAAK,OAAO,cAAc,cAAc,KAAK,IAAI,QAAQ;AACzF;;;;;;;;;;AAWA,IAAa,4BAAb,cAAkD,qBAAwB;CACxE;CAEA,YACE,SACA,aAAyB,MACzB;EACA,MAAM,OAAO;EACb,KAAK,aAAa;CACpB;CAEA,gBAAyB,QAAgB,SAAkC;EACzE,MAAM,YAAY,kBAAkB,MAAM;EAC1C,IAAI,cAAc,MAAM,OAAO,MAAM,gBAAgB,QAAQ,WAAW,KAAA,CAAS;EACjF,MAAM,QAAQ,WAAW,KAAK;EAC9B,MAAM,OAAO,SAAS,OAAO,OAAO,KAAK,WAAW,KAAK;EACzD,QACG,QAAQ,OAAO,OAAO,MAAM,gBAAgB,WAAW,IAAI,MAC5D,MAAM,gBAAgB,SAAS;CAEnC;AACF;;;;;;;;;AAiBA,SAAgB,qBACd,OACA,KACA,EACE,mBAAmB,MAAM,iBAAiB,kBAC1C,aAAa,SACuD,CAAC,GACzC;CAC9B,MAAM,WAAW,YAAY;EAAE,OAAO;EAAU,aAAa;CAAO,CAAC;CACrE,MAAM,EAAE,YAAY,iBAAiB;CACrC,OAAO,cAEH,IAAI,0BACF;EAAE;EAAY;EAAc;EAAkB;EAAK;CAAS,GAC5D,UACF,GACF;EAAC;EAAY;EAAc;EAAkB;EAAK;EAAU;CAAU,CACxE;AACF"}