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

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-until-found.mjs","names":[],"sources":["../../src/internal/use-until-found.ts"],"sourcesContent":["\"use client\";\nimport { useEffect, useEffectEvent, useLayoutEffect, useRef } from \"react\";\nimport type { RefObject } from \"react\";\n\nexport interface UseUntilFoundOptions {\n  /**\n   * The element should currently be `hidden=\"until-found\"`. The part renders a boolean `hidden`\n   * itself as well, so server-rendered HTML hides it (as `hidden=\"\"`) before hydration.\n   *\n   * Pass `false` while a change the element itself triggered (its `beforematch`) is pending:\n   * the browser has already revealed it, and re-asserting would hide it again until the commit.\n   * When that change is rejected the owner's optimistic state reverts, `active` becomes `true`\n   * again and the next commit re-hides it.\n   */\n  active: boolean;\n  /** Called with the `beforematch` event when find-in-page or a text fragment reveals it. */\n  onMatch: (event: Event) => void;\n}\n\n/**\n * The single home of the `hidden=\"until-found\"` workaround (conventions 7.4).\n *\n * react-dom 19.3 serialises `hidden` as a boolean attribute (`hidden=\"\"` on client and server),\n * so the part renders a boolean `hidden` and this hook upgrades the attribute to `\"until-found\"`\n * through a ref in a layout effect. The upgrade is re-asserted after **every** commit while\n * `active`: when the browser reveals the element it removes the attribute itself, and if the\n * resulting action is rejected React sees no prop change (the boolean `hidden` stayed `true`\n * throughout) and would leave the element visible.\n *\n * `beforematch` has no React prop, so a native listener is attached in an effect through the\n * returned ref (conventions 2.6, 7.4). Attach the ref to the element that renders the boolean\n * `hidden`.\n */\nexport function useUntilFound<E extends HTMLElement>(\n  options: UseUntilFoundOptions,\n): RefObject<E | null> {\n  const { active } = options;\n  const node = useRef<E | null>(null);\n  const onMatch = useEffectEvent((event: Event) => {\n    options.onMatch(event);\n  });\n\n  // No dependency array on purpose: re-assert after every commit of the owner (see above).\n  useLayoutEffect(() => {\n    const element = node.current;\n    if (element !== null && active && element.getAttribute(\"hidden\") !== \"until-found\") {\n      element.setAttribute(\"hidden\", \"until-found\");\n    }\n  });\n\n  // Re-subscribed after every commit so a swapped element (a changed `render`) is covered.\n  useEffect(() => {\n    const element = node.current;\n    if (element === null) return;\n    const listener = (event: Event) => onMatch(event);\n    element.addEventListener(\"beforematch\", listener);\n    return () => element.removeEventListener(\"beforematch\", listener);\n  });\n\n  return node;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAiCA,SAAgB,cACd,SACqB;CACrB,MAAM,EAAE,WAAW;CACnB,MAAM,OAAO,OAAiB,IAAI;CAClC,MAAM,UAAU,gBAAgB,UAAiB;EAC/C,QAAQ,QAAQ,KAAK;CACvB,CAAC;CAGD,sBAAsB;EACpB,MAAM,UAAU,KAAK;EACrB,IAAI,YAAY,QAAQ,UAAU,QAAQ,aAAa,QAAQ,MAAM,eACnE,QAAQ,aAAa,UAAU,aAAa;CAEhD,CAAC;CAGD,gBAAgB;EACd,MAAM,UAAU,KAAK;EACrB,IAAI,YAAY,MAAM;EACtB,MAAM,YAAY,UAAiB,QAAQ,KAAK;EAChD,QAAQ,iBAAiB,eAAe,QAAQ;EAChD,aAAa,QAAQ,oBAAoB,eAAe,QAAQ;CAClE,CAAC;CAED,OAAO;AACT"}

package/dist/radio-group/index.d.mts

@@ -0,0 +1,20 @@
+import "../internal/platform-attributes.mjs";
+import { RadioGroupItem, RadioGroupItemProps, RadioGroupItemState } from "./radio-group-item.mjs";
+import { RadioGroupRoot, RadioGroupRootProps, RadioGroupRootState, RadioGroupValueChangeDetails } from "./radio-group-root.mjs";
+import { RadioGroupLabel, RadioGroupLabelProps } from "./radio-group-label.mjs";
+//#region src/radio-group/index.d.ts
+/**
+ * RadioGroup (WAI-ARIA APG Radio Group pattern, native HTML radio variant): `Root`
+ * (`fieldset[role=radiogroup]`), an optional `Label` (`legend`, first child) and one `Item`
+ * (`input[type=radio]`) per option. The keyboard is entirely native. Each Item's DOM `checked` is
+ * the optimistic value; the Root and the checked Item carry `data-pending` while
+ * `valueChangeAction` is in flight.
+ */
+export declare const RadioGroup: {
+  readonly Root: typeof RadioGroupRoot;
+  readonly Label: typeof RadioGroupLabel;
+  readonly Item: typeof RadioGroupItem;
+};
+//#endregion
+export type { RadioGroupItemProps, RadioGroupItemState, RadioGroupLabelProps, RadioGroupRootProps, RadioGroupRootState, RadioGroupValueChangeDetails };
+//# sourceMappingURL=index.d.mts.map

package/dist/radio-group/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/radio-group/index.ts"],"mappings":";;;;;;;;;;;;qBAca;WACX,aAAI;WACJ,cAAK;WACL,aAAI"}

package/dist/radio-group/index.mjs

@@ -0,0 +1,20 @@
+import { RadioGroupItem } from "./radio-group-item.mjs";
+import { RadioGroupLabel } from "./radio-group-label.mjs";
+import { RadioGroupRoot } from "./radio-group-root.mjs";
+//#region src/radio-group/index.ts
+/**
+* RadioGroup (WAI-ARIA APG Radio Group pattern, native HTML radio variant): `Root`
+* (`fieldset[role=radiogroup]`), an optional `Label` (`legend`, first child) and one `Item`
+* (`input[type=radio]`) per option. The keyboard is entirely native. Each Item's DOM `checked` is
+* the optimistic value; the Root and the checked Item carry `data-pending` while
+* `valueChangeAction` is in flight.
+*/
+const RadioGroup = {
+	Root: RadioGroupRoot,
+	Label: RadioGroupLabel,
+	Item: RadioGroupItem
+};
+//#endregion
+export { RadioGroup };
+
+//# sourceMappingURL=index.mjs.map

package/dist/radio-group/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/radio-group/index.ts"],"sourcesContent":["// Ships the platform attribute typings with this subpath (conventions 7.4). Type-only: the\n// built JS has no import of it.\nimport \"../internal/platform-attributes.js\";\nimport { RadioGroupItem } from \"./radio-group-item.js\";\nimport { RadioGroupLabel } from \"./radio-group-label.js\";\nimport { RadioGroupRoot } from \"./radio-group-root.js\";\n\n/**\n * RadioGroup (WAI-ARIA APG Radio Group pattern, native HTML radio variant): `Root`\n * (`fieldset[role=radiogroup]`), an optional `Label` (`legend`, first child) and one `Item`\n * (`input[type=radio]`) per option. The keyboard is entirely native. Each Item's DOM `checked` is\n * the optimistic value; the Root and the checked Item carry `data-pending` while\n * `valueChangeAction` is in flight.\n */\nexport const RadioGroup = {\n  Root: RadioGroupRoot,\n  Label: RadioGroupLabel,\n  Item: RadioGroupItem,\n} as const;\n\nexport type {\n  RadioGroupRootProps,\n  RadioGroupRootState,\n  RadioGroupValueChangeDetails,\n} from \"./radio-group-root.js\";\nexport type { RadioGroupLabelProps } from \"./radio-group-label.js\";\nexport type { RadioGroupItemProps, RadioGroupItemState } from \"./radio-group-item.js\";\n"],"mappings":";;;;;;;;;;;AAcA,MAAa,aAAa;CACxB,MAAM;CACN,OAAO;CACP,MAAM;AACR"}

package/dist/radio-group/radio-group-context.mjs

@@ -0,0 +1,13 @@
+"use client";
+import { createContext, use } from "react";
+//#region src/radio-group/radio-group-context.ts
+const RadioGroupContext = createContext(null);
+function useRadioGroupContext(part) {
+	const context = use(RadioGroupContext);
+	if (context === null) throw new Error(`${part} must be rendered inside a RadioGroup.Root.`);
+	return context;
+}
+//#endregion
+export { RadioGroupContext, useRadioGroupContext };
+
+//# sourceMappingURL=radio-group-context.mjs.map

package/dist/radio-group/radio-group-context.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio-group-context.mjs","names":[],"sources":["../../src/radio-group/radio-group-context.ts"],"sourcesContent":["\"use client\";\nimport { createContext, use } from \"react\";\n\nexport interface RadioGroupContextValue {\n  /** The `name` shared by every radio of the group (prop or `useId()`). */\n  readonly name: string;\n  readonly form: string | undefined;\n  readonly required: boolean;\n  /** Optimistic value: Items render `checked` from it. */\n  readonly optimistic: string | null;\n  readonly pending: boolean;\n  /** `Root disabled` (reaches the radios natively through `<fieldset disabled>`). */\n  readonly disabled: boolean;\n  /**\n   * Uncontrolled mode: the latest `defaultValue` (`null` when omitted), mirrored by each Item into\n   * `el.defaultChecked` so that a form reset returns to it. `undefined` in controlled mode, where\n   * React's mount-time value stays the reset target (conventions 3.8 rule 6).\n   */\n  readonly defaultValue: string | null | undefined;\n  /**\n   * Dispatches a user check. No-op when `value` is already the optimistic value. Checks neither\n   * `disabled` (a disabled radio fires no click) nor `defaultPrevented` (the Item's\n   * `guardCheckableChange` does).\n   */\n  readonly select: (value: string, event: Event) => void;\n  /**\n   * Called by each Item from its mount layout effect. An Item that mounts after the Root (under a\n   * Suspense boundary, selective hydration) asks the Root to reconcile the group again, so a click\n   * made before that Item hydrated is reported once (deduped by the Root's hook). Receives the\n   * Item's element, which the Root uses for the dev-only partial-hydration warning.\n   */\n  readonly onItemMounted: (element: HTMLInputElement | null) => void;\n}\n\nexport const RadioGroupContext = createContext<RadioGroupContextValue | null>(null);\n\nexport function useRadioGroupContext(part: string): RadioGroupContextValue {\n  const context = use(RadioGroupContext);\n  if (context === null) {\n    throw new Error(`${part} must be rendered inside a RadioGroup.Root.`);\n  }\n  return context;\n}\n"],"mappings":";;;AAkCA,MAAa,oBAAoB,cAA6C,IAAI;AAElF,SAAgB,qBAAqB,MAAsC;CACzE,MAAM,UAAU,IAAI,iBAAiB;CACrC,IAAI,YAAY,MACd,MAAM,IAAI,MAAM,GAAG,KAAK,4CAA4C;CAEtE,OAAO;AACT"}

package/dist/radio-group/radio-group-item.d.mts

@@ -0,0 +1,54 @@
+import { RenderProp, StateValue } from "../internal/types.mjs";
+import { CSSProperties, ComponentPropsWithRef, ViewTransitionClass } from "react";
+//#region src/radio-group/radio-group-item.d.ts
+export interface RadioGroupItemState {
+  readonly value: string;
+  /** Optimistic: true as soon as the user checks this radio, before the action settles. */
+  readonly checked: boolean;
+  /** The Root is pending and this radio is the optimistic target. */
+  readonly pending: boolean;
+  /** Disabled by its own prop or by `Root disabled`. */
+  readonly disabled: boolean;
+}
+export interface RadioGroupItemProps extends Omit<ComponentPropsWithRef<"input">, "type" | "name" | "value" | "checked" | "defaultChecked" | "defaultValue" | "form" | "required" | "onChange" | "className" | "style" | "children"> {
+  /** The value this radio checks. Must be unique within the Root. Submitted as the form value. */
+  value: string;
+  /** Native `disabled`: unfocusable, skipped by arrow keys, never dispatches. */
+  disabled?: boolean;
+  /**
+   * Forwarded to the Item's `<ViewTransition default>`. Default: no boundary. Fires only on the commit
+   * that settles the action (or rolls it back), never on the optimistic check; animate the check
+   * itself with CSS on `:checked`.
+   *
+   * Static: without `transition` the part renders no `<ViewTransition>`; changing it between
+   * `undefined` and a value remounts the element. Any value, `"none"` included, makes a mount or
+   * `<Activity>` reveal of this part inside a transition start a document view transition: the
+   * page cross-fades for about 250 ms and the next transition commit waits for it (issue #35).
+   */
+  transition?: ViewTransitionClass;
+  className?: StateValue<string | undefined, RadioGroupItemState>;
+  style?: StateValue<CSSProperties | undefined, RadioGroupItemState>;
+  /** Replace the rendered element. Must keep an `<input>`; the library sets `type="radio"`. */
+  render?: RenderProp<ComponentPropsWithRef<"input">, RadioGroupItemState>;
+}
+/**
+ * One `<input type="radio">` of the group. Its DOM `checked` is the optimistic value
+ * (`checked={optimistic === value}`): react-dom restores a controlled input to its props after
+ * every event, and only the sync-lane optimistic value survives that restore.
+ *
+ * Owned keys (conventions 1.2; a `render` element's value is overridden): `type`, `name`,
+ * `value`, `checked`, `defaultChecked` (never rendered), `disabled`, `form`, `required`,
+ * `data-checked`, `data-pending`, `data-disabled`. `onChange` is merged: a `render` element's own
+ * handler runs first, then the library's.
+ *
+ * Form reset in controlled mode: React sets an input's `defaultChecked` once, from its initial
+ * `checked`. An Item added on the client while the Root's `value` equals its value gets
+ * `defaultChecked` too, so two radios may carry it and a reset does not necessarily return to
+ * the group's mount-time value (see `RadioGroup.Root` `value`).
+ */
+export declare function RadioGroupItem({ value, disabled: disabledProp, transition, className, style, render, ...rest }: RadioGroupItemProps): import("react").ReactNode;
+export declare namespace RadioGroupItem {
+  var displayName: string;
+}
+//#endregion
+//# sourceMappingURL=radio-group-item.d.mts.map

package/dist/radio-group/radio-group-item.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio-group-item.d.mts","names":[],"sources":["../../src/radio-group/radio-group-item.tsx"],"mappings":";;;iBASiB;WACN;;WAEA;;WAEA;;WAEA;;iBAGM,4BAA4B,KAC3C;;EAeA;;EAEA;;;;;;;;;;;EAWA,aAAa;EACb,YAAY,+BAA+B;EAC3C,QAAQ,WAAW,2BAA2B;;EAE9C,SAAS,WAAW,gCAAgC;;;;;;;;;;;;;;;;;wBAkBtC,iBACd,OACA,UAAU,cACV,YACA,WACA,OACA,WACG,QACF,sCAAmB;yBARN"}

package/dist/radio-group/radio-group-item.mjs

@@ -0,0 +1,88 @@
+"use client";
+import { useTransitionBoundary } from "../internal/transition-boundary.mjs";
+import { dataAttr } from "../internal/data-attr.mjs";
+import { useRender } from "../internal/use-render.mjs";
+import { guardCheckableChange, useNativeChecked } from "../internal/use-native-checked.mjs";
+import { useRadioGroupContext } from "./radio-group-context.mjs";
+//#region src/radio-group/radio-group-item.tsx
+/**
+* One `<input type="radio">` of the group. Its DOM `checked` is the optimistic value
+* (`checked={optimistic === value}`): react-dom restores a controlled input to its props after
+* every event, and only the sync-lane optimistic value survives that restore.
+*
+* Owned keys (conventions 1.2; a `render` element's value is overridden): `type`, `name`,
+* `value`, `checked`, `defaultChecked` (never rendered), `disabled`, `form`, `required`,
+* `data-checked`, `data-pending`, `data-disabled`. `onChange` is merged: a `render` element's own
+* handler runs first, then the library's.
+*
+* Form reset in controlled mode: React sets an input's `defaultChecked` once, from its initial
+* `checked`. An Item added on the client while the Root's `value` equals its value gets
+* `defaultChecked` too, so two radios may carry it and a reset does not necessarily return to
+* the group's mount-time value (see `RadioGroup.Root` `value`).
+*/
+function RadioGroupItem({ value, disabled: disabledProp = false, transition, className, style, render, ...rest }) {
+	const ctx = useRadioGroupContext("RadioGroup.Item");
+	const checked = ctx.optimistic === value;
+	const pending = ctx.pending && checked;
+	const disabled = ctx.disabled || disabledProp;
+	const inputRef = useNativeChecked({
+		type: "radio",
+		component: "RadioGroup.Item",
+		checked,
+		group: true,
+		onItemMounted: (el) => {
+			if (el !== null) {
+				syncPresence(el, "data-checked", checked);
+				syncPresence(el, "data-pending", pending);
+				syncPresence(el, "data-disabled", disabled);
+			}
+			ctx.onItemMounted(el);
+		},
+		defaultChecked: ctx.defaultValue === void 0 ? void 0 : ctx.defaultValue === value
+	});
+	const element = useRender({
+		defaultElement: "input",
+		render,
+		state: {
+			value,
+			checked,
+			pending,
+			disabled
+		},
+		className,
+		style,
+		children: void 0,
+		ref: inputRef,
+		props: rest,
+		libraryProps: {
+			type: "radio",
+			name: ctx.name,
+			value,
+			checked,
+			defaultChecked: void 0,
+			disabled: disabledProp,
+			form: ctx.form,
+			required: ctx.required,
+			"data-checked": dataAttr(checked),
+			"data-pending": dataAttr(pending),
+			"data-disabled": dataAttr(disabled),
+			onChange: (event) => {
+				if (disabled) return;
+				const nativeEvent = event.nativeEvent;
+				guardCheckableChange(nativeEvent, () => ctx.select(value, nativeEvent), "RadioGroup.Item");
+			}
+		}
+	});
+	return useTransitionBoundary("RadioGroup.Item", transition, element);
+}
+RadioGroupItem.displayName = "RadioGroupItem";
+function syncPresence(el, name, present) {
+	if (el.hasAttribute(name) !== present) {
+		if (present) el.setAttribute(name, "");
+		else el.removeAttribute(name);
+	}
+}
+//#endregion
+export { RadioGroupItem };
+
+//# sourceMappingURL=radio-group-item.mjs.map

package/dist/radio-group/radio-group-item.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio-group-item.mjs","names":[],"sources":["../../src/radio-group/radio-group-item.tsx"],"sourcesContent":["\"use client\";\nimport type { ChangeEvent, ComponentPropsWithRef, CSSProperties, ViewTransitionClass } from \"react\";\nimport { useTransitionBoundary } from \"../internal/transition-boundary.js\";\nimport { dataAttr } from \"../internal/data-attr.js\";\nimport type { RenderProp, StateValue } from \"../internal/types.js\";\nimport { guardCheckableChange, useNativeChecked } from \"../internal/use-native-checked.js\";\nimport { useRender } from \"../internal/use-render.js\";\nimport { useRadioGroupContext } from \"./radio-group-context.js\";\n\nexport interface RadioGroupItemState {\n  readonly value: string;\n  /** Optimistic: true as soon as the user checks this radio, before the action settles. */\n  readonly checked: boolean;\n  /** The Root is pending and this radio is the optimistic target. */\n  readonly pending: boolean;\n  /** Disabled by its own prop or by `Root disabled`. */\n  readonly disabled: boolean;\n}\n\nexport interface RadioGroupItemProps extends Omit<\n  ComponentPropsWithRef<\"input\">,\n  | \"type\"\n  | \"name\"\n  | \"value\"\n  | \"checked\"\n  | \"defaultChecked\"\n  | \"defaultValue\"\n  | \"form\"\n  | \"required\"\n  | \"onChange\"\n  | \"className\"\n  | \"style\"\n  | \"children\"\n> {\n  /** The value this radio checks. Must be unique within the Root. Submitted as the form value. */\n  value: string;\n  /** Native `disabled`: unfocusable, skipped by arrow keys, never dispatches. */\n  disabled?: boolean;\n  /**\n   * Forwarded to the Item's `<ViewTransition default>`. Default: no boundary. Fires only on the commit\n   * that settles the action (or rolls it back), never on the optimistic check; animate the check\n   * itself with CSS on `:checked`.\n   *\n   * Static: without `transition` the part renders no `<ViewTransition>`; changing it between\n   * `undefined` and a value remounts the element. Any value, `\"none\"` included, makes a mount or\n   * `<Activity>` reveal of this part inside a transition start a document view transition: the\n   * page cross-fades for about 250 ms and the next transition commit waits for it (issue #35).\n   */\n  transition?: ViewTransitionClass;\n  className?: StateValue<string | undefined, RadioGroupItemState>;\n  style?: StateValue<CSSProperties | undefined, RadioGroupItemState>;\n  /** Replace the rendered element. Must keep an `<input>`; the library sets `type=\"radio\"`. */\n  render?: RenderProp<ComponentPropsWithRef<\"input\">, RadioGroupItemState>;\n}\n\n/**\n * One `<input type=\"radio\">` of the group. Its DOM `checked` is the optimistic value\n * (`checked={optimistic === value}`): react-dom restores a controlled input to its props after\n * every event, and only the sync-lane optimistic value survives that restore.\n *\n * Owned keys (conventions 1.2; a `render` element's value is overridden): `type`, `name`,\n * `value`, `checked`, `defaultChecked` (never rendered), `disabled`, `form`, `required`,\n * `data-checked`, `data-pending`, `data-disabled`. `onChange` is merged: a `render` element's own\n * handler runs first, then the library's.\n *\n * Form reset in controlled mode: React sets an input's `defaultChecked` once, from its initial\n * `checked`. An Item added on the client while the Root's `value` equals its value gets\n * `defaultChecked` too, so two radios may carry it and a reset does not necessarily return to\n * the group's mount-time value (see `RadioGroup.Root` `value`).\n */\nexport function RadioGroupItem({\n  value,\n  disabled: disabledProp = false,\n  transition,\n  className,\n  style,\n  render,\n  ...rest\n}: RadioGroupItemProps) {\n  const ctx = useRadioGroupContext(\"RadioGroup.Item\");\n  const checked = ctx.optimistic === value;\n  const pending = ctx.pending && checked;\n  const disabled = ctx.disabled || disabledProp;\n\n  // Group mode: element check and re-apply only; the Root reports the residual paths once. The\n  // hook calls `onItemMounted` at mount so that an Item mounting after its Root (a Suspense\n  // boundary that hydrates later) still gets the group reconciled.\n  const inputRef = useNativeChecked({\n    type: \"radio\",\n    component: \"RadioGroup.Item\",\n    checked,\n    group: true,\n    onItemMounted: (el) => {\n      // Hydration keeps server attributes that differ from the client render (React only warns).\n      // An Item hydrating after its Root (partial hydration, Root JSDoc) can render a different\n      // `checked` than the server did, e.g. after a click on an already hydrated radio, and a\n      // stale `data-checked` would then stay until the prop changes again.\n      if (el !== null) {\n        syncPresence(el, \"data-checked\", checked);\n        syncPresence(el, \"data-pending\", pending);\n        syncPresence(el, \"data-disabled\", disabled);\n      }\n      ctx.onItemMounted(el);\n    },\n    defaultChecked: ctx.defaultValue === undefined ? undefined : ctx.defaultValue === value,\n  });\n\n  const state: RadioGroupItemState = { value, checked, pending, disabled };\n\n  const element = useRender<ComponentPropsWithRef<\"input\">, RadioGroupItemState>({\n    defaultElement: \"input\",\n    render,\n    state,\n    className,\n    style,\n    children: undefined,\n    ref: inputRef,\n    // Pass-through layer: a `render` element's own props win over these.\n    props: rest,\n    libraryProps: {\n      type: \"radio\",\n      name: ctx.name,\n      value,\n      checked,\n      defaultChecked: undefined,\n      // Owned (Switch precedent) so that native disabledness, `data-disabled` and the click guard\n      // agree. Only the Item's own prop: `Root disabled` reaches the radio through the fieldset.\n      disabled: disabledProp,\n      form: ctx.form,\n      required: ctx.required,\n      \"data-checked\": dataAttr(checked),\n      \"data-pending\": dataAttr(pending),\n      \"data-disabled\": dataAttr(disabled),\n      onChange: (event: ChangeEvent<HTMLInputElement>) => {\n        // A natively disabled radio fires no click; this covers `render` elements that do not\n        // honour `disabled`.\n        if (disabled) return;\n        const nativeEvent = event.nativeEvent;\n        guardCheckableChange(nativeEvent, () => ctx.select(value, nativeEvent), \"RadioGroup.Item\");\n      },\n    },\n  });\n\n  return useTransitionBoundary(\"RadioGroup.Item\", transition, element);\n}\n\nRadioGroupItem.displayName = \"RadioGroupItem\";\n\nfunction syncPresence(el: Element, name: string, present: boolean): void {\n  if (el.hasAttribute(name) !== present) {\n    if (present) el.setAttribute(name, \"\");\n    else el.removeAttribute(name);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAsEA,SAAgB,eAAe,EAC7B,OACA,UAAU,eAAe,OACzB,YACA,WACA,OACA,QACA,GAAG,QACmB;CACtB,MAAM,MAAM,qBAAqB,iBAAiB;CAClD,MAAM,UAAU,IAAI,eAAe;CACnC,MAAM,UAAU,IAAI,WAAW;CAC/B,MAAM,WAAW,IAAI,YAAY;CAKjC,MAAM,WAAW,iBAAiB;EAChC,MAAM;EACN,WAAW;EACX;EACA,OAAO;EACP,gBAAgB,OAAO;GAKrB,IAAI,OAAO,MAAM;IACf,aAAa,IAAI,gBAAgB,OAAO;IACxC,aAAa,IAAI,gBAAgB,OAAO;IACxC,aAAa,IAAI,iBAAiB,QAAQ;GAC5C;GACA,IAAI,cAAc,EAAE;EACtB;EACA,gBAAgB,IAAI,iBAAiB,KAAA,IAAY,KAAA,IAAY,IAAI,iBAAiB;CACpF,CAAC;CAID,MAAM,UAAU,UAA+D;EAC7E,gBAAgB;EAChB;EACA,OAAA;GALmC;GAAO;GAAS;GAAS;EAKxD;EACJ;EACA;EACA,UAAU,KAAA;EACV,KAAK;EAEL,OAAO;EACP,cAAc;GACZ,MAAM;GACN,MAAM,IAAI;GACV;GACA;GACA,gBAAgB,KAAA;GAGhB,UAAU;GACV,MAAM,IAAI;GACV,UAAU,IAAI;GACd,gBAAgB,SAAS,OAAO;GAChC,gBAAgB,SAAS,OAAO;GAChC,iBAAiB,SAAS,QAAQ;GAClC,WAAW,UAAyC;IAGlD,IAAI,UAAU;IACd,MAAM,cAAc,MAAM;IAC1B,qBAAqB,mBAAmB,IAAI,OAAO,OAAO,WAAW,GAAG,iBAAiB;GAC3F;EACF;CACF,CAAC;CAED,OAAO,sBAAsB,mBAAmB,YAAY,OAAO;AACrE;AAEA,eAAe,cAAc;AAE7B,SAAS,aAAa,IAAa,MAAc,SAAwB;CACvE,IAAI,GAAG,aAAa,IAAI,MAAM,SAAS;EACrC,IAAI,SAAS,GAAG,aAAa,MAAM,EAAE;OAChC,GAAG,gBAAgB,IAAI;CAC9B;AACF"}

package/dist/radio-group/radio-group-label.d.mts

@@ -0,0 +1,21 @@
+import { RenderProp, StateValue } from "../internal/types.mjs";
+import { RadioGroupRootState } from "./radio-group-root.mjs";
+import { CSSProperties, ComponentPropsWithRef, ReactNode } from "react";
+//#region src/radio-group/radio-group-label.d.ts
+export interface RadioGroupLabelProps extends Omit<ComponentPropsWithRef<"legend">, "className" | "style" | "children"> {
+  className?: StateValue<string | undefined, RadioGroupRootState>;
+  style?: StateValue<CSSProperties | undefined, RadioGroupRootState>;
+  /** Receives the Root's state: a group-level pending indicator goes here. */
+  children?: StateValue<ReactNode, RadioGroupRootState>;
+  render?: RenderProp<ComponentPropsWithRef<"legend">, RadioGroupRootState>;
+}
+/**
+ * The group's `<legend>`, which names the fieldset natively. Optional; must be the **first child**
+ * of `RadioGroup.Root` (HTML content model). Its state is the Root's state. Owns no keys.
+ */
+export declare function RadioGroupLabel({ className, style, children, render, ...rest }: RadioGroupLabelProps): ReactNode;
+export declare namespace RadioGroupLabel {
+  var displayName: string;
+}
+//#endregion
+//# sourceMappingURL=radio-group-label.d.mts.map

package/dist/radio-group/radio-group-label.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio-group-label.d.mts","names":[],"sources":["../../src/radio-group/radio-group-label.tsx"],"mappings":";;;;iBAOiB,6BAA6B,KAC5C;EAGA,YAAY,+BAA+B;EAC3C,QAAQ,WAAW,2BAA2B;;EAE9C,WAAW,WAAW,WAAW;EACjC,SAAS,WAAW,iCAAiC;;;;;;wBAOvC,kBACd,WACA,OACA,UACA,WACG,QACF,uBAAoB;yBANP"}

package/dist/radio-group/radio-group-label.mjs

@@ -0,0 +1,30 @@
+"use client";
+import { useRender } from "../internal/use-render.mjs";
+import { useRadioGroupContext } from "./radio-group-context.mjs";
+//#region src/radio-group/radio-group-label.tsx
+/**
+* The group's `<legend>`, which names the fieldset natively. Optional; must be the **first child**
+* of `RadioGroup.Root` (HTML content model). Its state is the Root's state. Owns no keys.
+*/
+function RadioGroupLabel({ className, style, children, render, ...rest }) {
+	const ctx = useRadioGroupContext("RadioGroup.Label");
+	const state = {
+		value: ctx.optimistic,
+		pending: ctx.pending,
+		disabled: ctx.disabled
+	};
+	return useRender({
+		defaultElement: "legend",
+		render,
+		state,
+		className,
+		style,
+		children,
+		props: rest
+	});
+}
+RadioGroupLabel.displayName = "RadioGroupLabel";
+//#endregion
+export { RadioGroupLabel };
+
+//# sourceMappingURL=radio-group-label.mjs.map

package/dist/radio-group/radio-group-label.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio-group-label.mjs","names":[],"sources":["../../src/radio-group/radio-group-label.tsx"],"sourcesContent":["\"use client\";\nimport type { ComponentPropsWithRef, CSSProperties, ReactNode } from \"react\";\nimport type { RenderProp, StateValue } from \"../internal/types.js\";\nimport { useRender } from \"../internal/use-render.js\";\nimport { useRadioGroupContext } from \"./radio-group-context.js\";\nimport type { RadioGroupRootState } from \"./radio-group-root.js\";\n\nexport interface RadioGroupLabelProps extends Omit<\n  ComponentPropsWithRef<\"legend\">,\n  \"className\" | \"style\" | \"children\"\n> {\n  className?: StateValue<string | undefined, RadioGroupRootState>;\n  style?: StateValue<CSSProperties | undefined, RadioGroupRootState>;\n  /** Receives the Root's state: a group-level pending indicator goes here. */\n  children?: StateValue<ReactNode, RadioGroupRootState>;\n  render?: RenderProp<ComponentPropsWithRef<\"legend\">, RadioGroupRootState>;\n}\n\n/**\n * The group's `<legend>`, which names the fieldset natively. Optional; must be the **first child**\n * of `RadioGroup.Root` (HTML content model). Its state is the Root's state. Owns no keys.\n */\nexport function RadioGroupLabel({\n  className,\n  style,\n  children,\n  render,\n  ...rest\n}: RadioGroupLabelProps) {\n  const ctx = useRadioGroupContext(\"RadioGroup.Label\");\n  const state: RadioGroupRootState = {\n    value: ctx.optimistic,\n    pending: ctx.pending,\n    disabled: ctx.disabled,\n  };\n  return useRender<ComponentPropsWithRef<\"legend\">, RadioGroupRootState>({\n    defaultElement: \"legend\",\n    render,\n    state,\n    className,\n    style,\n    children,\n    props: rest,\n  });\n}\n\nRadioGroupLabel.displayName = \"RadioGroupLabel\";\n"],"mappings":";;;;;;;;AAsBA,SAAgB,gBAAgB,EAC9B,WACA,OACA,UACA,QACA,GAAG,QACoB;CACvB,MAAM,MAAM,qBAAqB,kBAAkB;CACnD,MAAM,QAA6B;EACjC,OAAO,IAAI;EACX,SAAS,IAAI;EACb,UAAU,IAAI;CAChB;CACA,OAAO,UAAgE;EACrE,gBAAgB;EAChB;EACA;EACA;EACA;EACA;EACA,OAAO;CACT,CAAC;AACH;AAEA,gBAAgB,cAAc"}

package/dist/radio-group/radio-group-root.d.mts

@@ -0,0 +1,92 @@
+import { ActionDetails, ChangeAction, ChangeReason, RenderProp, StateValue } from "../internal/types.mjs";
+import { CSSProperties, ComponentPropsWithRef, ReactNode } from "react";
+//#region src/radio-group/radio-group-root.d.ts
+/** Details passed as the second argument of `valueChangeAction`. */
+export interface RadioGroupValueChangeDetails extends ActionDetails {
+  /**
+   * `"activate"`: the user checked a radio (click, Space, label click, or an arrow key, all of
+   * which arrive as a native `click`). `"platform"`: the browser changed the checked radio
+   * itself: a form reset (`details.event` is the `reset` event), or a click before hydration /
+   * Firefox form-state restoration found at mount (`details.event` is `undefined`).
+   */
+  readonly reason: ChangeReason;
+}
+export interface RadioGroupRootState {
+  /** Optimistic checked value, or `null`. Content rendered from it must not suspend. */
+  readonly value: string | null;
+  /** An action dispatched through this group is in flight. */
+  readonly pending: boolean;
+  /** The `disabled` prop. */
+  readonly disabled: boolean;
+}
+export interface RadioGroupRootProps extends Omit<ComponentPropsWithRef<"fieldset">, "className" | "style" | "children" | "defaultValue" | "defaultChecked" | "name" | "disabled" | "form"> {
+  /**
+   * Controlled checked value. `null` checks nothing; `undefined` means uncontrolled.
+   *
+   * A form reset returns each radio to the `checked` it had when *that radio* mounted (React sets
+   * `defaultChecked` once, from the initial `checked`). An Item added on the client while `value`
+   * equals its value therefore also gets `defaultChecked`, so two radios may carry it and the
+   * reset target is not necessarily the group's mount-time value. The reset is offered to
+   * `valueChangeAction` as usual; for a stable target remount the group with a `key` or use
+   * `defaultValue`, whose latest value every Item mirrors.
+   */
+  value?: string | null;
+  /**
+   * Initial value in uncontrolled mode. Defaults to `null` (nothing checked). Also the value a
+   * form reset returns to: the latest prop value is mirrored into the radios' `defaultChecked`.
+   */
+  defaultValue?: string | null;
+  /**
+   * Runs inside the Root's transition whenever the checked radio changes. May be sync or async
+   * (also a Server Function); rejections reach the nearest Error Boundary and roll the selection
+   * back.
+   *
+   * `next` is a string for every user interaction. It is `null` only with
+   * `details.reason === "platform"`, when a form reset returned the group to "nothing checked".
+   * Every arrow key press dispatches; the latest dispatch wins. A `setState` placed after your
+   * own `await` is not a Transition update; wrap it in `startTransition` (React limitation).
+   * `details.event.preventDefault()` is not a veto; use controlled mode to veto a change.
+   */
+  valueChangeAction?: ChangeAction<string | null, RadioGroupValueChangeDetails>;
+  /**
+   * The `name` shared by every radio in the group (form data key). Defaults to a `useId()` value;
+   * pass a real name when the group is inside a `<form>` you submit. Must be unique within the
+   * form: react-dom throws if a non-React radio shares it.
+   */
+  name?: string;
+  /** The `form` attribute, applied to the fieldset and to every radio. */
+  form?: string;
+  /**
+   * Marks every radio `required`, which makes the group required (one checked radio satisfies it),
+   * and renders `aria-required="true"` on the fieldset so the radiogroup itself is exposed as
+   * required.
+   */
+  required?: boolean;
+  /** Renders `<fieldset disabled>`: every radio is disabled, unfocusable and skipped by arrows. */
+  disabled?: boolean;
+  className?: StateValue<string | undefined, RadioGroupRootState>;
+  style?: StateValue<CSSProperties | undefined, RadioGroupRootState>;
+  children?: StateValue<ReactNode, RadioGroupRootState>;
+  /** Replace the rendered element. Must keep a `<fieldset>`. */
+  render?: RenderProp<ComponentPropsWithRef<"fieldset">, RadioGroupRootState>;
+}
+/**
+ * `<fieldset role="radiogroup">` that owns the group's state, the transition, the shared `name`,
+ * the form-reset listener and the mount reconciliation (design/components/radio-group.md 13.3).
+ * Carries `data-pending` while `valueChangeAction` is in flight.
+ *
+ * Owned keys (conventions 1.2): `role`, `aria-required`, `disabled`, `form`, `data-pending`,
+ * `data-disabled`.
+ *
+ * Keep every Item in the same Suspense boundary as its Root when server rendering. Partial
+ * hydration of a group (a boundary between Root and Items that stays dehydrated while the user
+ * interacts) is not supported by React: clicking a hydrated radio while same-`name` siblings are
+ * still dehydrated makes react-dom throw "Mixing React and non-React radio inputs with the same
+ * `name` is not supported". Development warns when Items hydrate after their Root.
+ */
+export declare function RadioGroupRoot({ value, defaultValue, valueChangeAction, name: nameProp, form, required, disabled, className, style, children, render, ...rest }: RadioGroupRootProps): import("react").JSX.Element;
+export declare namespace RadioGroupRoot {
+  var displayName: string;
+}
+//#endregion
+//# sourceMappingURL=radio-group-root.d.mts.map

package/dist/radio-group/radio-group-root.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio-group-root.d.mts","names":[],"sources":["../../src/radio-group/radio-group-root.tsx"],"mappings":";;;;iBAsBiB,qCAAqC;;;;;;;WAO3C,QAAQ;;iBAGF;;WAEN;;WAEA;;WAEA;;iBAGM,4BAA4B,KAC3C;;;;;;;;;;;EAoBA;;;;;EAKA;;;;;;;;;;;;EAYA,oBAAoB,4BAA4B;;;;;;EAMhD;;EAEA;;;;;;EAMA;;EAEA;EACA,YAAY,+BAA+B;EAC3C,QAAQ,WAAW,2BAA2B;EAC9C,WAAW,WAAW,WAAW;;EAEjC,SAAS,WAAW,mCAAmC;;;;;;;;;;;;;;;;wBAkCzC,iBACd,OACA,cACA,mBACA,MAAM,UACN,MACA,UACA,UACA,WACA,OACA,UACA,WACG,QACF,sCAAmB,IAAA;yBAbN"}

package/dist/radio-group/radio-group-root.mjs

@@ -0,0 +1,137 @@
+"use client";
+import { createActionDetails } from "../internal/action-details.mjs";
+import { dataAttr } from "../internal/data-attr.mjs";
+import { transitionTypes } from "../internal/transition-types.mjs";
+import { useControllableAction } from "../internal/use-controllable-action.mjs";
+import { useRender } from "../internal/use-render.mjs";
+import { RadioGroupContext } from "./radio-group-context.mjs";
+import { useNativeGroupReconciliation } from "../internal/use-native-group-reconciliation.mjs";
+import { useCallback, useId, useLayoutEffect, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/radio-group/radio-group-root.tsx
+const isDev = process.env.NODE_ENV !== "production";
+/**
+* Value of the group's checked radio as the DOM shows it (`prop: "checked"`) or as a form reset
+* leaves it (`prop: "defaultChecked"`), or `null`. Only radios of this group's `name` count, so a
+* nested group is ignored.
+*/
+function readGroup(fieldset, name, prop) {
+	if (fieldset === null) return null;
+	for (const radio of fieldset.querySelectorAll("input[type=\"radio\"]")) if (radio.name === name && radio[prop]) return radio.value;
+	return null;
+}
+/**
+* `<fieldset role="radiogroup">` that owns the group's state, the transition, the shared `name`,
+* the form-reset listener and the mount reconciliation (design/components/radio-group.md 13.3).
+* Carries `data-pending` while `valueChangeAction` is in flight.
+*
+* Owned keys (conventions 1.2): `role`, `aria-required`, `disabled`, `form`, `data-pending`,
+* `data-disabled`.
+*
+* Keep every Item in the same Suspense boundary as its Root when server rendering. Partial
+* hydration of a group (a boundary between Root and Items that stays dehydrated while the user
+* interacts) is not supported by React: clicking a hydrated radio while same-`name` siblings are
+* still dehydrated makes react-dom throw "Mixing React and non-React radio inputs with the same
+* `name` is not supported". Development warns when Items hydrate after their Root.
+*/
+function RadioGroupRoot({ value, defaultValue, valueChangeAction, name: nameProp, form, required = false, disabled = false, className, style, children, render, ...rest }) {
+	const fallbackName = useId();
+	const name = nameProp ?? fallbackName;
+	const fieldsetRef = useRef(null);
+	const warnedElement = useRef(false);
+	const { optimistic, pending, dispatch, latestInFlight } = useControllableAction({
+		controlled: value,
+		defaultValue,
+		initialValue: null,
+		action: valueChangeAction,
+		transitionTypes: () => transitionTypes("radio-group"),
+		warn: {
+			component: "RadioGroup.Root",
+			prop: "value"
+		}
+	});
+	/** What the user intends: the latest in-flight dispatch, else optimistic (conventions 3.8 rule 1). */
+	const base = () => {
+		const inFlight = latestInFlight();
+		return inFlight === null ? optimistic : inFlight.next;
+	};
+	const { onItemMounted } = useNativeGroupReconciliation({
+		element: fieldsetRef,
+		readCurrent: () => readGroup(fieldsetRef.current, name, "checked"),
+		readDefault: () => readGroup(fieldsetRef.current, name, "defaultChecked"),
+		base,
+		onPlatformChange: (next, event) => dispatch(next, createActionDetails(event, { reason: "platform" }))
+	});
+	const serverRadios = useRef(null);
+	const warnedPartialHydration = useRef(false);
+	useLayoutEffect(() => {
+		if (!isDev) return;
+		const el = fieldsetRef.current;
+		serverRadios.current = new Set(el === null ? [] : el.querySelectorAll("input[type=\"radio\"]"));
+		return () => {
+			serverRadios.current = null;
+		};
+	}, []);
+	const onItemMountedWithCheck = useCallback((element) => {
+		if (isDev && !warnedPartialHydration.current && element != null && serverRadios.current?.has(element) === true) {
+			warnedPartialHydration.current = true;
+			console.error("RadioGroup.Item: an Item hydrated after its RadioGroup.Root (a Suspense boundary between them). Partial hydration of a radio group is not supported by React: clicking a hydrated radio while same-name radios are still dehydrated makes react-dom throw \"Mixing React and non-React radio inputs with the same name is not supported\". Keep every Item in the same Suspense boundary as its Root.");
+		}
+		onItemMounted(element);
+	}, [onItemMounted]);
+	const libraryRef = useCallback((el) => {
+		fieldsetRef.current = el;
+		if (isDev && !warnedElement.current && el.tagName !== "FIELDSET") {
+			warnedElement.current = true;
+			console.error(`RadioGroup.Root: expected to render a <fieldset> element but got <${el.tagName.toLowerCase()}>. The platform semantics (legend naming, disabled inheritance, form reset) need a real <fieldset>.`);
+		}
+		return () => {
+			fieldsetRef.current = null;
+		};
+	}, []);
+	const context = {
+		name,
+		form,
+		required,
+		optimistic,
+		pending,
+		disabled,
+		defaultValue: value === void 0 ? defaultValue ?? null : void 0,
+		onItemMounted: onItemMountedWithCheck,
+		select: (next, event) => {
+			if (next === optimistic) return;
+			dispatch(next, createActionDetails(event, { reason: "activate" }));
+		}
+	};
+	const element = useRender({
+		defaultElement: "fieldset",
+		render,
+		state: {
+			value: optimistic,
+			pending,
+			disabled
+		},
+		className,
+		style,
+		children,
+		props: rest,
+		libraryProps: {
+			role: "radiogroup",
+			"aria-required": required ? "true" : void 0,
+			disabled,
+			form,
+			"data-pending": dataAttr(pending),
+			"data-disabled": dataAttr(disabled)
+		},
+		ref: libraryRef
+	});
+	return /* @__PURE__ */ jsx(RadioGroupContext, {
+		value: context,
+		children: element
+	});
+}
+RadioGroupRoot.displayName = "RadioGroupRoot";
+//#endregion
+export { RadioGroupRoot };
+
+//# sourceMappingURL=radio-group-root.mjs.map

package/dist/radio-group/radio-group-root.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio-group-root.mjs","names":[],"sources":["../../src/radio-group/radio-group-root.tsx"],"sourcesContent":["\"use client\";\nimport { useCallback, useId, useLayoutEffect, useRef } from \"react\";\nimport type { ComponentPropsWithRef, CSSProperties, ReactNode } from \"react\";\nimport { createActionDetails } from \"../internal/action-details.js\";\nimport { dataAttr } from \"../internal/data-attr.js\";\nimport { transitionTypes } from \"../internal/transition-types.js\";\nimport type {\n  ActionDetails,\n  ChangeAction,\n  ChangeReason,\n  RenderProp,\n  StateValue,\n} from \"../internal/types.js\";\nimport { useControllableAction } from \"../internal/use-controllable-action.js\";\nimport { useNativeGroupReconciliation } from \"../internal/use-native-group-reconciliation.js\";\nimport { useRender } from \"../internal/use-render.js\";\nimport { RadioGroupContext } from \"./radio-group-context.js\";\nimport type { RadioGroupContextValue } from \"./radio-group-context.js\";\n\nconst isDev = process.env.NODE_ENV !== \"production\";\n\n/** Details passed as the second argument of `valueChangeAction`. */\nexport interface RadioGroupValueChangeDetails extends ActionDetails {\n  /**\n   * `\"activate\"`: the user checked a radio (click, Space, label click, or an arrow key, all of\n   * which arrive as a native `click`). `\"platform\"`: the browser changed the checked radio\n   * itself: a form reset (`details.event` is the `reset` event), or a click before hydration /\n   * Firefox form-state restoration found at mount (`details.event` is `undefined`).\n   */\n  readonly reason: ChangeReason;\n}\n\nexport interface RadioGroupRootState {\n  /** Optimistic checked value, or `null`. Content rendered from it must not suspend. */\n  readonly value: string | null;\n  /** An action dispatched through this group is in flight. */\n  readonly pending: boolean;\n  /** The `disabled` prop. */\n  readonly disabled: boolean;\n}\n\nexport interface RadioGroupRootProps extends Omit<\n  ComponentPropsWithRef<\"fieldset\">,\n  | \"className\"\n  | \"style\"\n  | \"children\"\n  | \"defaultValue\"\n  | \"defaultChecked\"\n  | \"name\"\n  | \"disabled\"\n  | \"form\"\n> {\n  /**\n   * Controlled checked value. `null` checks nothing; `undefined` means uncontrolled.\n   *\n   * A form reset returns each radio to the `checked` it had when *that radio* mounted (React sets\n   * `defaultChecked` once, from the initial `checked`). An Item added on the client while `value`\n   * equals its value therefore also gets `defaultChecked`, so two radios may carry it and the\n   * reset target is not necessarily the group's mount-time value. The reset is offered to\n   * `valueChangeAction` as usual; for a stable target remount the group with a `key` or use\n   * `defaultValue`, whose latest value every Item mirrors.\n   */\n  value?: string | null;\n  /**\n   * Initial value in uncontrolled mode. Defaults to `null` (nothing checked). Also the value a\n   * form reset returns to: the latest prop value is mirrored into the radios' `defaultChecked`.\n   */\n  defaultValue?: string | null;\n  /**\n   * Runs inside the Root's transition whenever the checked radio changes. May be sync or async\n   * (also a Server Function); rejections reach the nearest Error Boundary and roll the selection\n   * back.\n   *\n   * `next` is a string for every user interaction. It is `null` only with\n   * `details.reason === \"platform\"`, when a form reset returned the group to \"nothing checked\".\n   * Every arrow key press dispatches; the latest dispatch wins. A `setState` placed after your\n   * own `await` is not a Transition update; wrap it in `startTransition` (React limitation).\n   * `details.event.preventDefault()` is not a veto; use controlled mode to veto a change.\n   */\n  valueChangeAction?: ChangeAction<string | null, RadioGroupValueChangeDetails>;\n  /**\n   * The `name` shared by every radio in the group (form data key). Defaults to a `useId()` value;\n   * pass a real name when the group is inside a `<form>` you submit. Must be unique within the\n   * form: react-dom throws if a non-React radio shares it.\n   */\n  name?: string;\n  /** The `form` attribute, applied to the fieldset and to every radio. */\n  form?: string;\n  /**\n   * Marks every radio `required`, which makes the group required (one checked radio satisfies it),\n   * and renders `aria-required=\"true\"` on the fieldset so the radiogroup itself is exposed as\n   * required.\n   */\n  required?: boolean;\n  /** Renders `<fieldset disabled>`: every radio is disabled, unfocusable and skipped by arrows. */\n  disabled?: boolean;\n  className?: StateValue<string | undefined, RadioGroupRootState>;\n  style?: StateValue<CSSProperties | undefined, RadioGroupRootState>;\n  children?: StateValue<ReactNode, RadioGroupRootState>;\n  /** Replace the rendered element. Must keep a `<fieldset>`. */\n  render?: RenderProp<ComponentPropsWithRef<\"fieldset\">, RadioGroupRootState>;\n}\n\n/**\n * Value of the group's checked radio as the DOM shows it (`prop: \"checked\"`) or as a form reset\n * leaves it (`prop: \"defaultChecked\"`), or `null`. Only radios of this group's `name` count, so a\n * nested group is ignored.\n */\nfunction readGroup(\n  fieldset: HTMLFieldSetElement | null,\n  name: string,\n  prop: \"checked\" | \"defaultChecked\",\n): string | null {\n  if (fieldset === null) return null;\n  for (const radio of fieldset.querySelectorAll<HTMLInputElement>('input[type=\"radio\"]')) {\n    if (radio.name === name && radio[prop]) return radio.value;\n  }\n  return null;\n}\n\n/**\n * `<fieldset role=\"radiogroup\">` that owns the group's state, the transition, the shared `name`,\n * the form-reset listener and the mount reconciliation (design/components/radio-group.md 13.3).\n * Carries `data-pending` while `valueChangeAction` is in flight.\n *\n * Owned keys (conventions 1.2): `role`, `aria-required`, `disabled`, `form`, `data-pending`,\n * `data-disabled`.\n *\n * Keep every Item in the same Suspense boundary as its Root when server rendering. Partial\n * hydration of a group (a boundary between Root and Items that stays dehydrated while the user\n * interacts) is not supported by React: clicking a hydrated radio while same-`name` siblings are\n * still dehydrated makes react-dom throw \"Mixing React and non-React radio inputs with the same\n * `name` is not supported\". Development warns when Items hydrate after their Root.\n */\nexport function RadioGroupRoot({\n  value,\n  defaultValue,\n  valueChangeAction,\n  name: nameProp,\n  form,\n  required = false,\n  disabled = false,\n  className,\n  style,\n  children,\n  render,\n  ...rest\n}: RadioGroupRootProps) {\n  const fallbackName = useId();\n  const name = nameProp ?? fallbackName;\n  const fieldsetRef = useRef<HTMLFieldSetElement | null>(null);\n  const warnedElement = useRef(false);\n\n  const { optimistic, pending, dispatch, latestInFlight } = useControllableAction<\n    string | null,\n    RadioGroupValueChangeDetails\n  >({\n    controlled: value,\n    defaultValue,\n    initialValue: null,\n    action: valueChangeAction,\n    transitionTypes: () => transitionTypes(\"radio-group\"),\n    warn: { component: \"RadioGroup.Root\", prop: \"value\" },\n  });\n  // Deliberately no warning when neither `value` nor `defaultValue` is given: an unchecked group\n  // is the HTML default (design decision 2).\n\n  /** What the user intends: the latest in-flight dispatch, else optimistic (conventions 3.8 rule 1). */\n  const base = (): string | null => {\n    const inFlight = latestInFlight();\n    // Not `?.next ?? optimistic`: an in-flight reset to `null` is a real intent.\n    return inFlight === null ? optimistic : inFlight.next;\n  };\n\n  // The residual browser paths (design section 5): one dispatch per group, from here. Items that\n  // mount after the Root report through `onItemMounted` so the group is reconciled again.\n  const { onItemMounted } = useNativeGroupReconciliation<string | null>({\n    element: fieldsetRef,\n    readCurrent: () => readGroup(fieldsetRef.current, name, \"checked\"),\n    readDefault: () => readGroup(fieldsetRef.current, name, \"defaultChecked\"),\n    base,\n    onPlatformChange: (next, event) =>\n      dispatch(next, createActionDetails(event, { reason: \"platform\" })),\n  });\n\n  // Dev-only partial-hydration detection. The radios present in the fieldset when the Root\n  // mounts are either mounted in the Root's commit or still dehydrated server HTML. An Item that\n  // mounts later on one of those elements hydrated after the Root (an Item created on the client\n  // gets a new element). Items of the Root's own commit run their mount effect before this one,\n  // while the snapshot is still `null`; StrictMode's re-run finds it reset by the cleanup.\n  const serverRadios = useRef<ReadonlySet<Element> | null>(null);\n  const warnedPartialHydration = useRef(false);\n  useLayoutEffect(() => {\n    if (!isDev) return;\n    const el = fieldsetRef.current;\n    serverRadios.current = new Set(el === null ? [] : el.querySelectorAll('input[type=\"radio\"]'));\n    return () => {\n      serverRadios.current = null;\n    };\n  }, []);\n  const onItemMountedWithCheck = useCallback(\n    (element?: Element | null) => {\n      if (\n        isDev &&\n        !warnedPartialHydration.current &&\n        element != null &&\n        serverRadios.current?.has(element) === true\n      ) {\n        warnedPartialHydration.current = true;\n        console.error(\n          `RadioGroup.Item: an Item hydrated after its RadioGroup.Root (a Suspense boundary ` +\n            `between them). Partial hydration of a radio group is not supported by React: ` +\n            `clicking a hydrated radio while same-name radios are still dehydrated makes ` +\n            `react-dom throw \"Mixing React and non-React radio inputs with the same name is not ` +\n            `supported\". Keep every Item in the same Suspense boundary as its Root.`,\n        );\n      }\n      onItemMounted(element);\n    },\n    [onItemMounted],\n  );\n\n  const libraryRef = useCallback((el: HTMLFieldSetElement) => {\n    fieldsetRef.current = el;\n    if (isDev && !warnedElement.current && el.tagName !== \"FIELDSET\") {\n      warnedElement.current = true;\n      console.error(\n        `RadioGroup.Root: expected to render a <fieldset> element but got ` +\n          `<${el.tagName.toLowerCase()}>. The platform semantics (legend naming, disabled ` +\n          `inheritance, form reset) need a real <fieldset>.`,\n      );\n    }\n    return () => {\n      fieldsetRef.current = null;\n    };\n  }, []);\n\n  const context: RadioGroupContextValue = {\n    name,\n    form,\n    required,\n    optimistic,\n    pending,\n    disabled,\n    defaultValue: value === undefined ? (defaultValue ?? null) : undefined,\n    onItemMounted: onItemMountedWithCheck,\n    select: (next, event) => {\n      // No-op rule against the optimistic value (conventions 2.3 item 7, design 4.2).\n      if (next === optimistic) return;\n      dispatch(next, createActionDetails(event, { reason: \"activate\" }));\n    },\n  };\n\n  const state: RadioGroupRootState = { value: optimistic, pending, disabled };\n\n  const element = useRender<ComponentPropsWithRef<\"fieldset\">, RadioGroupRootState>({\n    defaultElement: \"fieldset\",\n    render,\n    state,\n    className,\n    style,\n    children,\n    props: rest,\n    libraryProps: {\n      role: \"radiogroup\",\n      \"aria-required\": required ? \"true\" : undefined,\n      disabled,\n      form,\n      \"data-pending\": dataAttr(pending),\n      \"data-disabled\": dataAttr(disabled),\n    },\n    ref: libraryRef,\n  });\n\n  return <RadioGroupContext value={context}>{element}</RadioGroupContext>;\n}\n\nRadioGroupRoot.displayName = \"RadioGroupRoot\";\n"],"mappings":";;;;;;;;;;;AAmBA,MAAM,QAAQ,QAAQ,IAAI,aAAa;;;;;;AAyFvC,SAAS,UACP,UACA,MACA,MACe;CACf,IAAI,aAAa,MAAM,OAAO;CAC9B,KAAK,MAAM,SAAS,SAAS,iBAAmC,uBAAqB,GACnF,IAAI,MAAM,SAAS,QAAQ,MAAM,OAAO,OAAO,MAAM;CAEvD,OAAO;AACT;;;;;;;;;;;;;;;AAgBA,SAAgB,eAAe,EAC7B,OACA,cACA,mBACA,MAAM,UACN,MACA,WAAW,OACX,WAAW,OACX,WACA,OACA,UACA,QACA,GAAG,QACmB;CACtB,MAAM,eAAe,MAAM;CAC3B,MAAM,OAAO,YAAY;CACzB,MAAM,cAAc,OAAmC,IAAI;CAC3D,MAAM,gBAAgB,OAAO,KAAK;CAElC,MAAM,EAAE,YAAY,SAAS,UAAU,mBAAmB,sBAGxD;EACA,YAAY;EACZ;EACA,cAAc;EACd,QAAQ;EACR,uBAAuB,gBAAgB,aAAa;EACpD,MAAM;GAAE,WAAW;GAAmB,MAAM;EAAQ;CACtD,CAAC;;CAKD,MAAM,aAA4B;EAChC,MAAM,WAAW,eAAe;EAEhC,OAAO,aAAa,OAAO,aAAa,SAAS;CACnD;CAIA,MAAM,EAAE,kBAAkB,6BAA4C;EACpE,SAAS;EACT,mBAAmB,UAAU,YAAY,SAAS,MAAM,SAAS;EACjE,mBAAmB,UAAU,YAAY,SAAS,MAAM,gBAAgB;EACxE;EACA,mBAAmB,MAAM,UACvB,SAAS,MAAM,oBAAoB,OAAO,EAAE,QAAQ,WAAW,CAAC,CAAC;CACrE,CAAC;CAOD,MAAM,eAAe,OAAoC,IAAI;CAC7D,MAAM,yBAAyB,OAAO,KAAK;CAC3C,sBAAsB;EACpB,IAAI,CAAC,OAAO;EACZ,MAAM,KAAK,YAAY;EACvB,aAAa,UAAU,IAAI,IAAI,OAAO,OAAO,CAAC,IAAI,GAAG,iBAAiB,uBAAqB,CAAC;EAC5F,aAAa;GACX,aAAa,UAAU;EACzB;CACF,GAAG,CAAC,CAAC;CACL,MAAM,yBAAyB,aAC5B,YAA6B;EAC5B,IACE,SACA,CAAC,uBAAuB,WACxB,WAAW,QACX,aAAa,SAAS,IAAI,OAAO,MAAM,MACvC;GACA,uBAAuB,UAAU;GACjC,QAAQ,MACN,uYAKF;EACF;EACA,cAAc,OAAO;CACvB,GACA,CAAC,aAAa,CAChB;CAEA,MAAM,aAAa,aAAa,OAA4B;EAC1D,YAAY,UAAU;EACtB,IAAI,SAAS,CAAC,cAAc,WAAW,GAAG,YAAY,YAAY;GAChE,cAAc,UAAU;GACxB,QAAQ,MACN,qEACM,GAAG,QAAQ,YAAY,EAAE,oGAEjC;EACF;EACA,aAAa;GACX,YAAY,UAAU;EACxB;CACF,GAAG,CAAC,CAAC;CAEL,MAAM,UAAkC;EACtC;EACA;EACA;EACA;EACA;EACA;EACA,cAAc,UAAU,KAAA,IAAa,gBAAgB,OAAQ,KAAA;EAC7D,eAAe;EACf,SAAS,MAAM,UAAU;GAEvB,IAAI,SAAS,YAAY;GACzB,SAAS,MAAM,oBAAoB,OAAO,EAAE,QAAQ,WAAW,CAAC,CAAC;EACnE;CACF;CAIA,MAAM,UAAU,UAAkE;EAChF,gBAAgB;EAChB;EACA,OAAA;GALmC,OAAO;GAAY;GAAS;EAK3D;EACJ;EACA;EACA;EACA,OAAO;EACP,cAAc;GACZ,MAAM;GACN,iBAAiB,WAAW,SAAS,KAAA;GACrC;GACA;GACA,gBAAgB,SAAS,OAAO;GAChC,iBAAiB,SAAS,QAAQ;EACpC;EACA,KAAK;CACP,CAAC;CAED,OAAO,oBAAC,mBAAD;EAAmB,OAAO;EAAU,UAAA;CAA2B,CAAA;AACxE;AAEA,eAAe,cAAc"}

package/dist/switch/index.d.mts

@@ -0,0 +1,3 @@
+import "../internal/platform-attributes.mjs";
+import { Switch, SwitchCheckedChangeDetails, SwitchProps, SwitchState } from "./switch.mjs";
+export { Switch, type SwitchCheckedChangeDetails, type SwitchProps, type SwitchState };

package/dist/switch/index.mjs

@@ -0,0 +1 @@
+export { Switch } from "./switch.mjs";