@uniaria/vue 0.0.0-stage → 0.2.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,52 @@
-# Temporary Holding Version
+# @uniaria/vue
 
-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 Vue adapter for UniAria: one generic composable, `useComponent`, binds any
+component definition from [`@uniaria/core`](https://www.npmjs.com/package/@uniaria/core)
+to your elements. Vue 3.5 or later.
+
+> **Pre-release.** The API can change in any 0.x version.
+
+## Install
+
+```sh
+pnpm add @uniaria/core @uniaria/vue
+```
+
+## Use
+
+Pass a definition and its props to `useComponent`, then bind each part's
+props onto your element with `v-bind`:
+
+```vue
+<script setup lang="ts">
+import { toggleSwitch } from '@uniaria/core/switch';
+import { useComponent } from '@uniaria/vue';
+
+const wifi = useComponent(toggleSwitch, {
+  defaultSelected: true,
+  labelElementType: 'span',
+});
+</script>
+
+<template>
+  <label v-bind="wifi.parts.root">
+    <input v-bind="wifi.parts.input" name="wifi" />
+    <span v-bind="wifi.parts.indicator" />
+    <span v-bind="wifi.parts.label">Wi-Fi</span>
+  </label>
+</template>
+```
+
+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://uniaria.tenphi.me/guide/getting-started/), the
+[Vue API](https://uniaria.tenphi.me/api/vue/) and every component's page are on
+[uniaria.tenphi.me](https://uniaria.tenphi.me).
+
+## License
+
+[MIT](https://github.com/tenphi/uniaria/blob/main/LICENSE)

package/dist/index.d.ts

@@ -0,0 +1,45 @@
+import { ActionsOf, AnyDefinition, Instance, ItemPartOf, PartOf, PropsOf, StateOf } from "@uniaria/core";
+import { MaybeRefOrGetter, Ref } from "vue";
+//#region src/use-component.d.ts
+/** Props to bind onto a part element: attributes, stable handlers, a ref. */
+type VuePartProps = Readonly<Record<string, unknown>> & {
+  readonly ref: (target: unknown) => 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, read when the render reads them. */
+  readonly parts: Readonly<Record<PartOf<D>, VuePartProps>>;
+  /**
+   * Props for one item part of one item (Listbox spec, Item parts), read
+   * when the render reads them. Later changes reach the element through the
+   * binder, so the component rendering the rows doesn't render again for
+   * them.
+   */
+  getItemProps(part: ItemPartOf<D>, key: string): VuePartProps;
+}
+/**
+ * What `useComponent` takes as props: a getter, a ref, a reactive object
+ * such as the component's own `defineProps()`, or a plain object read once.
+ */
+type ComponentProps<D extends AnyDefinition> = MaybeRefOrGetter<PropsOf<D>>;
+/**
+ * Creates an instance of `definition` for this component and returns props
+ * for its parts. Call it in `setup()`. Props are stored silently before the
+ * render reads them and synced after the patch; internal state changes
+ * never re-render this component.
+ */
+export declare function useComponent<D extends AnyDefinition>(definition: D, ...[props]: Partial<PropsOf<D>> extends PropsOf<D> ? [props?: NoInfer<ComponentProps<D>>] : [props: NoInfer<ComponentProps<D>>]): ComponentHandle<D>;
+//#endregion
+//#region src/use-component-state.d.ts
+/**
+ * Reads one value of an instance's public state as a ref that triggers only
+ * when the value 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): Readonly<Ref<T>>;
+//#endregion
+export type { ComponentHandle, ComponentProps, VuePartProps };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,383 @@
+import { createInstance, isOwnerDefinition } from "@uniaria/core";
+import { createBinder, isDevelopment, provideOwner, requestOwner, warn } from "@uniaria/core/dom";
+import { customRef, getCurrentInstance, getCurrentScope, inject, isProxy, isRef, markRaw, onActivated, onBeforeUnmount, onDeactivated, onMounted, onScopeDispose, provide, queuePostFlushCb, useId, watch } from "vue";
+//#region src/owner.ts
+/** Shared by duplicate installs, like the core's global singletons. */
+const OWNER_SCOPE = Symbol.for("@uniaria/vue owner");
+/**
+* The scope each component provides last. `inject()` reads the parent's
+* provides, so a second `useComponent` in one component chains onto the
+* first through this, not through `inject()`.
+*/
+const provided = /* @__PURE__ */ new WeakMap();
+/** The scope the current component's parent provides, if any. */
+function injectScope() {
+	return inject(OWNER_SCOPE, null);
+}
+/** Provides `instance` to the current component's descendants. */
+function provideScope(instance, parent) {
+	const component = getCurrentInstance();
+	const scope = {
+		instance,
+		parent: (component && provided.get(component)) ?? parent
+	};
+	if (component) provided.set(component, scope);
+	provide(OWNER_SCOPE, scope);
+}
+/** The nearest owner of `definition` in the scope, 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
+/**
+* Live DOM properties rendered once with Vue's attribute-only binding, so
+* the element starts with them and Vue never controls it after that.
+*/
+const LIVE_PROPS = {
+	value: "^value",
+	checked: "^checked"
+};
+/**
+* The Vue handler prop for a DOM event name: `keydown` → `onKeydown`. Vue
+* listens to the event named by the rest, lowercased, and DOM event names
+* have no capitals for it to split on.
+*/
+function vueEventName(type) {
+	return `on${type.charAt(0).toUpperCase()}${type.slice(1)}`;
+}
+/**
+* The attribute-only props for a part's live values, from the first render:
+* `^value` as a string, and `^checked` only while checked (its attribute
+* holds no value).
+*/
+function liveDefaults(props) {
+	const result = {};
+	for (const [name, value] of Object.entries(props.properties ?? {})) {
+		const prop = LIVE_PROPS[name];
+		if (!prop || value === void 0 || value === false) continue;
+		result[prop] = value === true ? "" : String(value);
+	}
+	return result;
+}
+/** Attributes and style as Vue props, leaving out what is `undefined`. */
+function toVueAttrs(props, result) {
+	for (const [name, value] of Object.entries(props.attrs)) if (value !== void 0) result[name] = value;
+	if (props.style) {
+		const style = {};
+		for (const [name, value] of Object.entries(props.style)) if (value !== void 0) style[name] = value;
+		result.style = style;
+	}
+	return result;
+}
+//#endregion
+//#region src/use-component.ts
+/**
+* The element a ref target stands for: the element, or for a component
+* bound as a part (a router link), its root element.
+*/
+function toElement(target) {
+	let node = target;
+	if (node && typeof node === "object" && "$el" in node) node = node.$el;
+	return node && typeof node === "object" && node.nodeType === 1 ? node : null;
+}
+/**
+* Warns when the element's attributes differ from the part props Vue
+* rendered: the template, or a parent's fallthrough attributes, wrote an
+* attribute the binder owns, which the binder would silently overwrite.
+*/
+function checkOwnership(internal, part, element, rendered) {
+	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 template.`);
+	}
+}
+/** Hands the binder every element Vue set or cleared since the last flush. */
+function flushAttaching(internal) {
+	if (internal.attaching.size === 0) return;
+	const list = Array.from(internal.attaching);
+	internal.attaching.clear();
+	internal.instance.batch(() => {
+		for (const [id, { part, key, element, rendered }] of list) {
+			if (element && isDevelopment() && !internal.checked.has(element)) {
+				internal.checked.add(element);
+				checkOwnership(internal, part, element, rendered);
+			}
+			internal.attached.set(id, element);
+			if (key === void 0) internal.binder.attach(part, element);
+			else internal.binder.attachItem(part, key, element);
+		}
+	});
+}
+/**
+* Records an element for the binder. Vue calls a ref again on every patch of
+* its element, so the same element again is a no-op.
+*/
+function queueAttaching(internal, id, entry) {
+	const pending = internal.attaching.get(id);
+	if (pending) {
+		pending.element = entry.element;
+		pending.rendered = entry.rendered;
+		return;
+	}
+	if (internal.attached.get(id) === entry.element) return;
+	if (internal.attaching.size === 0) queuePostFlushCb(internal.flush);
+	internal.attaching.set(id, entry);
+}
+/**
+* `getItemProps` for one instance: Vue 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 = (target) => {
+				const current = internal();
+				const element = toElement(target);
+				const entry = current.items.get(id);
+				queueAttaching(current, id, {
+					part,
+					key,
+					element,
+					rendered: entry?.rendered?.props
+				});
+				if (!element && entry?.ref === ref) current.items.delete(id);
+			};
+			item = { ref };
+			items.set(id, item);
+		}
+		if (item.rendered?.props === props) return item.rendered.vue;
+		const result = toVueAttrs(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);
+				};
+				itemHandlers.set(handlerKey, handler);
+			}
+			result[vueEventName(type)] = handler;
+		}
+		const vue = {
+			...result,
+			ref: item.ref
+		};
+		item.rendered = {
+			props,
+			vue
+		};
+		return vue;
+	};
+}
+function toVueParts(internal, connected) {
+	const { instance, handlers, refs, defaults } = internal;
+	const parts = {};
+	for (const [part, props] of Object.entries(connected)) {
+		let initial = defaults.get(part);
+		if (!initial) {
+			initial = liveDefaults(props);
+			defaults.set(part, initial);
+		}
+		const result = toVueAttrs(props, { ...initial });
+		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);
+				};
+				handlers.set(key, handler);
+			}
+			result[vueEventName(type)] = handler;
+		}
+		let ref = refs.get(part);
+		if (!ref) {
+			ref = (target) => queueAttaching(internal, part, {
+				part,
+				element: toElement(target),
+				rendered: (internal.rendered?.connected)?.[part]
+			});
+			refs.set(part, ref);
+		}
+		parts[part] = {
+			...result,
+			ref
+		};
+	}
+	return parts;
+}
+/** A getter for the props, whichever form they came in. */
+function propsReader(source) {
+	if (typeof source === "function") return source;
+	if (isRef(source)) return () => source.value;
+	if (isProxy(source)) return () => ({ ...source });
+	const props = source ?? {};
+	return () => props;
+}
+/**
+* Creates an instance of `definition` for this component and returns props
+* for its parts. Call it in `setup()`. Props are stored silently before the
+* render reads them and synced after the patch; internal state changes
+* never re-render this component.
+*/
+function useComponent(definition, ...[props]) {
+	const read = propsReader(props);
+	const instance = createInstance(definition, {
+		props: read(),
+		id: useId()
+	});
+	markRaw(instance);
+	const internal = {
+		instance,
+		binder: createBinder(instance),
+		handlers: /* @__PURE__ */ new Map(),
+		refs: /* @__PURE__ */ new Map(),
+		itemHandlers: /* @__PURE__ */ new Map(),
+		items: /* @__PURE__ */ new Map(),
+		getItemProps: createGetItemProps(() => internal),
+		attaching: /* @__PURE__ */ new Map(),
+		attached: /* @__PURE__ */ new Map(),
+		flush: () => flushAttaching(internal),
+		defaults: /* @__PURE__ */ new Map(),
+		checked: /* @__PURE__ */ new WeakSet()
+	};
+	const { binder } = internal;
+	const scope = injectScope();
+	const ownerLink = definition.owner;
+	const scopeOwner = ownerLink ? findOwner(scope, ownerLink.definition) : void 0;
+	if (scopeOwner) instance.link(scopeOwner);
+	provideScope(instance, scope);
+	let isRunning = false;
+	let lookup = null;
+	const isLinkedByDom = () => ownerLink !== void 0 && scopeOwner === void 0 && instance.getProps().owner === void 0;
+	const updateLookup = () => {
+		if (isLinkedByDom() === (lookup !== null)) return;
+		if (lookup) {
+			lookup();
+			lookup = null;
+			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();
+		});
+		lookup = () => {
+			forget();
+			instance.link(void 0);
+			instance.sync();
+		};
+	};
+	const sync = () => {
+		flushAttaching(internal);
+		instance.sync();
+		if (isRunning) updateLookup();
+	};
+	watch(read, (next) => {
+		instance.setProps(next);
+		queuePostFlushCb(sync);
+	}, { flush: "pre" });
+	let stop = null;
+	const begin = () => {
+		if (stop) return;
+		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)] : [];
+		}) : [];
+		isRunning = true;
+		updateLookup();
+		instance.sync();
+		stop = () => {
+			isRunning = false;
+			lookup?.();
+			lookup = null;
+			for (const forget of unprovide) forget();
+			binder.stop();
+			instance.stop();
+		};
+	};
+	const end = () => {
+		stop?.();
+		stop = null;
+	};
+	onMounted(begin);
+	onActivated(begin);
+	onDeactivated(end);
+	onBeforeUnmount(end);
+	return markRaw({
+		instance,
+		actions: instance.actions,
+		get parts() {
+			const connected = instance.connect();
+			if (internal.rendered?.connected !== connected) internal.rendered = {
+				connected,
+				parts: toVueParts(internal, connected)
+			};
+			return internal.rendered.parts;
+		},
+		getItemProps: internal.getItemProps
+	});
+}
+//#endregion
+//#region src/use-component-state.ts
+/**
+* Reads one value of an instance's public state as a ref that triggers only
+* when the value 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;
+	let cache = null;
+	const select = () => {
+		const state = instance.getState();
+		if (cache?.state === state) return cache.value;
+		const value = selector(state);
+		const stable = cache && isEqual(cache.value, value) ? cache.value : value;
+		cache = {
+			state,
+			value: stable
+		};
+		return stable;
+	};
+	return customRef((track, trigger) => {
+		let read = null;
+		if (typeof document !== "undefined") {
+			const unsubscribe = instance.subscribe(() => {
+				if (!read || !Object.is(read.value, select())) trigger();
+			});
+			if (getCurrentScope()) onScopeDispose(unsubscribe);
+		}
+		return {
+			get() {
+				track();
+				const value = select();
+				read = { value };
+				return value;
+			},
+			set() {
+				warn(`${instance.definition.name}: useComponentState returns a read-only ref.`);
+			}
+		};
+	});
+}
+//#endregion
+export { 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","../src/use-component-state.ts"],"sourcesContent":["/**\n * Owners in Vue (decision 11, Vue adapter spec: Owners and links): every\n * `useComponent` provides its instance to the component's descendants, slot\n * content included, through `provide()`, which holds only the stable\n * instance and renders nothing. A component finds its owner during setup,\n * so the first render and the server HTML have the owner's state. Scopes\n * nest: each component takes the nearest owner of the definition it names.\n */\n\nimport type { AnyDefinition, Instance } from '@uniaria/core';\nimport type { InjectionKey } from 'vue';\nimport { getCurrentInstance, inject, provide } from 'vue';\n\nexport interface Scope {\n  readonly instance: Instance;\n  readonly parent: Scope | null;\n}\n\n/** Shared by duplicate installs, like the core's global singletons. */\nexport const OWNER_SCOPE: InjectionKey<Scope | null> = Symbol.for(\n  '@uniaria/vue owner',\n) as InjectionKey<Scope | null>;\n\n/**\n * The scope each component provides last. `inject()` reads the parent's\n * provides, so a second `useComponent` in one component chains onto the\n * first through this, not through `inject()`.\n */\nconst provided = new WeakMap<object, Scope>();\n\n/** The scope the current component's parent provides, if any. */\nexport function injectScope(): Scope | null {\n  return inject(OWNER_SCOPE, null);\n}\n\n/** Provides `instance` to the current component's descendants. */\nexport function provideScope(instance: Instance, parent: Scope | null): void {\n  const component = getCurrentInstance();\n  const scope: Scope = {\n    instance,\n    parent: (component && provided.get(component)) ?? parent,\n  };\n  if (component) provided.set(component, scope);\n  provide(OWNER_SCOPE, scope);\n}\n\n/** The nearest owner of `definition` in the scope, 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 → Vue props (Vue adapter spec, Part props in Vue).\n * Vue's `v-bind` takes DOM names, so attributes and styles pass through as\n * they are, events become `on` and the capitalized DOM name, and live values\n * render once as attributes.\n */\n\nimport type { PartProps } from '@uniaria/core';\n\n/**\n * Live DOM properties rendered once with Vue's attribute-only binding, so\n * the element starts with them and Vue never controls it after that.\n */\nconst LIVE_PROPS: Readonly<Record<string, string>> = {\n  value: '^value',\n  checked: '^checked',\n};\n\n/**\n * The Vue handler prop for a DOM event name: `keydown` → `onKeydown`. Vue\n * listens to the event named by the rest, lowercased, and DOM event names\n * have no capitals for it to split on.\n */\nexport function vueEventName(type: string): string {\n  return `on${type.charAt(0).toUpperCase()}${type.slice(1)}`;\n}\n\n/**\n * The attribute-only props for a part's live values, from the first render:\n * `^value` as a string, and `^checked` only while checked (its attribute\n * holds no value).\n */\nexport function liveDefaults(props: PartProps): Record<string, unknown> {\n  const result: Record<string, unknown> = {};\n  for (const [name, value] of Object.entries(props.properties ?? {})) {\n    const prop = LIVE_PROPS[name];\n    if (!prop || value === undefined || value === false) continue;\n    result[prop] = value === true ? '' : String(value);\n  }\n  return result;\n}\n\n/** Attributes and style as Vue props, leaving out what is `undefined`. */\nexport function toVueAttrs(\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) result[name] = 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[name] = value;\n    }\n    result.style = style;\n  }\n  return result;\n}\n","/**\n * The Vue adapter (design decisions 2 and 9, Vue adapter spec). Internal\n * state never re-renders: each render reads the current part props, and the\n * DOM binder from `@uniaria/core/dom` writes later changes straight to the\n * elements. The store isn't reactive, so reading part props subscribes a\n * render to nothing; a component renders again 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} 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 { MaybeRefOrGetter } from 'vue';\nimport {\n  isProxy,\n  isRef,\n  markRaw,\n  onActivated,\n  onBeforeUnmount,\n  onDeactivated,\n  onMounted,\n  queuePostFlushCb,\n  useId,\n  watch,\n} from 'vue';\n\nimport { findOwner, injectScope, provideScope } from './owner';\nimport { liveDefaults, toVueAttrs, vueEventName } from './props';\n\n/** Props to bind onto a part element: attributes, stable handlers, a ref. */\nexport type VuePartProps = Readonly<Record<string, unknown>> & {\n  readonly ref: (target: unknown) => 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, read when the render reads them. */\n  readonly parts: Readonly<Record<PartOf<D>, VuePartProps>>;\n  /**\n   * Props for one item part of one item (Listbox spec, Item parts), read\n   * when the render reads them. Later changes reach the element through the\n   * binder, so the component rendering the rows doesn't render again for\n   * them.\n   */\n  getItemProps(part: ItemPartOf<D>, key: string): VuePartProps;\n}\n\n/**\n * What `useComponent` takes as props: a getter, a ref, a reactive object\n * such as the component's own `defineProps()`, or a plain object read once.\n */\nexport type ComponentProps<D extends AnyDefinition> = MaybeRefOrGetter<\n  PropsOf<D>\n>;\n\n/** An element the binder will get, and the part props it rendered with. */\ninterface Attaching {\n  readonly part: string;\n  /** An item part's key; none for a named part. */\n  readonly key?: string;\n  element: Element | null;\n  rendered: PartProps | undefined;\n}\n\ninterface Internal<D extends AnyDefinition> {\n  readonly instance: Instance<D>;\n  readonly binder: Binder;\n  readonly handlers: Map<string, (event: Event) => void>;\n  readonly refs: Map<string, (target: unknown) => void>;\n  /** Per item part and event type; the key comes from the element. */\n  readonly itemHandlers: Map<string, (event: Event) => 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: (target: unknown) => void;\n      rendered?: { readonly props: PartProps; readonly vue: VuePartProps };\n    }\n  >;\n  readonly getItemProps: (part: string, key: string) => VuePartProps;\n  /**\n   * Elements Vue set or cleared through a ref since the last flush, per\n   * part, or per item part and key. On first mount Vue calls a ref before\n   * the element is in the document, so the binder gets them only once the\n   * patch is done (Vue adapter spec, Refs).\n   */\n  readonly attaching: Map<string, Attaching>;\n  /** The element the binder has, per part, or per item part and key. */\n  readonly attached: Map<string, Element | null>;\n  /** Hands `attaching` to the binder; stable, so Vue queues it once. */\n  readonly flush: () => void;\n  /** Live values 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  rendered?: {\n    readonly connected: unknown;\n    readonly parts: Record<string, VuePartProps>;\n  };\n}\n\n/**\n * The element a ref target stands for: the element, or for a component\n * bound as a part (a router link), its root element.\n */\nfunction toElement(target: unknown): Element | null {\n  let node = target;\n  if (node && typeof node === 'object' && '$el' in node) node = node.$el;\n  return node && typeof node === 'object' && (node as Node).nodeType === 1\n    ? (node as Element)\n    : null;\n}\n\n/**\n * Warns when the element's attributes differ from the part props Vue\n * rendered: the template, or a parent's fallthrough attributes, wrote an\n * attribute the binder owns, which the binder would silently overwrite.\n */\nfunction checkOwnership<D extends AnyDefinition>(\n  internal: Internal<D>,\n  part: string,\n  element: Element,\n  rendered: PartProps | undefined,\n): void {\n  // A named part keeps an id the template gives it after `v-bind`, 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 template.',\n    );\n  }\n}\n\n/** Hands the binder every element Vue set or cleared since the last flush. */\nfunction flushAttaching<D extends AnyDefinition>(internal: Internal<D>): void {\n  if (internal.attaching.size === 0) return;\n  const list = Array.from(internal.attaching);\n  internal.attaching.clear();\n  internal.instance.batch(() => {\n    for (const [id, { part, key, element, rendered }] of list) {\n      if (element && isDevelopment() && !internal.checked.has(element)) {\n        internal.checked.add(element);\n        checkOwnership(internal, part, element, rendered);\n      }\n      internal.attached.set(id, element);\n      if (key === undefined) internal.binder.attach(part, element);\n      else internal.binder.attachItem(part, key, element);\n    }\n  });\n}\n\n/**\n * Records an element for the binder. Vue calls a ref again on every patch of\n * its element, so the same element again is a no-op.\n */\nfunction queueAttaching<D extends AnyDefinition>(\n  internal: Internal<D>,\n  id: string,\n  entry: Attaching,\n): void {\n  const pending = internal.attaching.get(id);\n  if (pending) {\n    pending.element = entry.element;\n    pending.rendered = entry.rendered;\n    return;\n  }\n  if (internal.attached.get(id) === entry.element) return;\n  if (internal.attaching.size === 0) queuePostFlushCb(internal.flush);\n  internal.attaching.set(id, entry);\n}\n\n/**\n * `getItemProps` for one instance: Vue 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) => VuePartProps {\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 = (target: unknown) => {\n        const current = internal();\n        const element = toElement(target);\n        const entry = current.items.get(id);\n        queueAttaching(current, id, {\n          part,\n          key,\n          element,\n          rendered: entry?.rendered?.props,\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.vue;\n    const result = toVueAttrs(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: Event) => {\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 as never);\n        };\n        itemHandlers.set(handlerKey, handler);\n      }\n      result[vueEventName(type)] = handler;\n    }\n    const vue = { ...result, ref: item.ref } as VuePartProps;\n    item.rendered = { props, vue };\n    return vue;\n  };\n}\n\nfunction toVueParts<D extends AnyDefinition>(\n  internal: Internal<D>,\n  connected: Readonly<Record<string, PartProps>>,\n): Record<string, VuePartProps> {\n  const { instance, handlers, refs, defaults } = internal;\n  const parts: Record<string, VuePartProps> = {};\n  for (const [part, props] of Object.entries(connected)) {\n    // From the first render only: a later one would reset the value\n    // attribute, which a form reset goes back to.\n    let initial = defaults.get(part);\n    if (!initial) {\n      initial = liveDefaults(props);\n      defaults.set(part, initial);\n    }\n    const result = toVueAttrs(props, { ...initial });\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: Event) => {\n          const latest = instance.connect() as Readonly<\n            Record<string, PartProps>\n          >;\n          latest[part]?.on?.[type]?.(event as never);\n        };\n        handlers.set(key, handler);\n      }\n      result[vueEventName(type)] = handler;\n    }\n    let ref = refs.get(part);\n    if (!ref) {\n      ref = (target: unknown) =>\n        queueAttaching(internal, part, {\n          part,\n          element: toElement(target),\n          rendered: (\n            internal.rendered?.connected as\n              Readonly<Record<string, PartProps>> | undefined\n          )?.[part],\n        });\n      refs.set(part, ref);\n    }\n    parts[part] = { ...result, ref } as VuePartProps;\n  }\n  return parts;\n}\n\n/** A getter for the props, whichever form they came in. */\nfunction propsReader<P>(source: MaybeRefOrGetter<P> | undefined): () => P {\n  if (typeof source === 'function') return source as () => P;\n  if (isRef(source)) return () => source.value;\n  // A reactive object, such as `defineProps()`: spreading it reads, and so\n  // tracks, every key.\n  if (isProxy(source)) return () => ({ ...source }) as P;\n  const props = (source ?? {}) as P;\n  return () => props;\n}\n\n/**\n * Creates an instance of `definition` for this component and returns props\n * for its parts. Call it in `setup()`. Props are stored silently before the\n * render reads them and synced after the patch; internal state changes\n * never re-render this component.\n */\nexport function useComponent<D extends AnyDefinition>(\n  definition: D,\n  // Optional when every prop is.\n  ...[props]: Partial<PropsOf<D>> extends PropsOf<D>\n    ? [props?: NoInfer<ComponentProps<D>>]\n    : [props: NoInfer<ComponentProps<D>>]\n): ComponentHandle<D> {\n  const read = propsReader(props);\n  const instance = createInstance(definition, { props: read(), id: useId() });\n  markRaw(instance);\n  const internal: Internal<D> = {\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(() => internal),\n    attaching: new Map(),\n    attached: new Map(),\n    flush: () => flushAttaching(internal),\n    defaults: new Map(),\n    checked: new WeakSet(),\n  };\n  const { binder } = internal;\n\n  // Decision 11: the `owner` prop, else the nearest provided owner during\n  // setup (so the first render and the server HTML have it), else the DOM\n  // after mount.\n  const scope = injectScope();\n  const ownerLink = (definition as { owner?: OwnerLink }).owner;\n  const scopeOwner = ownerLink\n    ? findOwner(scope, ownerLink.definition)\n    : undefined;\n  if (scopeOwner) instance.link(scopeOwner);\n  provideScope(instance as unknown as Instance, scope);\n\n  let isRunning = false;\n  let lookup: (() => void) | null = null;\n  const isLinkedByDom = () =>\n    ownerLink !== undefined &&\n    scopeOwner === undefined &&\n    (instance.getProps() as { owner?: unknown }).owner === undefined;\n  // Looks for the owner through the DOM while neither the `owner` prop nor\n  // a provided owner gives one.\n  const updateLookup = () => {\n    if (isLinkedByDom() === (lookup !== null)) return;\n    if (lookup) {\n      lookup();\n      lookup = null;\n      return;\n    }\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    lookup = () => {\n      forget();\n      instance.link(undefined);\n      instance.sync();\n    };\n  };\n\n  const sync = () => {\n    flushAttaching(internal);\n    instance.sync();\n    if (isRunning) updateLookup();\n  };\n  watch(\n    read,\n    (next) => {\n      instance.setProps(next);\n      queuePostFlushCb(sync);\n    },\n    { flush: 'pre' },\n  );\n\n  let stop: (() => void) | null = null;\n  const begin = () => {\n    if (stop) return;\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 components that find\n    // 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    isRunning = true;\n    updateLookup();\n    instance.sync();\n    stop = () => {\n      isRunning = false;\n      lookup?.();\n      lookup = null;\n      for (const forget of unprovide) forget();\n      binder.stop();\n      instance.stop();\n    };\n  };\n  const end = () => {\n    stop?.();\n    stop = null;\n  };\n  onMounted(begin);\n  onActivated(begin);\n  onDeactivated(end);\n  onBeforeUnmount(end);\n\n  return markRaw({\n    instance,\n    actions: instance.actions,\n    get parts() {\n      const connected = instance.connect();\n      if (internal.rendered?.connected !== connected) {\n        internal.rendered = {\n          connected,\n          parts: toVueParts(internal, connected),\n        };\n      }\n      return internal.rendered.parts as ComponentHandle<D>['parts'];\n    },\n    getItemProps: internal.getItemProps as ComponentHandle<D>['getItemProps'],\n  });\n}\n","/**\n * `useComponentState` (Vue adapter spec): one selected value of an\n * instance's public state as a read-only ref. The ref reads the state when\n * it is read, so a render after a prop change already shows the new value,\n * and it triggers only when the store's notification changes the value a\n * render last read.\n */\n\nimport type { AnyDefinition, Instance, StateOf } from '@uniaria/core';\nimport { warn } from '@uniaria/core/dom';\nimport type { Ref } from 'vue';\nimport { customRef, getCurrentScope, onScopeDispose } from 'vue';\n\nimport type { ComponentHandle } from './use-component';\n\n/**\n * Reads one value of an instance's public state as a ref that triggers only\n * when the value changes (`Object.is`, or `isEqual`). Takes the instance or\n * the handle `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): Readonly<Ref<T>> {\n  const instance = 'instance' in source ? source.instance : source;\n  let cache: { readonly state: StateOf<D>; readonly value: T } | null = null;\n\n  // The selection stays the same object while the state object is, or while\n  // the new selection is equal to the last one.\n  const select = (): T => {\n    const state = instance.getState();\n    if (cache?.state === state) return cache.value;\n    const value = selector(state);\n    const stable = cache && isEqual(cache.value, value) ? cache.value : value;\n    cache = { state, value: stable };\n    return stable;\n  };\n\n  return customRef<T>((track, trigger) => {\n    // The value a reader last got; a notification that brings the same one\n    // (the sync after a prop change the render already showed) stays quiet.\n    let read: { readonly value: T } | null = null;\n    // Never on the server, where nothing would unsubscribe.\n    if (typeof document !== 'undefined') {\n      const unsubscribe = instance.subscribe(() => {\n        if (!read || !Object.is(read.value, select())) trigger();\n      });\n      if (getCurrentScope()) onScopeDispose(unsubscribe);\n    }\n    return {\n      get() {\n        track();\n        const value = select();\n        read = { value };\n        return value;\n      },\n      set() {\n        warn(\n          `${instance.definition.name}: useComponentState returns a read-only ref.`,\n        );\n      },\n    };\n  });\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,59 @@
 {
   "name": "@uniaria/vue",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.0",
+  "description": "Vue adapter for UniAria: one generic useComponent composable 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/vue"
+  },
+  "keywords": [
+    "headless",
+    "ui",
+    "vue",
+    "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.2.0"
+  },
+  "peerDependencies": {
+    "vue": "^3.5.0"
+  },
+  "devDependencies": {
+    "@uniaria/conformance": "0.0.0",
+    "@uniaria/elements": "0.2.0",
+    "@uniaria/testing": "0.2.0",
+    "vue": "^3.5.43"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc -p tsconfig.json"
+  }
 }