@uniaria/react 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Andrey Yamanov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,51 @@
-# Temporary Holding Version
+# @uniaria/react
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The React adapter for UniAria: one generic hook, `useComponent`, binds any
+component definition from [`@uniaria/core`](https://www.npmjs.com/package/@uniaria/core)
+to your elements. React 18 or 19.
+
+> **Pre-release.** The API can change in any 0.x version.
+
+## Install
+
+```sh
+pnpm add @uniaria/core @uniaria/react
+```
+
+## Use
+
+Pass a definition and its props to `useComponent`, then spread each part's
+props onto your element:
+
+```tsx
+import { toggleSwitch } from '@uniaria/core/switch';
+import { useComponent } from '@uniaria/react';
+
+export function WifiSwitch() {
+  const wifi = useComponent(toggleSwitch, {
+    defaultSelected: true,
+    labelElementType: 'span',
+  });
+  return (
+    <label {...wifi.parts.root}>
+      <input {...wifi.parts.input} name="wifi" />
+      <span {...wifi.parts.indicator} />
+      <span {...wifi.parts.label}>Wi-Fi</span>
+    </label>
+  );
+}
+```
+
+Hovering, pressing or toggling doesn't render your component again: UniAria
+writes the new state straight to the elements. When your render needs a
+value, select it with `useComponentState`.
+
+## Documentation
+
+[Getting started](https://github.com/tenphi/uniaria/blob/main/docs/guide/getting-started.mdx)
+and every component's page are in the repository's
+[`docs`](https://github.com/tenphi/uniaria/tree/main/docs) folder.
+
+## License
+
+[MIT](https://github.com/tenphi/uniaria/blob/main/LICENSE)

package/dist/index.d.ts

@@ -0,0 +1,51 @@
+import { ReactNode } from "react";
+import { ActionsOf, AnyDefinition, Instance, ItemPartOf, PartOf, PropsOf, StateOf } from "@uniaria/core";
+//#region src/owner.d.ts
+interface Scope {
+  readonly instance: Instance;
+  readonly parent: Scope | null;
+}
+interface OwnerProviderProps<D extends AnyDefinition = AnyDefinition> {
+  /** The owner: an instance, or the handle `useComponent` returned. */
+  readonly owner: Instance<D> | {
+    readonly instance: Instance<D>;
+  };
+  readonly children?: ReactNode;
+}
+export declare function OwnerProvider<D extends AnyDefinition>({ owner, children }: OwnerProviderProps<D>): import("react").FunctionComponentElement<import("react").ProviderProps<Scope | null>>;
+//#endregion
+//#region src/use-component.d.ts
+/** Props to spread onto a part element: attributes, stable handlers, a ref. */
+type ReactPartProps = Readonly<Record<string, unknown>> & {
+  readonly ref: (element: Element | null) => void;
+};
+interface ComponentHandle<D extends AnyDefinition> {
+  /** The stable instance: pass it to `useComponentState` or as an `owner`. */
+  readonly instance: Instance<D>;
+  /** The component's public actions, such as a popover's `open()` and `close()`. */
+  readonly actions: ActionsOf<D>;
+  /** Props for each part, from this render. */
+  readonly parts: Readonly<Record<PartOf<D>, ReactPartProps>>;
+  /**
+   * Props for one item part of one item (Listbox spec, Item parts), from
+   * this render. Later changes reach the element through the binder, so the
+   * component rendering the rows doesn't render again for them. Item parts
+   * take no live DOM properties as React defaults.
+   */
+  getItemProps(part: ItemPartOf<D>, key: string): ReactPartProps;
+}
+/**
+ * Creates an instance of `definition` for this component and returns props
+ * for its parts. Props are stored silently during render and synced after
+ * commit; internal state changes never re-render this component.
+ */
+export declare function useComponent<D extends AnyDefinition>(definition: D, props: NoInfer<PropsOf<D>>): ComponentHandle<D>;
+/**
+ * Reads one value of an instance's public state and re-renders only when it
+ * changes (`Object.is`, or `isEqual`). Takes the instance or the handle
+ * `useComponent` returned.
+ */
+export declare function useComponentState<D extends AnyDefinition, T>(source: Instance<D> | ComponentHandle<D>, selector: (state: StateOf<D>) => T, isEqual?: (a: T, b: T) => boolean): T;
+//#endregion
+export type { ComponentHandle, OwnerProviderProps, ReactPartProps };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,444 @@
+"use client";
+import { createContext, createElement, useCallback, useContext, useEffect, useId, useInsertionEffect, useLayoutEffect, useMemo, useRef, useSyncExternalStore } from "react";
+import { createInstance, isOwnerDefinition } from "@uniaria/core";
+import { createBinder, isDevelopment, provideOwner, requestOwner, warn } from "@uniaria/core/dom";
+//#region src/owner.ts
+const OwnerContext = createContext(null);
+function OwnerProvider({ owner, children }) {
+	const parent = useContext(OwnerContext);
+	const instance = "instance" in owner ? owner.instance : owner;
+	const scope = useMemo(() => ({
+		instance,
+		parent
+	}), [instance, parent]);
+	return createElement(OwnerContext.Provider, { value: scope }, children);
+}
+/** The nearest owner of `definition` in the context, if any. */
+function findOwner(scope, definition) {
+	for (let current = scope; current; current = current.parent) if (current.instance.definition === definition) return current.instance;
+}
+//#endregion
+//#region src/props.ts
+/**
+* Neutral part props → React props (design decision 4): DOM attribute names
+* become React prop names, empty boolean attributes become `true`, and DOM
+* event names become React handler props.
+*/
+/** DOM attribute → React prop, where they differ. */
+const ATTRIBUTES = {
+	class: "className",
+	for: "htmlFor",
+	tabindex: "tabIndex",
+	readonly: "readOnly",
+	autofocus: "autoFocus",
+	autocomplete: "autoComplete",
+	autocorrect: "autoCorrect",
+	contenteditable: "contentEditable",
+	enterkeyhint: "enterKeyHint",
+	inputmode: "inputMode",
+	maxlength: "maxLength",
+	minlength: "minLength",
+	spellcheck: "spellCheck",
+	colspan: "colSpan",
+	rowspan: "rowSpan",
+	formaction: "formAction",
+	formenctype: "formEncType",
+	formmethod: "formMethod",
+	formnovalidate: "formNoValidate",
+	formtarget: "formTarget",
+	novalidate: "noValidate"
+};
+/** React props that take a boolean, so `''` must become `true`. */
+const BOOLEANS = /* @__PURE__ */ new Set([
+	"disabled",
+	"hidden",
+	"checked",
+	"selected",
+	"required",
+	"readOnly",
+	"multiple",
+	"open",
+	"inert",
+	"autoFocus",
+	"noValidate",
+	"formNoValidate"
+]);
+/** React's DOM event props; the map key is the DOM event name. */
+const EVENTS = new Map([
+	"onAnimationEnd",
+	"onAnimationIteration",
+	"onAnimationStart",
+	"onAuxClick",
+	"onBeforeInput",
+	"onBeforeToggle",
+	"onChange",
+	"onClick",
+	"onCompositionEnd",
+	"onCompositionStart",
+	"onCompositionUpdate",
+	"onContextMenu",
+	"onCopy",
+	"onCut",
+	"onDrag",
+	"onDragEnd",
+	"onDragEnter",
+	"onDragExit",
+	"onDragLeave",
+	"onDragOver",
+	"onDragStart",
+	"onDrop",
+	"onError",
+	"onGotPointerCapture",
+	"onInvalid",
+	"onKeyDown",
+	"onKeyUp",
+	"onLoad",
+	"onLostPointerCapture",
+	"onMouseDown",
+	"onMouseEnter",
+	"onMouseLeave",
+	"onMouseMove",
+	"onMouseOut",
+	"onMouseOver",
+	"onMouseUp",
+	"onPaste",
+	"onPointerCancel",
+	"onPointerDown",
+	"onPointerEnter",
+	"onPointerLeave",
+	"onPointerMove",
+	"onPointerOut",
+	"onPointerOver",
+	"onPointerUp",
+	"onReset",
+	"onScroll",
+	"onScrollEnd",
+	"onSelect",
+	"onSubmit",
+	"onToggle",
+	"onTouchCancel",
+	"onTouchEnd",
+	"onTouchMove",
+	"onTouchStart",
+	"onTransitionEnd",
+	"onWheel"
+].map((name) => [name.slice(2).toLowerCase(), name]));
+EVENTS.set("focusin", "onFocus");
+EVENTS.set("focusout", "onBlur");
+EVENTS.set("input", "onInput");
+EVENTS.set("dblclick", "onDoubleClick");
+/** The React prop for a DOM attribute. */
+function reactPropName(attribute) {
+	return ATTRIBUTES[attribute] ?? attribute;
+}
+/** The React value for an attribute value: `''` on a boolean prop is `true`. */
+function reactPropValue(name, value) {
+	return value === "" && BOOLEANS.has(name) ? true : value;
+}
+/** The React handler prop for a DOM event name. */
+function reactEventName(type) {
+	return EVENTS.get(type) ?? `on${type.charAt(0).toUpperCase()}${type.slice(1)}`;
+}
+//#endregion
+//#region src/use-component.ts
+/**
+* Live DOM properties React renders once as defaults, so it never controls
+* the element; the binder sets them after that.
+*/
+const DEFAULT_PROPS = {
+	value: "defaultValue",
+	checked: "defaultChecked"
+};
+/**
+* Instances whose new props `useComponent` is syncing after a commit. React's
+* `useSyncExternalStore` records the snapshot it rendered only in a passive
+* effect, so a notification from this layout-effect sync is compared with the
+* previous snapshot, and a component whose render already showed the new
+* props would render again with the same value.
+*/
+const syncing = /* @__PURE__ */ new WeakSet();
+const useIsomorphicLayoutEffect = typeof document === "undefined" ? useEffect : useLayoutEffect;
+/**
+* Warns when the element's attributes differ from the part props React just
+* rendered: the consumer wrote an attribute the binder owns, which the binder
+* would silently overwrite.
+*/
+function checkOwnership(internal, part, element, rendered = (internal.rendered?.connected)?.[part]) {
+	const isItem = internal.instance.definition.itemParts?.includes(part) ?? false;
+	for (const [name, value] of Object.entries(rendered?.attrs ?? {})) {
+		if (name === "id" && !isItem) continue;
+		const actual = element.getAttribute(name);
+		if (actual === (value ?? null)) continue;
+		warn(`${internal.instance.definition.name}: "${name}" on the ${part} part is written by UniAria, but the element has ${actual === null ? "none" : `"${actual}"`}. Pass it as a prop, or drop it from the JSX.`);
+	}
+}
+/**
+* A style property as React names it: custom properties as they are,
+* others in camelCase (`inset-block-start` → `insetBlockStart`).
+*/
+const reactStyleName = (name) => name.startsWith("--") ? name : name.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+/** Attributes and style as React props. */
+function toReactAttrs(props, result) {
+	for (const [name, value] of Object.entries(props.attrs)) {
+		if (value === void 0) continue;
+		const prop = reactPropName(name);
+		result[prop] = reactPropValue(prop, value);
+	}
+	if (props.style) {
+		const style = {};
+		for (const [name, value] of Object.entries(props.style)) if (value !== void 0) style[reactStyleName(name)] = value;
+		result.style = style;
+	}
+	return result;
+}
+/**
+* Hands the binder every item element attached or detached since the last
+* flush: in a microtask, or before the owner's layout effects when the
+* owner rendered in the same commit, so its instance starts and syncs with
+* its items attached.
+*/
+function flushAttaching(internal) {
+	if (internal.attaching.size === 0) return;
+	const list = Array.from(internal.attaching.values());
+	internal.attaching.clear();
+	internal.instance.batch(() => {
+		for (const { part, key, element } of list) internal.binder.attachItem(part, key, element);
+	});
+}
+/**
+* `getItemProps` for one instance: React props from the cached
+* `connectItem()`, reused while it returns the same object, with handlers
+* stable per part and event type and a ref stable per part and key.
+*/
+function createGetItemProps(internal) {
+	return (part, key) => {
+		const { instance, binder, itemHandlers, items } = internal();
+		const props = instance.connectItem(part, key);
+		const id = `${part}\n${key}`;
+		let item = items.get(id);
+		if (!item) {
+			const ref = (element) => {
+				const current = internal();
+				const entry = current.items.get(id);
+				if (element && isDevelopment() && !current.checked.has(element)) {
+					current.checked.add(element);
+					checkOwnership(current, part, element, entry?.rendered?.props);
+				}
+				const pending = current.attaching.get(id);
+				if (pending) pending.element = element;
+				else {
+					if (current.attaching.size === 0) queueMicrotask(() => flushAttaching(current));
+					current.attaching.set(id, {
+						part,
+						key,
+						element
+					});
+				}
+				if (!element && entry?.ref === ref) current.items.delete(id);
+			};
+			item = { ref };
+			items.set(id, item);
+		}
+		if (item.rendered?.props === props) return item.rendered.react;
+		const result = toReactAttrs(props, {});
+		for (const type of Object.keys(props.on ?? {})) {
+			const handlerKey = `${part}:${type}`;
+			let handler = itemHandlers.get(handlerKey);
+			if (!handler) {
+				handler = (event) => {
+					const target = binder.itemOf(event.currentTarget);
+					if (!target) return;
+					instance.connectItem(target.part, target.key).on?.[type]?.(event.nativeEvent);
+				};
+				itemHandlers.set(handlerKey, handler);
+			}
+			result[reactEventName(type)] = handler;
+		}
+		const react = {
+			...result,
+			ref: item.ref
+		};
+		item.rendered = {
+			props,
+			react
+		};
+		return react;
+	};
+}
+function toReactParts(internal, connected) {
+	const { instance, binder, handlers, refs, defaults } = internal;
+	const parts = {};
+	for (const [part, props] of Object.entries(connected)) {
+		const result = {};
+		let initial = defaults.get(part);
+		if (!initial) {
+			const first = {};
+			for (const [name, value] of Object.entries(props.properties ?? {})) {
+				const prop = DEFAULT_PROPS[name];
+				if (prop && value !== void 0) first[prop] = value;
+			}
+			initial = first;
+			defaults.set(part, initial);
+		}
+		Object.assign(result, initial);
+		toReactAttrs(props, result);
+		for (const type of Object.keys(props.on ?? {})) {
+			const key = `${part}:${type}`;
+			let handler = handlers.get(key);
+			if (!handler) {
+				handler = (event) => {
+					instance.connect()[part]?.on?.[type]?.(event.nativeEvent);
+				};
+				handlers.set(key, handler);
+			}
+			result[reactEventName(type)] = handler;
+		}
+		let ref = refs.get(part);
+		if (!ref) {
+			ref = (element) => {
+				if (element && isDevelopment() && !internal.checked.has(element)) {
+					internal.checked.add(element);
+					checkOwnership(internal, part, element);
+				}
+				binder.attach(part, element);
+			};
+			refs.set(part, ref);
+		}
+		parts[part] = {
+			...result,
+			ref
+		};
+	}
+	return parts;
+}
+/**
+* Creates an instance of `definition` for this component and returns props
+* for its parts. Props are stored silently during render and synced after
+* commit; internal state changes never re-render this component.
+*/
+function useComponent(definition, props) {
+	const id = useId();
+	const ref = useRef(null);
+	if (ref.current?.instance.definition !== definition) {
+		const instance = createInstance(definition, {
+			props,
+			id
+		});
+		ref.current = {
+			instance,
+			binder: createBinder(instance),
+			handlers: /* @__PURE__ */ new Map(),
+			refs: /* @__PURE__ */ new Map(),
+			itemHandlers: /* @__PURE__ */ new Map(),
+			items: /* @__PURE__ */ new Map(),
+			getItemProps: createGetItemProps(() => ref.current),
+			attaching: /* @__PURE__ */ new Map(),
+			defaults: /* @__PURE__ */ new Map(),
+			checked: /* @__PURE__ */ new WeakSet(),
+			isLinkedByContext: false
+		};
+	} else ref.current.instance.setProps(props);
+	const internal = ref.current;
+	const { instance, binder } = internal;
+	const scope = useContext(OwnerContext);
+	const ownerLink = definition.owner;
+	const contextOwner = ownerLink ? findOwner(scope, ownerLink.definition) : void 0;
+	if (contextOwner) {
+		instance.link(contextOwner);
+		internal.isLinkedByContext = true;
+	} else if (internal.isLinkedByContext) {
+		instance.link(void 0);
+		internal.isLinkedByContext = false;
+	}
+	const isLinkedByDom = ownerLink !== void 0 && contextOwner === void 0 && props.owner === void 0;
+	useIsomorphicLayoutEffect(() => {
+		flushAttaching(internal);
+		instance.batch(() => {
+			instance.start();
+			binder.start();
+		});
+		const unprovide = isOwnerDefinition(definition) ? definition.parts.flatMap((part) => {
+			const element = instance.element(part);
+			return element ? [provideOwner(instance, element)] : [];
+		}) : [];
+		return () => {
+			for (const stop of unprovide) stop();
+			binder.stop();
+			instance.stop();
+		};
+	}, [instance, binder]);
+	useIsomorphicLayoutEffect(() => {
+		if (!isLinkedByDom) return;
+		const element = definition.parts.map((part) => instance.element(part)).find(Boolean);
+		if (!element) return;
+		const forget = requestOwner(element, ownerLink.definition, (owner) => {
+			instance.link(owner);
+			instance.sync();
+		});
+		return () => {
+			forget();
+			instance.link(void 0);
+			instance.sync();
+		};
+	}, [instance, isLinkedByDom]);
+	useIsomorphicLayoutEffect(() => {
+		flushAttaching(internal);
+		syncing.add(instance);
+		try {
+			instance.sync();
+		} finally {
+			syncing.delete(instance);
+		}
+	});
+	const connected = instance.connect();
+	if (internal.rendered?.connected !== connected) internal.rendered = {
+		connected,
+		parts: toReactParts(internal, connected)
+	};
+	return {
+		instance,
+		actions: instance.actions,
+		parts: internal.rendered.parts,
+		getItemProps: internal.getItemProps
+	};
+}
+/**
+* Reads one value of an instance's public state and re-renders only when it
+* changes (`Object.is`, or `isEqual`). Takes the instance or the handle
+* `useComponent` returned.
+*/
+function useComponentState(source, selector, isEqual = Object.is) {
+	const instance = "instance" in source ? source.instance : source;
+	const cache = useRef(null);
+	const getSnapshot = () => {
+		const state = instance.getState();
+		const last = cache.current;
+		if (last?.state === state && last.selector === selector) return last.value;
+		const value = selector(state);
+		const stable = last && isEqual(last.value, value) ? last.value : value;
+		cache.current = {
+			state,
+			selector,
+			value: stable
+		};
+		return stable;
+	};
+	const committed = useRef(null);
+	const subscribe = useCallback((onChange) => instance.subscribe(() => {
+		const last = committed.current;
+		if (syncing.has(instance) && last && Object.is(last.value, last.getSnapshot())) return;
+		onChange();
+	}), [instance]);
+	const value = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+	useInsertionEffect(() => {
+		committed.current = {
+			value,
+			getSnapshot
+		};
+	});
+	return value;
+}
+//#endregion
+export { OwnerProvider, useComponent, useComponentState };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/owner.ts","../src/props.ts","../src/use-component.ts"],"sourcesContent":["/**\n * Owners in React (decision 11): `OwnerProvider` makes an instance the owner\n * of the UniAria components rendered inside it, through a React context that\n * holds only the stable instance, so it re-renders nothing. A component\n * finds its owner during render, which gives the first render and the server\n * HTML the owner's state. Contexts nest: each component takes the nearest\n * owner of the definition it names.\n */\n\nimport type { AnyDefinition, Instance } from '@uniaria/core';\nimport type { ReactNode } from 'react';\nimport { createContext, createElement, useContext, useMemo } from 'react';\n\ninterface Scope {\n  readonly instance: Instance;\n  readonly parent: Scope | null;\n}\n\nexport const OwnerContext = createContext<Scope | null>(null);\n\nexport interface OwnerProviderProps<D extends AnyDefinition = AnyDefinition> {\n  /** The owner: an instance, or the handle `useComponent` returned. */\n  readonly owner: Instance<D> | { readonly instance: Instance<D> };\n  readonly children?: ReactNode;\n}\n\n// Generic, since an `Instance<D>` isn't an `Instance`: its typed callback\n// props don't take `unknown`.\nexport function OwnerProvider<D extends AnyDefinition>({\n  owner,\n  children,\n}: OwnerProviderProps<D>) {\n  const parent = useContext(OwnerContext);\n  const instance = ('instance' in owner ? owner.instance : owner) as Instance;\n  const scope = useMemo(() => ({ instance, parent }), [instance, parent]);\n  return createElement(OwnerContext.Provider, { value: scope }, children);\n}\n\n/** The nearest owner of `definition` in the context, if any. */\nexport function findOwner(\n  scope: Scope | null,\n  definition: AnyDefinition,\n): Instance | undefined {\n  for (let current = scope; current; current = current.parent) {\n    if (current.instance.definition === definition) return current.instance;\n  }\n  return undefined;\n}\n","/**\n * Neutral part props → React props (design decision 4): DOM attribute names\n * become React prop names, empty boolean attributes become `true`, and DOM\n * event names become React handler props.\n */\n\n/** DOM attribute → React prop, where they differ. */\nconst ATTRIBUTES: Readonly<Record<string, string>> = {\n  class: 'className',\n  for: 'htmlFor',\n  tabindex: 'tabIndex',\n  readonly: 'readOnly',\n  autofocus: 'autoFocus',\n  autocomplete: 'autoComplete',\n  autocorrect: 'autoCorrect',\n  contenteditable: 'contentEditable',\n  enterkeyhint: 'enterKeyHint',\n  inputmode: 'inputMode',\n  maxlength: 'maxLength',\n  minlength: 'minLength',\n  spellcheck: 'spellCheck',\n  colspan: 'colSpan',\n  rowspan: 'rowSpan',\n  formaction: 'formAction',\n  formenctype: 'formEncType',\n  formmethod: 'formMethod',\n  formnovalidate: 'formNoValidate',\n  formtarget: 'formTarget',\n  novalidate: 'noValidate',\n};\n\n/** React props that take a boolean, so `''` must become `true`. */\nconst BOOLEANS = new Set([\n  'disabled',\n  'hidden',\n  'checked',\n  'selected',\n  'required',\n  'readOnly',\n  'multiple',\n  'open',\n  'inert',\n  'autoFocus',\n  'noValidate',\n  'formNoValidate',\n]);\n\n/** React's DOM event props; the map key is the DOM event name. */\nconst EVENTS = new Map(\n  [\n    'onAnimationEnd',\n    'onAnimationIteration',\n    'onAnimationStart',\n    'onAuxClick',\n    'onBeforeInput',\n    'onBeforeToggle',\n    'onChange',\n    'onClick',\n    'onCompositionEnd',\n    'onCompositionStart',\n    'onCompositionUpdate',\n    'onContextMenu',\n    'onCopy',\n    'onCut',\n    'onDrag',\n    'onDragEnd',\n    'onDragEnter',\n    'onDragExit',\n    'onDragLeave',\n    'onDragOver',\n    'onDragStart',\n    'onDrop',\n    'onError',\n    'onGotPointerCapture',\n    'onInvalid',\n    'onKeyDown',\n    'onKeyUp',\n    'onLoad',\n    'onLostPointerCapture',\n    'onMouseDown',\n    'onMouseEnter',\n    'onMouseLeave',\n    'onMouseMove',\n    'onMouseOut',\n    'onMouseOver',\n    'onMouseUp',\n    'onPaste',\n    'onPointerCancel',\n    'onPointerDown',\n    'onPointerEnter',\n    'onPointerLeave',\n    'onPointerMove',\n    'onPointerOut',\n    'onPointerOver',\n    'onPointerUp',\n    'onReset',\n    'onScroll',\n    'onScrollEnd',\n    'onSelect',\n    'onSubmit',\n    'onToggle',\n    'onTouchCancel',\n    'onTouchEnd',\n    'onTouchMove',\n    'onTouchStart',\n    'onTransitionEnd',\n    'onWheel',\n  ].map((name) => [name.slice(2).toLowerCase(), name]),\n);\n// Focus entering or leaving a subtree: React's onFocus and onBlur bubble and\n// are backed by focusin and focusout. The input event is React's onInput:\n// its onChange fires on click for a checkbox, before a cancelled click is\n// undone, and skips changes its value tracker missed.\nEVENTS.set('focusin', 'onFocus');\nEVENTS.set('focusout', 'onBlur');\nEVENTS.set('input', 'onInput');\nEVENTS.set('dblclick', 'onDoubleClick');\n\n/** The React prop for a DOM attribute. */\nexport function reactPropName(attribute: string): string {\n  return ATTRIBUTES[attribute] ?? attribute;\n}\n\n/** The React value for an attribute value: `''` on a boolean prop is `true`. */\nexport function reactPropValue(name: string, value: string): string | boolean {\n  return value === '' && BOOLEANS.has(name) ? true : value;\n}\n\n/** The React handler prop for a DOM event name. */\nexport function reactEventName(type: string): string {\n  return (\n    EVENTS.get(type) ?? `on${type.charAt(0).toUpperCase()}${type.slice(1)}`\n  );\n}\n","/**\n * The React adapter (design decisions 2 and 9). Internal state never\n * re-renders: each part renders once with its current props and a ref, and\n * the DOM binder from `@uniaria/core/dom` writes later changes straight to the\n * element. A component re-renders for state only through\n * `useComponentState`, and only when the selected value changes.\n */\n\nimport type {\n  ActionsOf,\n  AnyDefinition,\n  Instance,\n  ItemPartOf,\n  OwnerLink,\n  PartOf,\n  PartProps,\n  PropsOf,\n  StateOf,\n} from '@uniaria/core';\nimport { createInstance, isOwnerDefinition } from '@uniaria/core';\nimport type { Binder } from '@uniaria/core/dom';\nimport {\n  createBinder,\n  isDevelopment,\n  provideOwner,\n  requestOwner,\n  warn,\n} from '@uniaria/core/dom';\nimport type { SyntheticEvent } from 'react';\nimport {\n  useCallback,\n  useContext,\n  useEffect,\n  useId,\n  useInsertionEffect,\n  useLayoutEffect,\n  useRef,\n  useSyncExternalStore,\n} from 'react';\n\nimport { OwnerContext, findOwner } from './owner';\nimport { reactEventName, reactPropName, reactPropValue } from './props';\n\n/** Props to spread onto a part element: attributes, stable handlers, a ref. */\nexport type ReactPartProps = Readonly<Record<string, unknown>> & {\n  readonly ref: (element: Element | null) => void;\n};\n\nexport interface ComponentHandle<D extends AnyDefinition> {\n  /** The stable instance: pass it to `useComponentState` or as an `owner`. */\n  readonly instance: Instance<D>;\n  /** The component's public actions, such as a popover's `open()` and `close()`. */\n  readonly actions: ActionsOf<D>;\n  /** Props for each part, from this render. */\n  readonly parts: Readonly<Record<PartOf<D>, ReactPartProps>>;\n  /**\n   * Props for one item part of one item (Listbox spec, Item parts), from\n   * this render. Later changes reach the element through the binder, so the\n   * component rendering the rows doesn't render again for them. Item parts\n   * take no live DOM properties as React defaults.\n   */\n  getItemProps(part: ItemPartOf<D>, key: string): ReactPartProps;\n}\n\n/**\n * Live DOM properties React renders once as defaults, so it never controls\n * the element; the binder sets them after that.\n */\nconst DEFAULT_PROPS: Readonly<Record<string, string>> = {\n  value: 'defaultValue',\n  checked: 'defaultChecked',\n};\n\ninterface Internal<D extends AnyDefinition> {\n  readonly instance: Instance<D>;\n  readonly binder: Binder;\n  readonly handlers: Map<string, (event: SyntheticEvent) => void>;\n  readonly refs: Map<string, (element: Element | null) => void>;\n  /** Per item part and event type; the key comes from the element. */\n  readonly itemHandlers: Map<string, (event: SyntheticEvent) => void>;\n  /** Per item part and key: its ref, and the props it last rendered. */\n  readonly items: Map<\n    string,\n    {\n      readonly ref: (element: Element | null) => void;\n      rendered?: { readonly props: PartProps; readonly react: ReactPartProps };\n    }\n  >;\n  readonly getItemProps: (part: string, key: string) => ReactPartProps;\n  /**\n   * Item elements React attached or detached since the last flush, per part\n   * and key: each row has its own ref, so a commit that swaps a range of\n   * rows reaches the binder as one batch, in a microtask.\n   */\n  readonly attaching: Map<\n    string,\n    { readonly part: string; readonly key: string; element: Element | null }\n  >;\n  /** Default props from the first render, kept stable after it. */\n  readonly defaults: Map<string, Readonly<Record<string, unknown>>>;\n  /** Elements whose attributes were checked against the render. */\n  readonly checked: WeakSet<Element>;\n  /** Whether the instance's owner came from React context. */\n  isLinkedByContext: boolean;\n  rendered?: {\n    readonly connected: unknown;\n    readonly parts: Record<string, ReactPartProps>;\n  };\n}\n\n/**\n * Instances whose new props `useComponent` is syncing after a commit. React's\n * `useSyncExternalStore` records the snapshot it rendered only in a passive\n * effect, so a notification from this layout-effect sync is compared with the\n * previous snapshot, and a component whose render already showed the new\n * props would render again with the same value.\n */\nconst syncing = new WeakSet<object>();\n\n// Layout effects attach the binder before paint; on the server they never\n// run, and React 18 would warn about them.\nconst useIsomorphicLayoutEffect =\n  typeof document === 'undefined' ? useEffect : useLayoutEffect;\n\n/**\n * Warns when the element's attributes differ from the part props React just\n * rendered: the consumer wrote an attribute the binder owns, which the binder\n * would silently overwrite.\n */\nfunction checkOwnership<D extends AnyDefinition>(\n  internal: Internal<D>,\n  part: string,\n  element: Element,\n  rendered: PartProps | undefined = (\n    internal.rendered?.connected as\n      Readonly<Record<string, PartProps>> | undefined\n  )?.[part],\n): void {\n  // A named part keeps an id the JSX gives it after the spread, and the\n  // binder points every reference at it; an item's id is made from its key.\n  const isItem =\n    internal.instance.definition.itemParts?.includes(part) ?? false;\n  for (const [name, value] of Object.entries(rendered?.attrs ?? {})) {\n    if (name === 'id' && !isItem) continue;\n    const actual = element.getAttribute(name);\n    if (actual === (value ?? null)) continue;\n    warn(\n      `${internal.instance.definition.name}: \"${name}\" on the ${part} part is ` +\n        `written by UniAria, but the element has ${actual === null ? 'none' : `\"${actual}\"`}. ` +\n        'Pass it as a prop, or drop it from the JSX.',\n    );\n  }\n}\n\n/**\n * A style property as React names it: custom properties as they are,\n * others in camelCase (`inset-block-start` → `insetBlockStart`).\n */\nconst reactStyleName = (name: string): string =>\n  name.startsWith('--')\n    ? name\n    : name.replace(/-([a-z])/g, (_, letter: string) => letter.toUpperCase());\n\n/** Attributes and style as React props. */\nfunction toReactAttrs(\n  props: PartProps,\n  result: Record<string, unknown>,\n): Record<string, unknown> {\n  for (const [name, value] of Object.entries(props.attrs)) {\n    if (value === undefined) continue;\n    const prop = reactPropName(name);\n    result[prop] = reactPropValue(prop, value);\n  }\n  if (props.style) {\n    const style: Record<string, string> = {};\n    for (const [name, value] of Object.entries(props.style)) {\n      if (value !== undefined) style[reactStyleName(name)] = value;\n    }\n    result.style = style;\n  }\n  return result;\n}\n\n/**\n * Hands the binder every item element attached or detached since the last\n * flush: in a microtask, or before the owner's layout effects when the\n * owner rendered in the same commit, so its instance starts and syncs with\n * its items attached.\n */\nfunction flushAttaching<D extends AnyDefinition>(internal: Internal<D>): void {\n  if (internal.attaching.size === 0) return;\n  const list = Array.from(internal.attaching.values());\n  internal.attaching.clear();\n  internal.instance.batch(() => {\n    for (const { part, key, element } of list) {\n      internal.binder.attachItem(part, key, element);\n    }\n  });\n}\n\n/**\n * `getItemProps` for one instance: React props from the cached\n * `connectItem()`, reused while it returns the same object, with handlers\n * stable per part and event type and a ref stable per part and key.\n */\nfunction createGetItemProps<D extends AnyDefinition>(\n  internal: () => Internal<D>,\n): (part: string, key: string) => ReactPartProps {\n  return (part, key) => {\n    const { instance, binder, itemHandlers, items } = internal();\n    const props = instance.connectItem(part as never, key);\n    const id = `${part}\\n${key}`;\n    let item = items.get(id);\n    if (!item) {\n      const ref = (element: Element | null) => {\n        const current = internal();\n        const entry = current.items.get(id);\n        if (element && isDevelopment() && !current.checked.has(element)) {\n          current.checked.add(element);\n          checkOwnership(current, part, element, entry?.rendered?.props);\n        }\n        const pending = current.attaching.get(id);\n        if (pending) pending.element = element;\n        else {\n          if (current.attaching.size === 0) {\n            queueMicrotask(() => flushAttaching(current));\n          }\n          current.attaching.set(id, { part, key, element });\n        }\n        // An item that unmounts takes its cache with it; a remount gets a\n        // new ref.\n        if (!element && entry?.ref === ref) current.items.delete(id);\n      };\n      item = { ref };\n      items.set(id, item);\n    }\n    if (item.rendered?.props === props) return item.rendered.react;\n    const result = toReactAttrs(props, {});\n    for (const type of Object.keys(props.on ?? {})) {\n      const handlerKey = `${part}:${type}`;\n      let handler = itemHandlers.get(handlerKey);\n      if (!handler) {\n        handler = (event: SyntheticEvent) => {\n          const target = binder.itemOf(event.currentTarget as Element);\n          if (!target) return;\n          instance\n            .connectItem(target.part as never, target.key)\n            .on?.[type]?.(event.nativeEvent as never);\n        };\n        itemHandlers.set(handlerKey, handler);\n      }\n      result[reactEventName(type)] = handler;\n    }\n    const react = { ...result, ref: item.ref } as ReactPartProps;\n    item.rendered = { props, react };\n    return react;\n  };\n}\n\nfunction toReactParts<D extends AnyDefinition>(\n  internal: Internal<D>,\n  connected: Readonly<Record<string, PartProps>>,\n): Record<string, ReactPartProps> {\n  const { instance, binder, handlers, refs, defaults } = internal;\n  const parts: Record<string, ReactPartProps> = {};\n  for (const [part, props] of Object.entries(connected)) {\n    const result: Record<string, unknown> = {};\n    // From the first render only: a later default would reset the value\n    // attribute, which a form reset goes back to.\n    let initial = defaults.get(part);\n    if (!initial) {\n      const first: Record<string, unknown> = {};\n      for (const [name, value] of Object.entries(props.properties ?? {})) {\n        const prop = DEFAULT_PROPS[name];\n        if (prop && value !== undefined) first[prop] = value;\n      }\n      initial = first;\n      defaults.set(part, initial);\n    }\n    Object.assign(result, initial);\n    toReactAttrs(props, result);\n    // Handlers keep their identity across renders and call the handler from\n    // the latest connect() with the native event.\n    for (const type of Object.keys(props.on ?? {})) {\n      const key = `${part}:${type}`;\n      let handler = handlers.get(key);\n      if (!handler) {\n        handler = (event: SyntheticEvent) => {\n          const latest = instance.connect() as Readonly<\n            Record<string, PartProps>\n          >;\n          latest[part]?.on?.[type]?.(event.nativeEvent as never);\n        };\n        handlers.set(key, handler);\n      }\n      result[reactEventName(type)] = handler;\n    }\n    let ref = refs.get(part);\n    if (!ref) {\n      ref = (element: Element | null) => {\n        // Once per element: one attached again (StrictMode does) carries\n        // what the binder wrote since the render.\n        if (element && isDevelopment() && !internal.checked.has(element)) {\n          internal.checked.add(element);\n          checkOwnership(internal, part, element);\n        }\n        binder.attach(part, element);\n      };\n      refs.set(part, ref);\n    }\n    parts[part] = { ...result, ref };\n  }\n  return parts;\n}\n\n/**\n * Creates an instance of `definition` for this component and returns props\n * for its parts. Props are stored silently during render and synced after\n * commit; internal state changes never re-render this component.\n */\nexport function useComponent<D extends AnyDefinition>(\n  definition: D,\n  props: NoInfer<PropsOf<D>>,\n): ComponentHandle<D> {\n  const id = useId();\n  const ref = useRef<Internal<D> | null>(null);\n  if (ref.current?.instance.definition !== definition) {\n    const instance = createInstance(definition, { props, id });\n    ref.current = {\n      instance,\n      binder: createBinder(instance),\n      handlers: new Map(),\n      refs: new Map(),\n      itemHandlers: new Map(),\n      items: new Map(),\n      getItemProps: createGetItemProps(() => ref.current!),\n      attaching: new Map(),\n      defaults: new Map(),\n      checked: new WeakSet(),\n      isLinkedByContext: false,\n    };\n  } else {\n    ref.current.instance.setProps(props);\n  }\n  const internal = ref.current;\n  const { instance, binder } = internal;\n\n  // Decision 11: the `owner` prop, else React context during render (so the\n  // first render and SSR have it), else the DOM after mount.\n  const scope = useContext(OwnerContext);\n  const ownerLink = (definition as { owner?: OwnerLink }).owner;\n  const contextOwner = ownerLink\n    ? findOwner(scope, ownerLink.definition)\n    : undefined;\n  if (contextOwner) {\n    instance.link(contextOwner);\n    internal.isLinkedByContext = true;\n  } else if (internal.isLinkedByContext) {\n    instance.link(undefined);\n    internal.isLinkedByContext = false;\n  }\n  const isLinkedByDom =\n    ownerLink !== undefined &&\n    contextOwner === undefined &&\n    (props as { owner?: unknown }).owner === undefined;\n\n  useIsomorphicLayoutEffect(() => {\n    flushAttaching(internal);\n    // In one batch, so the start's element effects run once the binder has\n    // written the parts: an overlay open from the start is `data-entering`\n    // as it shows.\n    instance.batch(() => {\n      instance.start();\n      binder.start();\n    });\n    // Answers owner requests from custom elements and React components that\n    // find their owner through the DOM.\n    const unprovide = isOwnerDefinition(definition)\n      ? definition.parts.flatMap((part: string) => {\n          const element = instance.element(part as PartOf<D>);\n          return element\n            ? [\n                provideOwner(\n                  instance as unknown as Instance,\n                  element as Element,\n                ),\n              ]\n            : [];\n        })\n      : [];\n    return () => {\n      for (const stop of unprovide) stop();\n      binder.stop();\n      instance.stop();\n    };\n  }, [instance, binder]);\n\n  useIsomorphicLayoutEffect(() => {\n    if (!isLinkedByDom) return;\n    const element = definition.parts\n      .map((part: string) => instance.element(part as PartOf<D>))\n      .find(Boolean) as Element | undefined;\n    if (!element) return;\n    const forget = requestOwner(element, ownerLink!.definition, (owner) => {\n      instance.link(owner);\n      instance.sync();\n    });\n    return () => {\n      forget();\n      instance.link(undefined);\n      instance.sync();\n    };\n  }, [instance, isLinkedByDom]);\n\n  useIsomorphicLayoutEffect(() => {\n    flushAttaching(internal);\n    syncing.add(instance);\n    try {\n      instance.sync();\n    } finally {\n      syncing.delete(instance);\n    }\n  });\n\n  const connected = instance.connect();\n  if (internal.rendered?.connected !== connected) {\n    internal.rendered = {\n      connected,\n      parts: toReactParts(internal, connected),\n    };\n  }\n\n  return {\n    instance,\n    actions: instance.actions,\n    parts: internal.rendered.parts as ComponentHandle<D>['parts'],\n    getItemProps: internal.getItemProps as ComponentHandle<D>['getItemProps'],\n  };\n}\n\n/**\n * Reads one value of an instance's public state and re-renders only when it\n * changes (`Object.is`, or `isEqual`). Takes the instance or the handle\n * `useComponent` returned.\n */\nexport function useComponentState<D extends AnyDefinition, T>(\n  source: Instance<D> | ComponentHandle<D>,\n  selector: (state: StateOf<D>) => T,\n  isEqual: (a: T, b: T) => boolean = Object.is,\n): T {\n  const instance = 'instance' in source ? source.instance : source;\n  const cache = useRef<{\n    state: StateOf<D>;\n    selector: (state: StateOf<D>) => T;\n    value: T;\n  } | null>(null);\n\n  // The selected value is the snapshot, so it must be stable between\n  // changes: reuse it while the state object is the same, or while the new\n  // selection is equal to the last one.\n  const getSnapshot = (): T => {\n    const state = instance.getState();\n    const last = cache.current;\n    if (last?.state === state && last.selector === selector) return last.value;\n    const value = selector(state);\n    const stable = last && isEqual(last.value, value) ? last.value : value;\n    cache.current = { state, selector, value: stable };\n    return stable;\n  };\n\n  // The committed value and snapshot function. Insertion effects run before\n  // every layout effect, so they are current when `useComponent` syncs.\n  const committed = useRef<{ value: T; getSnapshot: () => T } | null>(null);\n\n  // Skips the notification from the prop sync after a commit when this hook\n  // already rendered the value it would bring (see `syncing`). A change the\n  // sync itself makes, such as hover ending on disable, still re-renders.\n  const subscribe = useCallback(\n    (onChange: () => void) =>\n      instance.subscribe(() => {\n        const last = committed.current;\n        if (\n          syncing.has(instance) &&\n          last &&\n          Object.is(last.value, last.getSnapshot())\n        ) {\n          return;\n        }\n        onChange();\n      }),\n    [instance],\n  );\n\n  const value = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n  useInsertionEffect(() => {\n    committed.current = { value, getSnapshot };\n  });\n  return value;\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,63 @@
 {
   "name": "@uniaria/react",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "React adapter for UniAria: one generic useComponent hook over any UniAria component definition",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "uniaria-source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tenphi/uniaria.git",
+    "directory": "packages/react"
+  },
+  "keywords": [
+    "headless",
+    "ui",
+    "react",
+    "accessibility",
+    "a11y",
+    "aria"
+  ],
+  "author": "Andrey Yamanov",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bugs": {
+    "url": "https://github.com/tenphi/uniaria/issues"
+  },
+  "homepage": "https://github.com/tenphi/uniaria#readme",
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@uniaria/core": "0.1.0"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0"
+  },
+  "devDependencies": {
+    "@uniaria/conformance": "0.0.0",
+    "@uniaria/testing": "0.1.0",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "react": "^19.3.0",
+    "react-aria": "^3.52.1",
+    "react-dom": "^19.3.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc -p tsconfig.json && tsc -p bench/tsconfig.json",
+    "bench": "node bench/run.ts"
+  }
 }