@funstack/ui 0.0.0-stage → 0.1.0-alpha.0

package/dist/internal/transition-boundary.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"transition-boundary.mjs","names":[],"sources":["../../src/internal/transition-boundary.tsx"],"sourcesContent":["\"use client\";\nimport { useEffect, useRef, ViewTransition } from \"react\";\nimport type { ReactNode, ViewTransitionClass } from \"react\";\n\nconst isDev = process.env.NODE_ENV !== \"production\";\n\n/**\n * Wraps a part's output in `<ViewTransition default={transition}>` **only when the consumer\n * passed `transition`** (conventions 5.1). With `transition === undefined` the node is returned\n * unwrapped and the part renders no boundary at all.\n *\n * Reason (docs/research/view-transition-mount-cost.md, issue #35): react-dom 19.3 starts a\n * document view transition whenever a `<ViewTransition>` mounts or is revealed by `<Activity>` in\n * a transition-lane commit, whatever its class resolves to (`\"none\"` included). The browser's\n * 250 ms root cross-fade then runs and every later transition commit waits for it. Exits and\n * updates of a `\"none\"` boundary are free, so an explicit `transition=\"none\"` keeps the boundary\n * and lets a consumer switch between `\"none\"` and a class without remounting.\n *\n * The boundary stays the outermost node of the part's output, so a part that is the top of an\n * inserted subtree gets enter / exit. A plain function (not a component), so it adds no fiber\n * between the boundary and the element.\n */\nexport function transitionBoundary(\n  transition: ViewTransitionClass | undefined,\n  node: ReactNode,\n): ReactNode {\n  if (transition === undefined) return node;\n  return <ViewTransition default={transition}>{node}</ViewTransition>;\n}\n\n/**\n * {@link transitionBoundary} plus the development warning for a non-static `transition`\n * (conventions 5.1): changing it between `undefined` and a value changes the element type at the\n * part's root, so React remounts the part's subtree (DOM and state lost). Warns once per\n * instance, from an effect. `part` is the public name used in the message (`\"Tabs.Panel\"`).\n *\n * Pass the *effective* value: a part that ignores `transition` in some mode (Accordion, Dialog\n * JS-free mode) passes `undefined` there.\n */\nexport function useTransitionBoundary(\n  part: string,\n  transition: ViewTransitionClass | undefined,\n  node: ReactNode,\n): ReactNode {\n  const hasBoundary = transition !== undefined;\n  const initial = useRef(hasBoundary);\n  const warned = useRef(false);\n  useEffect(() => {\n    if (!isDev || warned.current || hasBoundary === initial.current) return;\n    warned.current = true;\n    console.error(\n      `${part}: \\`transition\\` changed between undefined and a value after mount. The part ` +\n        \"renders a <ViewTransition> only when `transition` is given, so this remounts its \" +\n        'subtree (DOM and state are lost). Keep `transition` static; use `transition=\"none\"` ' +\n        \"to switch animation off without removing the boundary.\",\n    );\n  }, [hasBoundary, part]);\n  return transitionBoundary(transition, node);\n}\n"],"mappings":";;;;AAIA,MAAM,QAAQ,QAAQ,IAAI,aAAa;;;;;;;;;;;;;;;;;AAkBvC,SAAgB,mBACd,YACA,MACW;CACX,IAAI,eAAe,KAAA,GAAW,OAAO;CACrC,OAAO,oBAAC,gBAAD;EAAgB,SAAS;EAAa,UAAA;CAAqB,CAAA;AACpE;;;;;;;;;;AAWA,SAAgB,sBACd,MACA,YACA,MACW;CACX,MAAM,cAAc,eAAe,KAAA;CACnC,MAAM,UAAU,OAAO,WAAW;CAClC,MAAM,SAAS,OAAO,KAAK;CAC3B,gBAAgB;EACd,IAAI,CAAC,SAAS,OAAO,WAAW,gBAAgB,QAAQ,SAAS;EACjE,OAAO,UAAU;EACjB,QAAQ,MACN,GAAG,KAAK,+SAIV;CACF,GAAG,CAAC,aAAa,IAAI,CAAC;CACtB,OAAO,mBAAmB,YAAY,IAAI;AAC5C"}

package/dist/internal/transition-types.mjs

@@ -0,0 +1,15 @@
+//#region src/internal/transition-types.ts
+/**
+* Builds the library's View Transition type names for one dispatch (conventions 5.3):
+* `fsui-<component>` plus, when the change has a kind, `fsui-<component>-<change>`.
+*
+* Hyphens only: the names are also matched by `:active-view-transition-type(...)` in CSS.
+*/
+function transitionTypes(component, change) {
+	const base = `fsui-${component}`;
+	return change ? [base, `${base}-${change}`] : [base];
+}
+//#endregion
+export { transitionTypes };
+
+//# sourceMappingURL=transition-types.mjs.map

package/dist/internal/transition-types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"transition-types.mjs","names":[],"sources":["../../src/internal/transition-types.ts"],"sourcesContent":["/**\n * Builds the library's View Transition type names for one dispatch (conventions 5.3):\n * `fsui-<component>` plus, when the change has a kind, `fsui-<component>-<change>`.\n *\n * Hyphens only: the names are also matched by `:active-view-transition-type(...)` in CSS.\n */\nexport function transitionTypes(\n  component: string,\n  change?: string | null | undefined,\n): readonly string[] {\n  const base = `fsui-${component}`;\n  return change ? [base, `${base}-${change}`] : [base];\n}\n"],"mappings":";;;;;;;AAMA,SAAgB,gBACd,WACA,QACmB;CACnB,MAAM,OAAO,QAAQ;CACrB,OAAO,SAAS,CAAC,MAAM,GAAG,KAAK,GAAG,QAAQ,IAAI,CAAC,IAAI;AACrD"}

package/dist/internal/types.d.mts

@@ -0,0 +1,38 @@
+import { ReactElement, ReactNode } from "react";
+//#region src/internal/types.d.ts
+/**
+ * A callback the library runs inside a Transition. May be sync or async: the library awaits
+ * whatever it returns (a thenable is awaited, anything else is ignored). The return type is
+ * `unknown` rather than `void | Promise<void>` so that `(next) => save(next)` compiles when `save`
+ * returns data, as Server Functions usually do (conventions 2.2).
+ */
+export type Action<Args extends readonly unknown[] = []> = (...args: Args) => unknown;
+export interface ActionDetails {
+  /** The DOM event that caused the action, or `undefined` for programmatic changes. */
+  readonly event: Event | undefined;
+}
+/** An action called with the next value of a controllable state. */
+export type ChangeAction<T, Details extends ActionDetails = ActionDetails> = Action<[next: T, details: Details]>;
+/**
+ * Why a change action was dispatched (conventions 2.2). One library-wide vocabulary: every
+ * `<Component><State>ChangeDetails` that exposes `reason` declares it with this type.
+ *
+ * - `"activate"`: the user acted on a trigger part (click, Enter/Space, label click, focus in an
+ *   automatic-activation mode). `details.event` is the native event.
+ * - `"dismiss"`: the user closed the component without acting on one of its parts: Escape,
+ *   Android back, an assistive-technology dismiss gesture, or a click outside (light dismiss).
+ *   `details.event` is the platform's `close` event. Dialog is the first component to use it.
+ * - `"platform"`: the browser changed the state itself: find-in-page, a form reset (`event` is
+ *   the `reset` event), or interaction before hydration found at mount (`event` is `undefined`).
+ */
+export type ChangeReason = "activate" | "dismiss" | "platform";
+/** A prop value that is either a plain value or a function of the part's state. */
+export type StateValue<T, State> = T | ((state: State) => T);
+/**
+ * Element polymorphism. Element form replaces the default element and the library merges its
+ * props into it; function form receives the merged props and the part's state and renders
+ * whatever it likes (it must spread `props` onto a DOM element).
+ */
+export type RenderProp<Props, State> = ReactElement<Partial<Props>> | ((props: Props, state: State) => ReactNode);
+//#endregion
+//# sourceMappingURL=types.d.mts.map

package/dist/internal/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/internal/types.ts"],"mappings":";;;;;;;;YAQY,OAAO,4CAA4C,MAAM;iBAEpD;;WAEN,OAAO;;;YAIN,aAAa,GAAG,gBAAgB,gBAAgB,iBAAiB,QAC1E,MAAM,GAAG,SAAS;;;;;;;;;;;;;YAeT;;YAGA,WAAW,GAAG,SAAS,MAAM,OAAO,UAAU;;;;;;YAO9C,WAAW,OAAO,SAC1B,aAAa,QAAQ,YACnB,OAAO,OAAO,OAAO,UAAU"}

package/dist/internal/use-controllable-action.mjs

@@ -0,0 +1,115 @@
+"use client";
+import { addTransitionType, startTransition, useEffect, useOptimistic, useRef, useState, useTransition } from "react";
+//#region src/internal/use-controllable-action.ts
+const isDev = process.env.NODE_ENV !== "production";
+function capitalize(s) {
+	return s.charAt(0).toUpperCase() + s.slice(1);
+}
+/** Reports an error that cannot reach a boundary (conventions 2.4: never swallow). */
+function report(error) {
+	if (typeof reportError === "function") reportError(error);
+	else console.error(error);
+}
+/**
+* The one place the state model of conventions section 3 is implemented: committed state,
+* optimistic state (`useOptimistic`, reducer form), the component's own transition, the
+* post-`await` write of uncontrolled state, the latest-dispatch guard, and the surfacing of
+* superseded rejections (conventions 2.4).
+*/
+function useControllableAction(options) {
+	const { controlled, defaultValue, initialValue, action, transitionTypes, reducer, warn } = options;
+	const [supersededError, setSupersededError] = useState(null);
+	const hasSupersededError = useRef(false);
+	if (supersededError !== null) throw supersededError.error;
+	const [internal, setInternal] = useState(defaultValue === void 0 ? initialValue : defaultValue);
+	const isControlled = controlled !== void 0;
+	const committed = isControlled ? controlled : internal;
+	const [optimistic, setOptimistic] = useOptimistic(committed, (prev, patch) => reducer ? reducer(prev, patch.next, patch.details) : patch.next);
+	const [pending, startOwnTransition] = useTransition();
+	const latest = useRef(0);
+	const inFlight = useRef({
+		count: 0,
+		next: void 0
+	});
+	const mounted = useRef(false);
+	useDevWarnings(isControlled, defaultValue !== void 0, warn);
+	useEffect(() => {
+		mounted.current = true;
+		return () => {
+			mounted.current = false;
+		};
+	}, []);
+	function dispatch(next, details) {
+		const prev = committed;
+		const id = ++latest.current;
+		inFlight.current.count += 1;
+		inFlight.current.next = next;
+		startOwnTransition(async () => {
+			for (const type of transitionTypes?.(next, prev, details) ?? []) addTransitionType(type);
+			setOptimistic({
+				next,
+				details
+			});
+			try {
+				await action?.(next, details);
+			} catch (error) {
+				settle();
+				if (id === latest.current) throw error;
+				if (!mounted.current) return;
+				if (hasSupersededError.current) {
+					report(error);
+					return;
+				}
+				hasSupersededError.current = true;
+				setSupersededError({ error });
+				return;
+			}
+			settle();
+			if (!isControlled && id === latest.current) startTransition(() => setInternal(next));
+		});
+	}
+	function settle() {
+		inFlight.current.count -= 1;
+		if (inFlight.current.count === 0) inFlight.current.next = void 0;
+	}
+	function latestInFlight() {
+		const { count, next } = inFlight.current;
+		return count > 0 ? { next } : null;
+	}
+	return {
+		committed,
+		optimistic,
+		pending,
+		dispatch,
+		latestInFlight
+	};
+}
+function useDevWarnings(isControlled, hasDefault, warn) {
+	const initialMode = useRef(isControlled);
+	const warnedBoth = useRef(false);
+	const warnedSwitch = useRef(false);
+	const component = warn?.component ?? "A component";
+	const prop = warn?.prop ?? "value";
+	useEffect(() => {
+		if (!isDev) return;
+		const defaultProp = `default${capitalize(prop)}`;
+		if (isControlled && hasDefault && !warnedBoth.current) {
+			warnedBoth.current = true;
+			console.error(`${component}: both \`${prop}\` and \`${defaultProp}\` are set. Use \`${prop}\` for controlled mode or \`${defaultProp}\` for uncontrolled mode, not both.`);
+		}
+		if (initialMode.current !== isControlled && !warnedSwitch.current) {
+			warnedSwitch.current = true;
+			const from = initialMode.current ? "controlled" : "uncontrolled";
+			console.error(`${component}: \`${prop}\` changed from ${from} to ${isControlled ? "controlled" : "uncontrolled"}. Switching modes after mount is not supported; keep \`${prop}\` either always defined or always undefined.`);
+		}
+	}, [
+		component,
+		prop,
+		isControlled,
+		hasDefault
+	]);
+}
+//#endregion
+export { useControllableAction };
+
+//# sourceMappingURL=use-controllable-action.mjs.map

package/dist/internal/use-controllable-action.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-controllable-action.mjs","names":[],"sources":["../../src/internal/use-controllable-action.ts"],"sourcesContent":["\"use client\";\nimport {\n  addTransitionType,\n  startTransition,\n  useEffect,\n  useOptimistic,\n  useRef,\n  useState,\n  useTransition,\n} from \"react\";\nimport type { ActionDetails, ChangeAction } from \"./types.js\";\n\nexport interface UseControllableActionOptions<T, Details extends ActionDetails> {\n  /** The controlled prop (`x`). `undefined` means uncontrolled. */\n  controlled: T | undefined;\n  /** The `defaultX` prop as the consumer passed it; `undefined` when omitted. */\n  defaultValue: T | undefined;\n  /** Initial uncontrolled value when neither `x` nor `defaultX` is given. */\n  initialValue: T;\n  /** The `xChangeAction` prop. Awaited inside this hook's transition. */\n  action: ChangeAction<T, Details> | undefined;\n  /**\n   * View Transition types to attach to the commit that ends a dispatch. Receives the previous\n   * committed value and the details object (Tabs derives next/prev direction from them).\n   */\n  transitionTypes?: (next: T, prev: T, details: Details) => readonly string[];\n  /**\n   * Optimistic reducer (conventions 3.4). Default: replace the value with `next`. Multi-item\n   * states (Accordion's open set) pass a reducer keyed by item, reading the item from `details`,\n   * so stacked optimistic patches re-base onto a changed committed value.\n   */\n  reducer?: (prev: T, next: T, details: Details) => T;\n  /** Names used in development warnings. */\n  warn?: { readonly component: string; readonly prop: string };\n}\n\nexport interface ControllableAction<T, Details extends ActionDetails> {\n  /** Committed value (`x ?? internal`). Content regions render this. */\n  readonly committed: T;\n  /** Optimistic value; trigger parts render this. */\n  readonly optimistic: T;\n  /** An action dispatched through this hook is in flight. */\n  readonly pending: boolean;\n  /** Runs the action inside the hook's transition with optimistic feedback. */\n  readonly dispatch: (next: T, details: Details) => void;\n  /**\n   * The `next` of the most recent dispatch while any dispatch's action is still unsettled, else\n   * `null`. Lets a component with a browser-owned path (Accordion's find-in-page reveal) build on\n   * what the user already intends instead of on the DOM. Read it from handlers and effects only.\n   */\n  readonly latestInFlight: () => { readonly next: T } | null;\n}\n\nconst isDev = process.env.NODE_ENV !== \"production\";\n\nfunction capitalize(s: string): string {\n  return s.charAt(0).toUpperCase() + s.slice(1);\n}\n\n/** Reports an error that cannot reach a boundary (conventions 2.4: never swallow). */\nfunction report(error: unknown): void {\n  if (typeof reportError === \"function\") reportError(error);\n  else console.error(error);\n}\n\n/**\n * The one place the state model of conventions section 3 is implemented: committed state,\n * optimistic state (`useOptimistic`, reducer form), the component's own transition, the\n * post-`await` write of uncontrolled state, the latest-dispatch guard, and the surfacing of\n * superseded rejections (conventions 2.4).\n */\nexport function useControllableAction<T, Details extends ActionDetails = ActionDetails>(\n  options: UseControllableActionOptions<T, Details>,\n): ControllableAction<T, Details> {\n  const { controlled, defaultValue, initialValue, action, transitionTypes, reducer, warn } =\n    options;\n\n  // React keeps only the newest thenable per `useTransition`, so a rejection from a dispatch that\n  // was superseded by a later one would be dropped entirely (no boundary, no `reportError`). The\n  // hook catches those itself, keeps the first, and throws it from render so it reaches the same\n  // nearest Error Boundary as the latest dispatch's rejection does through React.\n  //\n  // The throw sits before `useTransition` on purpose: React retries an errored render with every\n  // pending lane, and in that retry `useTransition` unwraps the still-pending action thenable and\n  // suspends, which would hold the boundary commit until the newer action settles.\n  const [supersededError, setSupersededError] = useState<{ readonly error: unknown } | null>(null);\n  const hasSupersededError = useRef(false);\n  if (supersededError !== null) throw supersededError.error;\n\n  const [internal, setInternal] = useState<T>(\n    defaultValue === undefined ? initialValue : defaultValue,\n  );\n  const isControlled = controlled !== undefined;\n  const committed = isControlled ? controlled : internal;\n  const [optimistic, setOptimistic] = useOptimistic(\n    committed,\n    (prev: T, patch: { next: T; details: Details }) =>\n      reducer ? reducer(prev, patch.next, patch.details) : patch.next,\n  );\n  const [pending, startOwnTransition] = useTransition();\n  const latest = useRef(0);\n  const inFlight = useRef<{ count: number; next: T | undefined }>({ count: 0, next: undefined });\n  const mounted = useRef(false);\n\n  useDevWarnings(isControlled, defaultValue !== undefined, warn);\n\n  useEffect(() => {\n    mounted.current = true;\n    return () => {\n      mounted.current = false;\n    };\n  }, []);\n\n  function dispatch(next: T, details: Details): void {\n    const prev = committed;\n    const id = ++latest.current;\n    inFlight.current.count += 1;\n    inFlight.current.next = next;\n    startOwnTransition(async () => {\n      for (const type of transitionTypes?.(next, prev, details) ?? []) addTransitionType(type);\n      setOptimistic({ next, details });\n      try {\n        await action?.(next, details);\n      } catch (error) {\n        settle();\n        // The latest dispatch's rejection takes React's own route to the boundary.\n        if (id === latest.current) throw error;\n        // Nothing to throw to once unmounted (React drops its own thenables the same way).\n        if (!mounted.current) return;\n        if (hasSupersededError.current) {\n          // One boundary reset per burst is enough; later errors are still reported.\n          report(error);\n          return;\n        }\n        hasSupersededError.current = true;\n        // Outside the transition by now (after an await), so this is an urgent update: the owner\n        // re-renders promptly and throws.\n        setSupersededError({ error });\n        return;\n      }\n      settle();\n      if (!isControlled && id === latest.current) {\n        startTransition(() => setInternal(next));\n      }\n    });\n  }\n\n  function settle(): void {\n    inFlight.current.count -= 1;\n    if (inFlight.current.count === 0) inFlight.current.next = undefined;\n  }\n\n  function latestInFlight(): { readonly next: T } | null {\n    const { count, next } = inFlight.current;\n    return count > 0 ? { next: next as T } : null;\n  }\n\n  return { committed, optimistic, pending, dispatch, latestInFlight };\n}\n\nfunction useDevWarnings(\n  isControlled: boolean,\n  hasDefault: boolean,\n  warn: { readonly component: string; readonly prop: string } | undefined,\n): void {\n  const initialMode = useRef(isControlled);\n  const warnedBoth = useRef(false);\n  const warnedSwitch = useRef(false);\n  const component = warn?.component ?? \"A component\";\n  const prop = warn?.prop ?? \"value\";\n\n  useEffect(() => {\n    if (!isDev) return;\n    const defaultProp = `default${capitalize(prop)}`;\n\n    if (isControlled && hasDefault && !warnedBoth.current) {\n      warnedBoth.current = true;\n      console.error(\n        `${component}: both \\`${prop}\\` and \\`${defaultProp}\\` are set. ` +\n          `Use \\`${prop}\\` for controlled mode or \\`${defaultProp}\\` for uncontrolled mode, not both.`,\n      );\n    }\n\n    if (initialMode.current !== isControlled && !warnedSwitch.current) {\n      warnedSwitch.current = true;\n      const from = initialMode.current ? \"controlled\" : \"uncontrolled\";\n      const to = isControlled ? \"controlled\" : \"uncontrolled\";\n      console.error(\n        `${component}: \\`${prop}\\` changed from ${from} to ${to}. Switching modes after mount ` +\n          `is not supported; keep \\`${prop}\\` either always defined or always undefined.`,\n      );\n    }\n  }, [component, prop, isControlled, hasDefault]);\n}\n"],"mappings":";;;AAqDA,MAAM,QAAQ,QAAQ,IAAI,aAAa;AAEvC,SAAS,WAAW,GAAmB;CACrC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,YAAY,IAAI,EAAE,MAAM,CAAC;AAC9C;;AAGA,SAAS,OAAO,OAAsB;CACpC,IAAI,OAAO,gBAAgB,YAAY,YAAY,KAAK;MACnD,QAAQ,MAAM,KAAK;AAC1B;;;;;;;AAQA,SAAgB,sBACd,SACgC;CAChC,MAAM,EAAE,YAAY,cAAc,cAAc,QAAQ,iBAAiB,SAAS,SAChF;CAUF,MAAM,CAAC,iBAAiB,sBAAsB,SAA6C,IAAI;CAC/F,MAAM,qBAAqB,OAAO,KAAK;CACvC,IAAI,oBAAoB,MAAM,MAAM,gBAAgB;CAEpD,MAAM,CAAC,UAAU,eAAe,SAC9B,iBAAiB,KAAA,IAAY,eAAe,YAC9C;CACA,MAAM,eAAe,eAAe,KAAA;CACpC,MAAM,YAAY,eAAe,aAAa;CAC9C,MAAM,CAAC,YAAY,iBAAiB,cAClC,YACC,MAAS,UACR,UAAU,QAAQ,MAAM,MAAM,MAAM,MAAM,OAAO,IAAI,MAAM,IAC/D;CACA,MAAM,CAAC,SAAS,sBAAsB,cAAc;CACpD,MAAM,SAAS,OAAO,CAAC;CACvB,MAAM,WAAW,OAA+C;EAAE,OAAO;EAAG,MAAM,KAAA;CAAU,CAAC;CAC7F,MAAM,UAAU,OAAO,KAAK;CAE5B,eAAe,cAAc,iBAAiB,KAAA,GAAW,IAAI;CAE7D,gBAAgB;EACd,QAAQ,UAAU;EAClB,aAAa;GACX,QAAQ,UAAU;EACpB;CACF,GAAG,CAAC,CAAC;CAEL,SAAS,SAAS,MAAS,SAAwB;EACjD,MAAM,OAAO;EACb,MAAM,KAAK,EAAE,OAAO;EACpB,SAAS,QAAQ,SAAS;EAC1B,SAAS,QAAQ,OAAO;EACxB,mBAAmB,YAAY;GAC7B,KAAK,MAAM,QAAQ,kBAAkB,MAAM,MAAM,OAAO,KAAK,CAAC,GAAG,kBAAkB,IAAI;GACvF,cAAc;IAAE;IAAM;GAAQ,CAAC;GAC/B,IAAI;IACF,MAAM,SAAS,MAAM,OAAO;GAC9B,SAAS,OAAO;IACd,OAAO;IAEP,IAAI,OAAO,OAAO,SAAS,MAAM;IAEjC,IAAI,CAAC,QAAQ,SAAS;IACtB,IAAI,mBAAmB,SAAS;KAE9B,OAAO,KAAK;KACZ;IACF;IACA,mBAAmB,UAAU;IAG7B,mBAAmB,EAAE,MAAM,CAAC;IAC5B;GACF;GACA,OAAO;GACP,IAAI,CAAC,gBAAgB,OAAO,OAAO,SACjC,sBAAsB,YAAY,IAAI,CAAC;EAE3C,CAAC;CACH;CAEA,SAAS,SAAe;EACtB,SAAS,QAAQ,SAAS;EAC1B,IAAI,SAAS,QAAQ,UAAU,GAAG,SAAS,QAAQ,OAAO,KAAA;CAC5D;CAEA,SAAS,iBAA8C;EACrD,MAAM,EAAE,OAAO,SAAS,SAAS;EACjC,OAAO,QAAQ,IAAI,EAAQ,KAAU,IAAI;CAC3C;CAEA,OAAO;EAAE;EAAW;EAAY;EAAS;EAAU;CAAe;AACpE;AAEA,SAAS,eACP,cACA,YACA,MACM;CACN,MAAM,cAAc,OAAO,YAAY;CACvC,MAAM,aAAa,OAAO,KAAK;CAC/B,MAAM,eAAe,OAAO,KAAK;CACjC,MAAM,YAAY,MAAM,aAAa;CACrC,MAAM,OAAO,MAAM,QAAQ;CAE3B,gBAAgB;EACd,IAAI,CAAC,OAAO;EACZ,MAAM,cAAc,UAAU,WAAW,IAAI;EAE7C,IAAI,gBAAgB,cAAc,CAAC,WAAW,SAAS;GACrD,WAAW,UAAU;GACrB,QAAQ,MACN,GAAG,UAAU,WAAW,KAAK,WAAW,YAAY,oBACzC,KAAK,8BAA8B,YAAY,oCAC5D;EACF;EAEA,IAAI,YAAY,YAAY,gBAAgB,CAAC,aAAa,SAAS;GACjE,aAAa,UAAU;GACvB,MAAM,OAAO,YAAY,UAAU,eAAe;GAElD,QAAQ,MACN,GAAG,UAAU,MAAM,KAAK,kBAAkB,KAAK,MAFtC,eAAe,eAAe,eAEiB,yDAC1B,KAAK,8CACrC;EACF;CACF,GAAG;EAAC;EAAW;EAAM;EAAc;CAAU,CAAC;AAChD"}

package/dist/internal/use-dev-warning.mjs

@@ -0,0 +1,21 @@
+"use client";
+import { useEffect, useRef } from "react";
+//#region src/internal/use-dev-warning.ts
+const isDev = process.env.NODE_ENV !== "production";
+/**
+* Logs `message` through `console.error` once per component instance, the first time
+* `condition` is true. Runs in an effect (never during render) so the warning cannot fire for a
+* render that is discarded.
+*/
+function useDevWarning(condition, message) {
+	const warned = useRef(false);
+	useEffect(() => {
+		if (!isDev || !condition || warned.current) return;
+		warned.current = true;
+		console.error(message);
+	}, [condition, message]);
+}
+//#endregion
+export { useDevWarning };
+
+//# sourceMappingURL=use-dev-warning.mjs.map

package/dist/internal/use-dev-warning.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-dev-warning.mjs","names":[],"sources":["../../src/internal/use-dev-warning.ts"],"sourcesContent":["\"use client\";\nimport { useEffect, useRef } from \"react\";\n\nconst isDev = process.env.NODE_ENV !== \"production\";\n\n/**\n * Logs `message` through `console.error` once per component instance, the first time\n * `condition` is true. Runs in an effect (never during render) so the warning cannot fire for a\n * render that is discarded.\n */\nexport function useDevWarning(condition: boolean, message: string): void {\n  const warned = useRef(false);\n  useEffect(() => {\n    if (!isDev || !condition || warned.current) return;\n    warned.current = true;\n    console.error(message);\n  }, [condition, message]);\n}\n"],"mappings":";;;AAGA,MAAM,QAAQ,QAAQ,IAAI,aAAa;;;;;;AAOvC,SAAgB,cAAc,WAAoB,SAAuB;CACvE,MAAM,SAAS,OAAO,KAAK;CAC3B,gBAAgB;EACd,IAAI,CAAC,SAAS,CAAC,aAAa,OAAO,SAAS;EAC5C,OAAO,UAAU;EACjB,QAAQ,MAAM,OAAO;CACvB,GAAG,CAAC,WAAW,OAAO,CAAC;AACzB"}

package/dist/internal/use-form-reset.mjs

@@ -0,0 +1,50 @@
+"use client";
+import { useEffectEvent, useLayoutEffect, useRef } from "react";
+//#region src/internal/use-form-reset.ts
+/**
+* Stable `reset` subscription on the form owner of `ref.current` (conventions 3.8).
+*
+* - The owner (`element.form`, which honours the `form` attribute) is re-read after every commit,
+*   but the listener is moved only when the owner changed. It is never removed and re-added on an
+*   ordinary re-render: React's automatic reset after a successful `<form action>` runs in the
+*   commit's mutation phase, between an effect's cleanup and its next run, so a subscription that
+*   followed every commit would miss it (rule 4).
+* - The `reset` event fires before the reset algorithm, so `onReset` is called in a microtask,
+*   when the inputs hold their reset values (rule 5), and only if no listener cancelled the reset
+*   (rule 7).
+* - `onReset` always sees the latest committed render's values (`useEffectEvent`).
+*/
+function useFormReset(ref, onReset) {
+	const handleReset = useEffectEvent((event) => {
+		onReset(event);
+	});
+	const subscription = useRef(null);
+	useLayoutEffect(() => {
+		const form = ref.current?.form ?? null;
+		const current = subscription.current;
+		if (current !== null && current.form === form) return;
+		if (current !== null) current.form.removeEventListener("reset", current.listener);
+		subscription.current = null;
+		if (form === null) return;
+		const listener = (event) => {
+			queueMicrotask(() => {
+				if (event.defaultPrevented) return;
+				handleReset(event);
+			});
+		};
+		form.addEventListener("reset", listener);
+		subscription.current = {
+			form,
+			listener
+		};
+	});
+	useLayoutEffect(() => () => {
+		const current = subscription.current;
+		if (current !== null) current.form.removeEventListener("reset", current.listener);
+		subscription.current = null;
+	}, []);
+}
+//#endregion
+export { useFormReset };
+
+//# sourceMappingURL=use-form-reset.mjs.map

package/dist/internal/use-form-reset.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-form-reset.mjs","names":[],"sources":["../../src/internal/use-form-reset.ts"],"sourcesContent":["\"use client\";\nimport { useEffectEvent, useLayoutEffect, useRef } from \"react\";\nimport type { RefObject } from \"react\";\n\n/** A form-associated element whose form owner the hook follows. */\nexport type FormAssociatedElement = HTMLInputElement | HTMLFieldSetElement;\n\ninterface Subscription {\n  readonly form: HTMLFormElement;\n  readonly listener: (event: Event) => void;\n}\n\n/**\n * Stable `reset` subscription on the form owner of `ref.current` (conventions 3.8).\n *\n * - The owner (`element.form`, which honours the `form` attribute) is re-read after every commit,\n *   but the listener is moved only when the owner changed. It is never removed and re-added on an\n *   ordinary re-render: React's automatic reset after a successful `<form action>` runs in the\n *   commit's mutation phase, between an effect's cleanup and its next run, so a subscription that\n *   followed every commit would miss it (rule 4).\n * - The `reset` event fires before the reset algorithm, so `onReset` is called in a microtask,\n *   when the inputs hold their reset values (rule 5), and only if no listener cancelled the reset\n *   (rule 7).\n * - `onReset` always sees the latest committed render's values (`useEffectEvent`).\n */\nexport function useFormReset(\n  ref: RefObject<FormAssociatedElement | null>,\n  onReset: (event: Event) => void,\n): void {\n  const handleReset = useEffectEvent((event: Event) => {\n    onReset(event);\n  });\n  const subscription = useRef<Subscription | null>(null);\n\n  // No deps on purpose: follows the form owner after every commit (a changed `form` attribute, the\n  // element moved to another form), but re-subscribes only when the owner actually changed.\n  useLayoutEffect(() => {\n    const form = ref.current?.form ?? null;\n    const current = subscription.current;\n    if (current !== null && current.form === form) return;\n    if (current !== null) current.form.removeEventListener(\"reset\", current.listener);\n    subscription.current = null;\n    if (form === null) return;\n    const listener = (event: Event) => {\n      queueMicrotask(() => {\n        if (event.defaultPrevented) return;\n        handleReset(event);\n      });\n    };\n    form.addEventListener(\"reset\", listener);\n    subscription.current = { form, listener };\n  });\n\n  // The only place the subscription is torn down: unmount (and StrictMode's simulated unmount,\n  // after which the effect above subscribes again).\n  useLayoutEffect(\n    () => () => {\n      const current = subscription.current;\n      if (current !== null) current.form.removeEventListener(\"reset\", current.listener);\n      subscription.current = null;\n    },\n    [],\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAyBA,SAAgB,aACd,KACA,SACM;CACN,MAAM,cAAc,gBAAgB,UAAiB;EACnD,QAAQ,KAAK;CACf,CAAC;CACD,MAAM,eAAe,OAA4B,IAAI;CAIrD,sBAAsB;EACpB,MAAM,OAAO,IAAI,SAAS,QAAQ;EAClC,MAAM,UAAU,aAAa;EAC7B,IAAI,YAAY,QAAQ,QAAQ,SAAS,MAAM;EAC/C,IAAI,YAAY,MAAM,QAAQ,KAAK,oBAAoB,SAAS,QAAQ,QAAQ;EAChF,aAAa,UAAU;EACvB,IAAI,SAAS,MAAM;EACnB,MAAM,YAAY,UAAiB;GACjC,qBAAqB;IACnB,IAAI,MAAM,kBAAkB;IAC5B,YAAY,KAAK;GACnB,CAAC;EACH;EACA,KAAK,iBAAiB,SAAS,QAAQ;EACvC,aAAa,UAAU;GAAE;GAAM;EAAS;CAC1C,CAAC;CAID,4BACc;EACV,MAAM,UAAU,aAAa;EAC7B,IAAI,YAAY,MAAM,QAAQ,KAAK,oBAAoB,SAAS,QAAQ,QAAQ;EAChF,aAAa,UAAU;CACzB,GACA,CAAC,CACH;AACF"}

package/dist/internal/use-native-checked.mjs

@@ -0,0 +1,113 @@
+"use client";
+import { useFormReset } from "./use-form-reset.mjs";
+import { useCallback, useEffectEvent, useLayoutEffect, useRef } from "react";
+//#region src/internal/use-native-checked.ts
+const isDev = process.env.NODE_ENV !== "production";
+/**
+* Per-element machinery for a controlled native `<input type="checkbox" | "radio">`
+* (conventions 3.8): returns the ref to attach to the input (merged by `useRender`).
+*
+* 1. Ref callback: stores the node; in development warns once when it is not an `<input>` of
+*    the expected `type`.
+* 2. Mount reconciliation (single controls): a click before hydration or Firefox's form-state
+*    restoration left the DOM different from what the user intends; reported once with
+*    `event: undefined`.
+* 3. Re-apply after every commit: `checked` (optimistic, or the latest in-flight value),
+*    `indeterminate` and `defaultChecked`, none of which React manages for a controlled input
+*    except `checked`.
+* 4. Form reset (single controls): in a microtask after the reset, compares `el.defaultChecked`
+*    with what the user intends and reports a difference with the `reset` event.
+*
+* The hook knows nothing about transitions or `reason`; the part wires `onPlatformChange`.
+*/
+function useNativeChecked(options) {
+	const { type, component, checked, defaultChecked, indeterminate, group = false } = options;
+	const node = useRef(null);
+	const warnedElement = useRef(false);
+	const ref = useCallback((el) => {
+		node.current = el;
+		if (isDev && !warnedElement.current && !isInputOfType(el, type)) {
+			warnedElement.current = true;
+			console.error(`${component}: expected to render an \`<input type="${type}">\` but got ${describeElement(el)}; the platform semantics (form participation, labels, keyboard, reset) need a real input. A \`render\` element must keep the input.`);
+		}
+		return () => {
+			node.current = null;
+		};
+	}, [type, component]);
+	/** What the user intends: the latest in-flight dispatch, else the optimistic value (rule 1). */
+	const readBase = useEffectEvent(() => options.latestInFlight?.()?.next ?? checked);
+	const report = useEffectEvent((next, event) => {
+		options.onPlatformChange?.(next, event);
+	});
+	const reconcileMount = useEffectEvent(() => {
+		if (group) return;
+		const el = node.current;
+		if (el === null) return;
+		if (el.checked !== readBase()) report(el.checked, void 0);
+	});
+	useLayoutEffect(() => {
+		reconcileMount();
+	}, []);
+	const notifyMounted = useEffectEvent(() => {
+		if (group) options.onItemMounted?.(node.current);
+	});
+	useLayoutEffect(() => {
+		notifyMounted();
+	}, []);
+	const renderToken = {};
+	const mountToken = useRef(null);
+	useLayoutEffect(() => {
+		if (mountToken.current === null) mountToken.current = renderToken;
+		const el = node.current;
+		if (el === null) return;
+		if (defaultChecked !== void 0 && el.defaultChecked !== defaultChecked) el.defaultChecked = defaultChecked;
+		if (mountToken.current !== renderToken) {
+			const want = readBase();
+			if (el.checked !== want) el.checked = want;
+		}
+		if (indeterminate !== void 0 && el.indeterminate !== indeterminate) el.indeterminate = indeterminate;
+	});
+	useFormReset(node, (event) => {
+		if (group) return;
+		const el = node.current;
+		if (el === null) return;
+		const next = el.defaultChecked;
+		const base = options.latestInFlight?.()?.next ?? checked;
+		if (next !== base) options.onPlatformChange?.(next, event);
+		else if (el.checked !== base) el.checked = base;
+	});
+	return ref;
+}
+function isInputOfType(el, type) {
+	return el.tagName === "INPUT" && el.type === type;
+}
+function describeElement(el) {
+	const tag = el.tagName.toLowerCase();
+	return tag === "input" ? `\`<input type="${el.type}">\`` : `\`<${tag}>\``;
+}
+const warnedPreventDefault = /* @__PURE__ */ new WeakSet();
+/**
+* Shared `onChange` guard for checkable inputs (conventions 3.8 rule 9, 2.3 item 3):
+*
+* - A click that is already cancelled (`preventDefault()` in a pass-through `onClick`, which runs
+*   before the library's `onChange`) is not a change: the browser reverts the DOM after dispatch
+*   and React restores unchanged props. Nothing is dispatched.
+* - Otherwise `dispatch()` runs (the action's sync prefix included); if the event is cancelled
+*   now, the action's sync prefix called `preventDefault()`, which desyncs the input while the
+*   action is pending. Development warns once per input element.
+*/
+function guardCheckableChange(event, dispatch, component = "A checkable input") {
+	if (event.defaultPrevented) return;
+	dispatch();
+	if (!isDev || !event.defaultPrevented) return;
+	const target = event.target;
+	if (target !== null) {
+		if (warnedPreventDefault.has(target)) return;
+		warnedPreventDefault.add(target);
+	}
+	console.error(`${component}: \`preventDefault()\` on the change event is not supported; it desyncs the input while the action is pending. Use controlled mode to veto a change.`);
+}
+//#endregion
+export { guardCheckableChange, useNativeChecked };
+
+//# sourceMappingURL=use-native-checked.mjs.map

package/dist/internal/use-native-checked.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-native-checked.mjs","names":[],"sources":["../../src/internal/use-native-checked.ts"],"sourcesContent":["\"use client\";\nimport { useCallback, useEffectEvent, useLayoutEffect, useRef } from \"react\";\nimport type { RefCallback } from \"react\";\nimport { useFormReset } from \"./use-form-reset.js\";\n\nconst isDev = process.env.NODE_ENV !== \"production\";\n\nexport interface UseNativeCheckedOptions {\n  /** Dev-only: the expected `input.type`. */\n  readonly type: \"checkbox\" | \"radio\";\n  /** Dev-only: the part's name in warnings (`\"Switch\"`, `\"RadioGroup.Item\"`). */\n  readonly component: string;\n  /** What the DOM must show after every commit: the optimistic value. */\n  readonly checked: boolean;\n  /**\n   * The form-reset target. Uncontrolled parts pass the latest `defaultChecked` prop (`?? false`),\n   * mirrored into `el.defaultChecked` after every commit. Controlled parts pass `undefined`:\n   * React's mount-time value stays (conventions 3.8 rule 6).\n   */\n  readonly defaultChecked: boolean | undefined;\n  /** Checkbox only: `el.indeterminate` after every commit (the part passes `indeterminate && !pending`). */\n  readonly indeterminate?: boolean | undefined;\n  /**\n   * `true` inside a group (`RadioGroup.Item`): the hook does the element check and the re-apply\n   * only; mount reconciliation and form reset are reported once per group by the Root through\n   * `useNativeGroupReconciliation`. Default `false`: the hook reports both paths itself.\n   */\n  readonly group?: boolean | undefined;\n  /**\n   * Group members only: the Root's `onItemMounted` from `useNativeGroupReconciliation`. Called\n   * from this member's mount layout effect so that a member mounting after the Root (a Suspense\n   * boundary that hydrates later) still gets the group reconciled. Receives the member's element\n   * (`null` if the ref is not attached). Ignored without `group`.\n   */\n  readonly onItemMounted?: ((element: HTMLInputElement | null) => void) | undefined;\n  /** From `useControllableAction`: the value the DOM is compared against on the residual paths. */\n  readonly latestInFlight?: (() => { readonly next: boolean } | null) | undefined;\n  /**\n   * Single controls only. The browser changed the value on a residual path and it differs from\n   * what the user intends. `event` is the `reset` event, or `undefined` for mount reconciliation.\n   * The part dispatches with `reason: \"platform\"`.\n   */\n  readonly onPlatformChange?: ((next: boolean, event: Event | undefined) => void) | undefined;\n}\n\n/**\n * Per-element machinery for a controlled native `<input type=\"checkbox\" | \"radio\">`\n * (conventions 3.8): returns the ref to attach to the input (merged by `useRender`).\n *\n * 1. Ref callback: stores the node; in development warns once when it is not an `<input>` of\n *    the expected `type`.\n * 2. Mount reconciliation (single controls): a click before hydration or Firefox's form-state\n *    restoration left the DOM different from what the user intends; reported once with\n *    `event: undefined`.\n * 3. Re-apply after every commit: `checked` (optimistic, or the latest in-flight value),\n *    `indeterminate` and `defaultChecked`, none of which React manages for a controlled input\n *    except `checked`.\n * 4. Form reset (single controls): in a microtask after the reset, compares `el.defaultChecked`\n *    with what the user intends and reports a difference with the `reset` event.\n *\n * The hook knows nothing about transitions or `reason`; the part wires `onPlatformChange`.\n */\nexport function useNativeChecked(options: UseNativeCheckedOptions): RefCallback<HTMLInputElement> {\n  const { type, component, checked, defaultChecked, indeterminate, group = false } = options;\n  const node = useRef<HTMLInputElement | null>(null);\n  const warnedElement = useRef(false);\n\n  const ref = useCallback(\n    (el: HTMLInputElement) => {\n      node.current = el;\n      if (isDev && !warnedElement.current && !isInputOfType(el, type)) {\n        warnedElement.current = true;\n        console.error(\n          `${component}: expected to render an \\`<input type=\"${type}\">\\` but got ` +\n            `${describeElement(el)}; the platform semantics (form participation, labels, ` +\n            `keyboard, reset) need a real input. A \\`render\\` element must keep the input.`,\n        );\n      }\n      return () => {\n        node.current = null;\n      };\n    },\n    [type, component],\n  );\n\n  /** What the user intends: the latest in-flight dispatch, else the optimistic value (rule 1). */\n  const readBase = useEffectEvent(() => options.latestInFlight?.()?.next ?? checked);\n  const report = useEffectEvent((next: boolean, event: Event | undefined) => {\n    options.onPlatformChange?.(next, event);\n  });\n\n  // 2. Mount reconciliation. Declared before the re-apply effect so that the hydrated DOM value is\n  //    read before anything overwrites it (rule 3). StrictMode's second run finds the first run's\n  //    dispatch in flight and does nothing.\n  const reconcileMount = useEffectEvent(() => {\n    if (group) return;\n    const el = node.current;\n    if (el === null) return;\n    if (el.checked !== readBase()) report(el.checked, undefined);\n  });\n  useLayoutEffect(() => {\n    reconcileMount();\n  }, []);\n\n  // 2b. Group members tell the Root they mounted; the Root reconciles the group again if its own\n  //     mount reconciliation already ran (a member mounting later), which covers the `checked`\n  //     write this member skips in its mount commit (below).\n  const notifyMounted = useEffectEvent(() => {\n    if (group) options.onItemMounted?.(node.current);\n  });\n  useLayoutEffect(() => {\n    notifyMounted();\n  }, []);\n\n  // 3. Re-apply after every commit (rule 8). `checked` is skipped in the mount commit (including\n  //    StrictMode's re-run of it, which closes over the same render): React has just written it\n  //    from the prop, or kept the hydrated DOM value for the residual path to read. That matters\n  //    for groups, whose Root reconciles in its own layout effect, after its Items' effects.\n  const renderToken = {};\n  const mountToken = useRef<object | null>(null);\n  useLayoutEffect(() => {\n    if (mountToken.current === null) mountToken.current = renderToken;\n    const el = node.current;\n    if (el === null) return;\n    // The order defaultChecked -> checked -> indeterminate is load-bearing for the first two.\n    // React's automatic reset after a <form action> runs in the mutation phase, after react-dom\n    // wrote `checked` and before this effect, and clears the dirty-checkedness flag; writing\n    // `defaultChecked` (a new default from the same transition) then moves `checked` too, and the\n    // `checked` write that follows restores the intended value. The other way round, the `checked`\n    // write is skipped (it still matches) and the DOM ends up on the new default.\n    // `indeterminate` is independent of both writes and goes last. Tested in\n    // use-native-checked.test.tsx (\"re-apply order\").\n    if (defaultChecked !== undefined && el.defaultChecked !== defaultChecked) {\n      el.defaultChecked = defaultChecked;\n    }\n    if (mountToken.current !== renderToken) {\n      const want = readBase();\n      if (el.checked !== want) el.checked = want;\n    }\n    if (indeterminate !== undefined && el.indeterminate !== indeterminate) {\n      el.indeterminate = indeterminate;\n    }\n  });\n\n  // 4. Form reset (rules 4 to 7). `el.defaultChecked` is the value the browser reset to; by the\n  //    time the microtask runs after React's own reset, the re-apply effect may already have put\n  //    the optimistic value back into `checked`. (`useFormReset` already calls this through an\n  //    Effect Event, so it reads the latest render's options directly.)\n  useFormReset(node, (event) => {\n    if (group) return;\n    const el = node.current;\n    if (el === null) return;\n    const next = el.defaultChecked;\n    const base = options.latestInFlight?.()?.next ?? checked;\n    if (next !== base) options.onPlatformChange?.(next, event);\n    else if (el.checked !== base) el.checked = base;\n  });\n\n  return ref;\n}\n\nfunction isInputOfType(el: Element, type: string): boolean {\n  return el.tagName === \"INPUT\" && (el as HTMLInputElement).type === type;\n}\n\nfunction describeElement(el: Element): string {\n  const tag = el.tagName.toLowerCase();\n  return tag === \"input\" ? `\\`<input type=\"${(el as HTMLInputElement).type}\">\\`` : `\\`<${tag}>\\``;\n}\n\nconst warnedPreventDefault = new WeakSet<EventTarget>();\n\n/**\n * Shared `onChange` guard for checkable inputs (conventions 3.8 rule 9, 2.3 item 3):\n *\n * - A click that is already cancelled (`preventDefault()` in a pass-through `onClick`, which runs\n *   before the library's `onChange`) is not a change: the browser reverts the DOM after dispatch\n *   and React restores unchanged props. Nothing is dispatched.\n * - Otherwise `dispatch()` runs (the action's sync prefix included); if the event is cancelled\n *   now, the action's sync prefix called `preventDefault()`, which desyncs the input while the\n *   action is pending. Development warns once per input element.\n */\nexport function guardCheckableChange(\n  event: Event,\n  dispatch: () => void,\n  component: string = \"A checkable input\",\n): void {\n  if (event.defaultPrevented) return;\n  dispatch();\n  if (!isDev || !event.defaultPrevented) return;\n  const target = event.target;\n  if (target !== null) {\n    if (warnedPreventDefault.has(target)) return;\n    warnedPreventDefault.add(target);\n  }\n  console.error(\n    `${component}: \\`preventDefault()\\` on the change event is not supported; it desyncs the ` +\n      `input while the action is pending. Use controlled mode to veto a change.`,\n  );\n}\n"],"mappings":";;;;AAKA,MAAM,QAAQ,QAAQ,IAAI,aAAa;;;;;;;;;;;;;;;;;;AAyDvC,SAAgB,iBAAiB,SAAiE;CAChG,MAAM,EAAE,MAAM,WAAW,SAAS,gBAAgB,eAAe,QAAQ,UAAU;CACnF,MAAM,OAAO,OAAgC,IAAI;CACjD,MAAM,gBAAgB,OAAO,KAAK;CAElC,MAAM,MAAM,aACT,OAAyB;EACxB,KAAK,UAAU;EACf,IAAI,SAAS,CAAC,cAAc,WAAW,CAAC,cAAc,IAAI,IAAI,GAAG;GAC/D,cAAc,UAAU;GACxB,QAAQ,MACN,GAAG,UAAU,yCAAyC,KAAK,eACtD,gBAAgB,EAAE,EAAE,oIAE3B;EACF;EACA,aAAa;GACX,KAAK,UAAU;EACjB;CACF,GACA,CAAC,MAAM,SAAS,CAClB;;CAGA,MAAM,WAAW,qBAAqB,QAAQ,iBAAiB,CAAC,EAAE,QAAQ,OAAO;CACjF,MAAM,SAAS,gBAAgB,MAAe,UAA6B;EACzE,QAAQ,mBAAmB,MAAM,KAAK;CACxC,CAAC;CAKD,MAAM,iBAAiB,qBAAqB;EAC1C,IAAI,OAAO;EACX,MAAM,KAAK,KAAK;EAChB,IAAI,OAAO,MAAM;EACjB,IAAI,GAAG,YAAY,SAAS,GAAG,OAAO,GAAG,SAAS,KAAA,CAAS;CAC7D,CAAC;CACD,sBAAsB;EACpB,eAAe;CACjB,GAAG,CAAC,CAAC;CAKL,MAAM,gBAAgB,qBAAqB;EACzC,IAAI,OAAO,QAAQ,gBAAgB,KAAK,OAAO;CACjD,CAAC;CACD,sBAAsB;EACpB,cAAc;CAChB,GAAG,CAAC,CAAC;CAML,MAAM,cAAc,CAAC;CACrB,MAAM,aAAa,OAAsB,IAAI;CAC7C,sBAAsB;EACpB,IAAI,WAAW,YAAY,MAAM,WAAW,UAAU;EACtD,MAAM,KAAK,KAAK;EAChB,IAAI,OAAO,MAAM;EASjB,IAAI,mBAAmB,KAAA,KAAa,GAAG,mBAAmB,gBACxD,GAAG,iBAAiB;EAEtB,IAAI,WAAW,YAAY,aAAa;GACtC,MAAM,OAAO,SAAS;GACtB,IAAI,GAAG,YAAY,MAAM,GAAG,UAAU;EACxC;EACA,IAAI,kBAAkB,KAAA,KAAa,GAAG,kBAAkB,eACtD,GAAG,gBAAgB;CAEvB,CAAC;CAMD,aAAa,OAAO,UAAU;EAC5B,IAAI,OAAO;EACX,MAAM,KAAK,KAAK;EAChB,IAAI,OAAO,MAAM;EACjB,MAAM,OAAO,GAAG;EAChB,MAAM,OAAO,QAAQ,iBAAiB,CAAC,EAAE,QAAQ;EACjD,IAAI,SAAS,MAAM,QAAQ,mBAAmB,MAAM,KAAK;OACpD,IAAI,GAAG,YAAY,MAAM,GAAG,UAAU;CAC7C,CAAC;CAED,OAAO;AACT;AAEA,SAAS,cAAc,IAAa,MAAuB;CACzD,OAAO,GAAG,YAAY,WAAY,GAAwB,SAAS;AACrE;AAEA,SAAS,gBAAgB,IAAqB;CAC5C,MAAM,MAAM,GAAG,QAAQ,YAAY;CACnC,OAAO,QAAQ,UAAU,kBAAmB,GAAwB,KAAK,QAAQ,MAAM,IAAI;AAC7F;AAEA,MAAM,uCAAuB,IAAI,QAAqB;;;;;;;;;;;AAYtD,SAAgB,qBACd,OACA,UACA,YAAoB,qBACd;CACN,IAAI,MAAM,kBAAkB;CAC5B,SAAS;CACT,IAAI,CAAC,SAAS,CAAC,MAAM,kBAAkB;CACvC,MAAM,SAAS,MAAM;CACrB,IAAI,WAAW,MAAM;EACnB,IAAI,qBAAqB,IAAI,MAAM,GAAG;EACtC,qBAAqB,IAAI,MAAM;CACjC;CACA,QAAQ,MACN,GAAG,UAAU,qJAEf;AACF"}

package/dist/internal/use-native-group-reconciliation.mjs

@@ -0,0 +1,64 @@
+"use client";
+import { useFormReset } from "./use-form-reset.mjs";
+import { useCallback, useEffectEvent, useLayoutEffect, useRef } from "react";
+//#region src/internal/use-native-group-reconciliation.ts
+/**
+* Group adapter of the native-input machinery (conventions 3.8): one dispatch per group for the
+* residual browser paths, from the Root rather than once per member.
+*
+* - Mount reconciliation, once, in a layout effect: `readCurrent()` vs `base()`. The members'
+*   `useNativeChecked({ group: true })` leaves `checked` alone in their mount commit, so this
+*   effect, which runs after the members' (children first), still reads the hydrated DOM.
+* - Late members: a member mounting in a later commit (a Suspense boundary that hydrates after the
+*   Root, where a click before hydration changed the DOM) reports through `onItemMounted`, and the
+*   group is reconciled again the same way (see `UseNativeGroupReconciliationResult`).
+* - Form reset through `useFormReset` on the container: in a microtask after the reset,
+*   `readDefault()` vs `base()`.
+*
+* Values are compared with `Object.is`.
+*/
+function useNativeGroupReconciliation(options) {
+	const { element } = options;
+	const latest = useRef(options);
+	useLayoutEffect(() => {
+		latest.current = options;
+	});
+	/** The Root's own mount reconciliation has run (reset by its cleanup, StrictMode included). */
+	const rootReconciled = useRef(false);
+	/** A late reconciliation is queued; members mounting in the same commit share it. */
+	const lateQueued = useRef(false);
+	const reconcileMount = useEffectEvent(() => {
+		if (element.current === null) return;
+		reconcile(options, options.readCurrent());
+	});
+	useLayoutEffect(() => {
+		reconcileMount();
+		rootReconciled.current = true;
+		return () => {
+			rootReconciled.current = false;
+		};
+	}, []);
+	const onItemMounted = useCallback(() => {
+		if (!rootReconciled.current || lateQueued.current) return;
+		lateQueued.current = true;
+		queueMicrotask(() => {
+			lateQueued.current = false;
+			if (!rootReconciled.current) return;
+			const current = latest.current;
+			if (current.element.current === null) return;
+			reconcile(current, current.readCurrent());
+		});
+	}, []);
+	useFormReset(element, (event) => {
+		if (element.current === null) return;
+		reconcile(options, options.readDefault(), event);
+	});
+	return { onItemMounted };
+}
+function reconcile(options, next, event) {
+	if (!Object.is(next, options.base())) options.onPlatformChange(next, event);
+}
+//#endregion
+export { useNativeGroupReconciliation };
+
+//# sourceMappingURL=use-native-group-reconciliation.mjs.map

package/dist/internal/use-native-group-reconciliation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-native-group-reconciliation.mjs","names":[],"sources":["../../src/internal/use-native-group-reconciliation.ts"],"sourcesContent":["\"use client\";\nimport { useCallback, useEffectEvent, useLayoutEffect, useRef } from \"react\";\nimport type { RefObject } from \"react\";\nimport { useFormReset } from \"./use-form-reset.js\";\n\nexport interface UseNativeGroupReconciliationOptions<T> {\n  /** The group's form-associated container (`RadioGroup.Root`'s `<fieldset>`). */\n  readonly element: RefObject<HTMLFieldSetElement | null>;\n  /** The group's value as the DOM shows it now (`checked` of the members). */\n  readonly readCurrent: () => T;\n  /** The value the browser resets the group to (`defaultChecked` of the members, rule 5). */\n  readonly readDefault: () => T;\n  /**\n   * What the user intends (rule 1): the latest in-flight dispatch's `next`, else the optimistic\n   * value. Use an explicit null check, `const f = latestInFlight(); return f === null ?\n   * optimistic : f.next;`, not `?.next ?? optimistic`, which drops an in-flight dispatch of a\n   * nullish value (a pending reset to \"nothing checked\").\n   */\n  readonly base: () => T;\n  /**\n   * The browser changed the group's value on a residual path and it differs from `base()`.\n   * `event` is the `reset` event, or `undefined` for mount reconciliation (the Root's mount, or a\n   * member mounting later). The Root dispatches once for the whole group with\n   * `reason: \"platform\"`.\n   */\n  readonly onPlatformChange: (next: T, event: Event | undefined) => void;\n}\n\nexport interface UseNativeGroupReconciliationResult {\n  /**\n   * Stable. Pass it to every member, which hands it to\n   * `useNativeChecked({ group: true, onItemMounted })`; the hook calls it from the member's mount\n   * layout effect. A member that mounts after the Root's own mount reconciliation (inside a\n   * Suspense boundary that hydrates later, selective hydration, or a member added on the client)\n   * makes the adapter reconcile the group again: `readCurrent()` vs `base()`, in a microtask, once\n   * for all members mounted in the same commit. Members mounting in the Root's own commit are\n   * covered by the Root's mount reconciliation (their effects run before the Root's) and are\n   * ignored.\n   *\n   * RadioGroup wiring: `const { onItemMounted } = useNativeGroupReconciliation(...)` in the Root,\n   * put `onItemMounted` in the group context, and in each Item\n   * `useNativeChecked({ type: \"radio\", group: true, onItemMounted: ctx.onItemMounted, ... })`.\n   * The member's element argument is not used here; the Root may use it (dev warnings).\n   */\n  readonly onItemMounted: (element?: Element | null) => void;\n}\n\n/**\n * Group adapter of the native-input machinery (conventions 3.8): one dispatch per group for the\n * residual browser paths, from the Root rather than once per member.\n *\n * - Mount reconciliation, once, in a layout effect: `readCurrent()` vs `base()`. The members'\n *   `useNativeChecked({ group: true })` leaves `checked` alone in their mount commit, so this\n *   effect, which runs after the members' (children first), still reads the hydrated DOM.\n * - Late members: a member mounting in a later commit (a Suspense boundary that hydrates after the\n *   Root, where a click before hydration changed the DOM) reports through `onItemMounted`, and the\n *   group is reconciled again the same way (see `UseNativeGroupReconciliationResult`).\n * - Form reset through `useFormReset` on the container: in a microtask after the reset,\n *   `readDefault()` vs `base()`.\n *\n * Values are compared with `Object.is`.\n */\nexport function useNativeGroupReconciliation<T>(\n  options: UseNativeGroupReconciliationOptions<T>,\n): UseNativeGroupReconciliationResult {\n  const { element } = options;\n\n  // The latest committed options, for the late reconciliation, which runs in a microtask outside\n  // any effect (so it cannot go through an Effect Event).\n  const latest = useRef(options);\n  useLayoutEffect(() => {\n    latest.current = options;\n  });\n\n  /** The Root's own mount reconciliation has run (reset by its cleanup, StrictMode included). */\n  const rootReconciled = useRef(false);\n  /** A late reconciliation is queued; members mounting in the same commit share it. */\n  const lateQueued = useRef(false);\n\n  const reconcileMount = useEffectEvent(() => {\n    if (element.current === null) return;\n    reconcile(options, options.readCurrent());\n  });\n  useLayoutEffect(() => {\n    reconcileMount();\n    rootReconciled.current = true;\n    return () => {\n      rootReconciled.current = false;\n    };\n  }, []);\n\n  const onItemMounted = useCallback(() => {\n    if (!rootReconciled.current || lateQueued.current) return;\n    lateQueued.current = true;\n    queueMicrotask(() => {\n      lateQueued.current = false;\n      if (!rootReconciled.current) return;\n      const current = latest.current;\n      if (current.element.current === null) return;\n      reconcile(current, current.readCurrent());\n    });\n  }, []);\n\n  useFormReset(element, (event) => {\n    if (element.current === null) return;\n    reconcile(options, options.readDefault(), event);\n  });\n\n  return { onItemMounted };\n}\n\nfunction reconcile<T>(options: UseNativeGroupReconciliationOptions<T>, next: T, event?: Event) {\n  if (!Object.is(next, options.base())) options.onPlatformChange(next, event);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA8DA,SAAgB,6BACd,SACoC;CACpC,MAAM,EAAE,YAAY;CAIpB,MAAM,SAAS,OAAO,OAAO;CAC7B,sBAAsB;EACpB,OAAO,UAAU;CACnB,CAAC;;CAGD,MAAM,iBAAiB,OAAO,KAAK;;CAEnC,MAAM,aAAa,OAAO,KAAK;CAE/B,MAAM,iBAAiB,qBAAqB;EAC1C,IAAI,QAAQ,YAAY,MAAM;EAC9B,UAAU,SAAS,QAAQ,YAAY,CAAC;CAC1C,CAAC;CACD,sBAAsB;EACpB,eAAe;EACf,eAAe,UAAU;EACzB,aAAa;GACX,eAAe,UAAU;EAC3B;CACF,GAAG,CAAC,CAAC;CAEL,MAAM,gBAAgB,kBAAkB;EACtC,IAAI,CAAC,eAAe,WAAW,WAAW,SAAS;EACnD,WAAW,UAAU;EACrB,qBAAqB;GACnB,WAAW,UAAU;GACrB,IAAI,CAAC,eAAe,SAAS;GAC7B,MAAM,UAAU,OAAO;GACvB,IAAI,QAAQ,QAAQ,YAAY,MAAM;GACtC,UAAU,SAAS,QAAQ,YAAY,CAAC;EAC1C,CAAC;CACH,GAAG,CAAC,CAAC;CAEL,aAAa,UAAU,UAAU;EAC/B,IAAI,QAAQ,YAAY,MAAM;EAC9B,UAAU,SAAS,QAAQ,YAAY,GAAG,KAAK;CACjD,CAAC;CAED,OAAO,EAAE,cAAc;AACzB;AAEA,SAAS,UAAa,SAAiD,MAAS,OAAe;CAC7F,IAAI,CAAC,OAAO,GAAG,MAAM,QAAQ,KAAK,CAAC,GAAG,QAAQ,iBAAiB,MAAM,KAAK;AAC5E"}

package/dist/internal/use-render.mjs

@@ -0,0 +1,51 @@
+"use client";
+import { mergeProps, mergeRefs } from "./merge-props.mjs";
+import { cloneElement, createElement, isValidElement, useMemo } from "react";
+//#region src/internal/use-render.tsx
+function resolveStateValue(value, state) {
+	return typeof value === "function" ? value(state) : value;
+}
+/**
+* Whether a part whose default element is a `<button>` should add `type="button"`: no `render`,
+* a `render` element whose type is the intrinsic `"button"`, or the function form (it receives
+* button props and decides itself what to spread). An element of any other type (an `<a>`, a
+* router `Link`) does not get it: `type` means something else, or nothing, there.
+*/
+function rendersButton(render) {
+	if (render === void 0 || typeof render === "function") return true;
+	return isValidElement(render) && render.type === "button";
+}
+/**
+* Resolves `render` and the function-form `className` / `style` / `children` of a part against
+* its state and produces the element (conventions 1.2, 1.3, 1.4).
+*/
+function useRender(options) {
+	const { defaultElement, render, state, className, style, children, props, libraryProps, ref } = options;
+	const consumerRef = props.ref;
+	const renderElement = isValidElement(render) ? render : void 0;
+	const elementRef = renderElement?.props.ref;
+	const mergedRef = useMemo(() => mergeRefs(ref, consumerRef, elementRef), [
+		ref,
+		consumerRef,
+		elementRef
+	]);
+	const partProps = {
+		...props,
+		ref: mergedRef,
+		className: resolveStateValue(className, state),
+		style: resolveStateValue(style, state),
+		children: resolveStateValue(children, state)
+	};
+	const controlled = libraryProps ?? {};
+	if (renderElement !== void 0) {
+		const { ref: _ignored, ...elementProps } = renderElement.props;
+		return cloneElement(renderElement, mergeProps(partProps, elementProps, controlled));
+	}
+	const resolved = mergeProps(partProps, {}, controlled);
+	if (typeof render === "function") return render(resolved, state);
+	return createElement(defaultElement, resolved);
+}
+//#endregion
+export { rendersButton, resolveStateValue, useRender };
+
+//# sourceMappingURL=use-render.mjs.map

package/dist/internal/use-render.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-render.mjs","names":[],"sources":["../../src/internal/use-render.tsx"],"sourcesContent":["\"use client\";\nimport { cloneElement, createElement, isValidElement, useMemo } from \"react\";\nimport type { CSSProperties, ReactNode, Ref } from \"react\";\nimport { mergeProps, mergeRefs } from \"./merge-props.js\";\nimport type { RenderProp, StateValue } from \"./types.js\";\n\ninterface ElementLikeProps {\n  className?: string | undefined;\n  style?: CSSProperties | undefined;\n  children?: ReactNode;\n  ref?: Ref<unknown> | undefined;\n}\n\n/** `data-*` attributes are valid JSX but absent from the element prop types. */\nexport type DataAttributes = { [key: `data-${string}`]: string | undefined };\n\nexport interface UseRenderOptions<Props extends ElementLikeProps, State> {\n  /** Intrinsic element rendered when `render` is not given. */\n  defaultElement: string;\n  render: RenderProp<Props, State> | undefined;\n  state: State;\n  className: StateValue<string | undefined, State> | undefined;\n  style: StateValue<CSSProperties | undefined, State> | undefined;\n  children: StateValue<ReactNode, State> | undefined;\n  /** The part's pass-through props for the element. A `render` element's own props win over these. */\n  props: Omit<Props, \"className\" | \"style\" | \"children\"> & DataAttributes;\n  /**\n   * Library-controlled attributes the part computes (`role`, `aria-*` state, id wiring, `data-*`\n   * state, the library's own event handlers). These win over a `render` element's props\n   * (conventions 1.2).\n   */\n  libraryProps?: Partial<Omit<Props, \"className\" | \"style\" | \"children\">> & DataAttributes;\n  /** The library's own ref, if the part needs the DOM node. */\n  ref?: Ref<unknown> | undefined;\n}\n\nexport function resolveStateValue<T, State>(value: StateValue<T, State>, state: State): T {\n  return typeof value === \"function\" ? (value as (state: State) => T)(state) : value;\n}\n\n/**\n * Whether a part whose default element is a `<button>` should add `type=\"button\"`: no `render`,\n * a `render` element whose type is the intrinsic `\"button\"`, or the function form (it receives\n * button props and decides itself what to spread). An element of any other type (an `<a>`, a\n * router `Link`) does not get it: `type` means something else, or nothing, there.\n */\nexport function rendersButton<Props, State>(render: RenderProp<Props, State> | undefined): boolean {\n  if (render === undefined || typeof render === \"function\") return true;\n  return isValidElement(render) && render.type === \"button\";\n}\n\n/**\n * Resolves `render` and the function-form `className` / `style` / `children` of a part against\n * its state and produces the element (conventions 1.2, 1.3, 1.4).\n */\nexport function useRender<Props extends ElementLikeProps, State>(\n  options: UseRenderOptions<Props, State>,\n): ReactNode {\n  const { defaultElement, render, state, className, style, children, props, libraryProps, ref } =\n    options;\n\n  const consumerRef = (props as ElementLikeProps).ref;\n  const renderElement = isValidElement<ElementLikeProps>(render) ? render : undefined;\n  const elementRef = renderElement?.props.ref;\n  // Memoised so that the callback ref keeps its identity across renders and React does not\n  // detach and re-attach the node every time.\n  const mergedRef = useMemo(\n    () => mergeRefs(ref, consumerRef, elementRef),\n    [ref, consumerRef, elementRef],\n  );\n\n  const partProps = {\n    ...props,\n    ref: mergedRef,\n    className: resolveStateValue(className, state),\n    style: resolveStateValue(style, state),\n    children: resolveStateValue(children, state),\n  } as Record<string, unknown>;\n  const controlled = (libraryProps ?? {}) as Record<string, unknown>;\n\n  if (renderElement !== undefined) {\n    // The element's ref is already part of `mergedRef`.\n    const { ref: _ignored, ...elementProps } = renderElement.props as Record<string, unknown>;\n    return cloneElement(\n      renderElement,\n      mergeProps(partProps, elementProps, controlled) as Partial<Props>,\n    );\n  }\n  const resolved = mergeProps(partProps, {}, controlled) as unknown as Props;\n  if (typeof render === \"function\") {\n    return render(resolved, state);\n  }\n  return createElement(defaultElement, resolved);\n}\n"],"mappings":";;;;AAoCA,SAAgB,kBAA4B,OAA6B,OAAiB;CACxF,OAAO,OAAO,UAAU,aAAc,MAA8B,KAAK,IAAI;AAC/E;;;;;;;AAQA,SAAgB,cAA4B,QAAuD;CACjG,IAAI,WAAW,KAAA,KAAa,OAAO,WAAW,YAAY,OAAO;CACjE,OAAO,eAAe,MAAM,KAAK,OAAO,SAAS;AACnD;;;;;AAMA,SAAgB,UACd,SACW;CACX,MAAM,EAAE,gBAAgB,QAAQ,OAAO,WAAW,OAAO,UAAU,OAAO,cAAc,QACtF;CAEF,MAAM,cAAe,MAA2B;CAChD,MAAM,gBAAgB,eAAiC,MAAM,IAAI,SAAS,KAAA;CAC1E,MAAM,aAAa,eAAe,MAAM;CAGxC,MAAM,YAAY,cACV,UAAU,KAAK,aAAa,UAAU,GAC5C;EAAC;EAAK;EAAa;CAAU,CAC/B;CAEA,MAAM,YAAY;EAChB,GAAG;EACH,KAAK;EACL,WAAW,kBAAkB,WAAW,KAAK;EAC7C,OAAO,kBAAkB,OAAO,KAAK;EACrC,UAAU,kBAAkB,UAAU,KAAK;CAC7C;CACA,MAAM,aAAc,gBAAgB,CAAC;CAErC,IAAI,kBAAkB,KAAA,GAAW;EAE/B,MAAM,EAAE,KAAK,UAAU,GAAG,iBAAiB,cAAc;EACzD,OAAO,aACL,eACA,WAAW,WAAW,cAAc,UAAU,CAChD;CACF;CACA,MAAM,WAAW,WAAW,WAAW,CAAC,GAAG,UAAU;CACrD,IAAI,OAAO,WAAW,YACpB,OAAO,OAAO,UAAU,KAAK;CAE/B,OAAO,cAAc,gBAAgB,QAAQ;AAC/C"}

package/dist/internal/use-until-found.mjs

@@ -0,0 +1,40 @@
+"use client";
+import { useEffect, useEffectEvent, useLayoutEffect, useRef } from "react";
+//#region src/internal/use-until-found.ts
+/**
+* The single home of the `hidden="until-found"` workaround (conventions 7.4).
+*
+* react-dom 19.3 serialises `hidden` as a boolean attribute (`hidden=""` on client and server),
+* so the part renders a boolean `hidden` and this hook upgrades the attribute to `"until-found"`
+* through a ref in a layout effect. The upgrade is re-asserted after **every** commit while
+* `active`: when the browser reveals the element it removes the attribute itself, and if the
+* resulting action is rejected React sees no prop change (the boolean `hidden` stayed `true`
+* throughout) and would leave the element visible.
+*
+* `beforematch` has no React prop, so a native listener is attached in an effect through the
+* returned ref (conventions 2.6, 7.4). Attach the ref to the element that renders the boolean
+* `hidden`.
+*/
+function useUntilFound(options) {
+	const { active } = options;
+	const node = useRef(null);
+	const onMatch = useEffectEvent((event) => {
+		options.onMatch(event);
+	});
+	useLayoutEffect(() => {
+		const element = node.current;
+		if (element !== null && active && element.getAttribute("hidden") !== "until-found") element.setAttribute("hidden", "until-found");
+	});
+	useEffect(() => {
+		const element = node.current;
+		if (element === null) return;
+		const listener = (event) => onMatch(event);
+		element.addEventListener("beforematch", listener);
+		return () => element.removeEventListener("beforematch", listener);
+	});
+	return node;
+}
+//#endregion
+export { useUntilFound };
+
+//# sourceMappingURL=use-until-found.mjs.map