@vizejs/ui 0.347.7 → 0.351.0

package/dist/{checkbox-B4y9GUen.mjs → checkbox-BgIvwjyC.mjs}

@@ -1,5 +1,5 @@
 import { useControllableState } from "./controllable-state.mjs";
-import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BVN2DL-U.mjs";
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BOaGB7Aw.mjs";
 import { computed, createElementBlock, defineComponent, nextTick, openBlock, unref, useTemplateRef, watch, watchEffect } from "vue";
 //#region src/checkbox-state.ts
 /** Resolve the visual state while giving the mixed state precedence. */
@@ -18,7 +18,7 @@ const _hoisted_1 = [
 ];
 //#endregion
 //#region src/CheckboxControl.vue
-var CheckboxControl_default = /* @__PURE__ */ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+var CheckboxControl_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
 	__name: "CheckboxControl",
 	props: {
 		modelValue: {

package/dist/{checkbox-sbhaWekB.d.mts → checkbox-DP3_ko7D.d.mts}

@@ -1,5 +1,4 @@
-import { r as StateUpdate } from "./controllable-state-B9v6FClp.mjs";
-import * as _$vue from "vue";
+import { r as StateUpdate } from "./controllable-state-BtoxKahh.mjs";
 
 //#region src/checkbox-state.d.ts
 /** Visual state exposed by the Checkbox Native CSS contract. */
@@ -42,21 +41,21 @@ type __VLS_Props = {
 };
 /** Move focus to the native checkbox. */
 declare function focus(options?: FocusOptions): void;
-declare const __VLS_export: _$vue.DefineComponent<__VLS_Props, {
-  element: Readonly<_$vue.ShallowRef<HTMLInputElement | null>>;
-  checked: _$vue.ComputedRef<boolean>;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
+  element: Readonly<import("vue").ShallowRef<HTMLInputElement | null>>;
+  checked: import("vue").ComputedRef<boolean>;
   focus: typeof focus;
   reset: () => boolean;
   setChecked: (update: StateUpdate<boolean>) => boolean;
-}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
   "update:modelValue": (value: boolean) => any;
   "update:indeterminate": (value: boolean) => any;
   change: (value: boolean, nativeEvent: Event) => any;
-}, string, _$vue.PublicProps, Readonly<__VLS_Props> & Readonly<{
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
   "onUpdate:modelValue"?: (value: boolean) => any;
   "onUpdate:indeterminate"?: (value: boolean) => any;
   onChange?: (value: boolean, nativeEvent: Event) => any;
-}>, {}, {}, {}, {}, string, _$vue.ComponentProvideOptions, false, {}, any>;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 //#endregion
 export { CheckboxState as n, getCheckboxState as r, _default as t };

package/dist/checkbox.d.mts

@@ -1,2 +1,2 @@
-import { n as CheckboxState, r as getCheckboxState, t as _default } from "./checkbox-sbhaWekB.mjs";
+import { n as CheckboxState, r as getCheckboxState, t as _default } from "./checkbox-DP3_ko7D.mjs";
 export { _default as Checkbox, CheckboxState, getCheckboxState };

package/dist/checkbox.mjs

@@ -1,2 +1,2 @@
-import { n as getCheckboxState, t as CheckboxControl_default } from "./checkbox-B4y9GUen.mjs";
+import { n as getCheckboxState, t as CheckboxControl_default } from "./checkbox-BgIvwjyC.mjs";
 export { CheckboxControl_default as Checkbox, getCheckboxState };

package/dist/collection.d.mts

@@ -1,2 +1,2 @@
-import { a as CollectionActiveChangeReason, c as CollectionItemInput, d as CollectionNavigationOptions, f as CollectionRegistration, h as CollectionTextSearchOptions, i as CollectionActiveChange, l as CollectionKey, m as CollectionRegistryOptions, n as normalizeCollectionTextValue, o as CollectionDisabledBehavior, p as CollectionRegistry, r as createCollectionRegistry, s as CollectionItem, t as extractCollectionTextValue, u as CollectionNavigationDirection } from "./collection-aHZ6Pf0e.mjs";
-export { CollectionActiveChange, CollectionActiveChangeReason, CollectionDisabledBehavior, CollectionItem, CollectionItemInput, CollectionKey, CollectionNavigationDirection, CollectionNavigationOptions, CollectionRegistration, CollectionRegistry, CollectionRegistryOptions, CollectionTextSearchOptions, createCollectionRegistry, extractCollectionTextValue, normalizeCollectionTextValue };
+import { a as CollectionActiveChangeReason, c as CollectionItemInput, d as CollectionNavigationOptions, f as CollectionRegistration, h as CollectionTextSearchOptions, i as CollectionActiveChange, l as CollectionKey, m as CollectionRegistryOptions, n as normalizeCollectionTextValue, o as CollectionDisabledBehavior, p as CollectionRegistry, r as createCollectionRegistry, s as CollectionItem, t as extractCollectionTextValue, u as CollectionNavigationDirection } from "./collection-B_dFZOHO.mjs";
+export { type CollectionActiveChange, type CollectionActiveChangeReason, type CollectionDisabledBehavior, type CollectionItem, type CollectionItemInput, type CollectionKey, type CollectionNavigationDirection, type CollectionNavigationOptions, type CollectionRegistration, type CollectionRegistry, type CollectionRegistryOptions, type CollectionTextSearchOptions, createCollectionRegistry, extractCollectionTextValue, normalizeCollectionTextValue };

package/dist/collection.mjs

@@ -1,2 +1,2 @@
-import { n as extractCollectionTextValue, r as normalizeCollectionTextValue, t as createCollectionRegistry } from "./collection-CoOROaho.mjs";
+import { n as extractCollectionTextValue, r as normalizeCollectionTextValue, t as createCollectionRegistry } from "./collection-eHN150dT.mjs";
 export { createCollectionRegistry, extractCollectionTextValue, normalizeCollectionTextValue };

package/dist/composite-navigation-QINW9GLy.d.mts

@@ -0,0 +1,115 @@
+import { l as CollectionKey, p as CollectionRegistry, s as CollectionItem } from "./collection-B_dFZOHO.mjs";
+import { a as TypeaheadOptions, r as TypeaheadController } from "./typeahead-BbgUB2Bj.mjs";
+import { ComputedRef, MaybeRefOrGetter } from "vue";
+
+//#region src/composite-navigation-types.d.ts
+/** Physical axes recognized by composite arrow-key navigation. */
+type CompositeOrientation = "both" | "horizontal" | "vertical";
+/** Reading direction used to map horizontal arrows. */
+type CompositeDirection = "ltr" | "rtl";
+/** DOM focus-management strategy described by the WAI-ARIA APG. */
+type CompositeFocusStrategy = "active-descendant" | "roving";
+/** Logical movement requested from a composite controller. */
+type CompositeNavigationIntent = "first" | "focus" | "last" | "next" | "page-next" | "page-previous" | "pointer" | "previous" | "typeahead";
+/** Imperative and keyboard movement commands accepted by `navigate`. */
+type CompositeNavigationCommand = Exclude<CompositeNavigationIntent, "focus" | "pointer" | "typeahead">;
+/** Immutable snapshot published after logical active state changes. */
+interface CompositeNavigationChange<Key extends CollectionKey> {
+  /** Newly active item. */
+  readonly key: Key;
+  /** Active item before navigation. */
+  readonly previousKey: Key | null;
+  /** Navigation operation that selected this item. */
+  readonly intent: CompositeNavigationIntent;
+  /** Native event responsible for navigation, or `null` for imperative calls. */
+  readonly originalEvent: Event | null;
+  /** Focus-management strategy used while synchronizing the DOM. */
+  readonly focusStrategy: CompositeFocusStrategy;
+}
+/** Shared options for both composite focus-management strategies. */
+interface CompositeNavigationBaseOptions<Key extends CollectionKey, Value> {
+  /** Ordered, mutation-aware logical item registry. */
+  readonly registry: CollectionRegistry<Key, Value>;
+  /**
+   * Arrow-key axes recognized by this composite.
+   *
+   * @default "vertical"
+   */
+  readonly orientation?: MaybeRefOrGetter<CompositeOrientation | undefined>;
+  /**
+   * Reading direction used by horizontal arrows.
+   *
+   * @default "ltr"
+   */
+  readonly direction?: MaybeRefOrGetter<CompositeDirection | undefined>;
+  /** Wrap arrow navigation at collection boundaries. */
+  readonly loop?: MaybeRefOrGetter<boolean | undefined>;
+  /** Suppress keyboard and pointer navigation while retaining active state. */
+  readonly isDisabled?: MaybeRefOrGetter<boolean | undefined>;
+  /** Number of logical items traversed by PageUp and PageDown. */
+  readonly pageSize?: MaybeRefOrGetter<number | undefined>;
+  /** Optional buffered typeahead integrated into the same active state. */
+  readonly typeahead?: false | Omit<TypeaheadOptions<Key, Value>, "registry">;
+  /** Called after the active item and DOM focus representation are synchronized. */
+  readonly onNavigate?: (change: CompositeNavigationChange<Key>) => void;
+  /**
+   * Custom visibility policy for virtualized or scroll-managed collections.
+   * The default calls `scrollIntoView({block: "nearest", inline: "nearest"})`
+   * when the method exists and DOM focus did not already scroll the item.
+   */
+  readonly scrollIntoView?: (item: CollectionItem<Key, Value>, originalEvent: Event | null) => void;
+}
+/** Roving-tabindex options. */
+interface RovingNavigationOptions<Key extends CollectionKey, Value> extends CompositeNavigationBaseOptions<Key, Value> {
+  /** @default "roving" */
+  readonly focusStrategy?: "roving";
+  /** Avoid browser scrolling when DOM focus moves; custom scrolling still runs. */
+  readonly preventScroll?: MaybeRefOrGetter<boolean | undefined>;
+  /** Optional stable ID projection for item props. */
+  readonly getItemId?: (item: CollectionItem<Key, Value>) => string | undefined;
+}
+/** `aria-activedescendant` options with a required SSR-stable ID projection. */
+interface ActiveDescendantNavigationOptions<Key extends CollectionKey, Value> extends CompositeNavigationBaseOptions<Key, Value> {
+  readonly focusStrategy: "active-descendant";
+  /** Resolve the stable DOM ID referenced by `aria-activedescendant`. */
+  readonly getItemId: (item: CollectionItem<Key, Value>) => string;
+}
+/** Closed, strategy-discriminated composite configuration. */
+type CompositeNavigationOptions<Key extends CollectionKey, Value> = ActiveDescendantNavigationOptions<Key, Value> | RovingNavigationOptions<Key, Value>;
+/** Dynamic props for the composite container. */
+interface CompositeContainerProps {
+  readonly "aria-activedescendant"?: string;
+  readonly tabindex?: 0;
+  readonly onFocus: (event: FocusEvent) => void;
+  readonly onKeydown: (event: KeyboardEvent) => void;
+}
+/** Dynamic props for one registered composite item. */
+interface CompositeItemProps {
+  readonly id?: string;
+  readonly tabindex?: -1 | 0;
+  readonly onFocus: (event: FocusEvent) => void;
+  readonly onPointerdown: (event: PointerEvent) => void;
+}
+/** Focus and keyboard adapter layered over a collection registry. */
+interface CompositeNavigationController<Key extends CollectionKey> {
+  /** Registry-owned logical active key. */
+  readonly activeKey: ComputedRef<Key | null>;
+  /** Integrated typeahead controller, or `null` when typeahead is disabled. */
+  readonly typeahead: TypeaheadController<Key> | null;
+  /** Resolve current dynamic container attributes and stable handlers. */
+  readonly getContainerProps: () => Readonly<CompositeContainerProps>;
+  /** Resolve current dynamic item attributes and stable key-owned handlers. */
+  readonly getItemProps: (key: Key) => Readonly<CompositeItemProps>;
+  /** Move logical focus and synchronize the configured DOM representation. */
+  readonly navigate: (intent: CompositeNavigationCommand, originalEvent?: Event | null) => Key | null;
+  /** Release typeahead timers and cached handlers without disposing the registry. */
+  readonly dispose: () => void;
+}
+//#endregion
+//#region src/composite-navigation.d.ts
+/** Create an SSR-safe roving-tabindex or active-descendant collection adapter. */
+declare function createCompositeNavigation<Key extends CollectionKey, Value>(options: CompositeNavigationOptions<Key, Value>): CompositeNavigationController<Key>;
+/** Create a composite adapter disposed with the current Vue effect scope. */
+declare function useCompositeNavigation<Key extends CollectionKey, Value>(options: CompositeNavigationOptions<Key, Value>): CompositeNavigationController<Key>;
+//#endregion
+export { CompositeDirection as a, CompositeNavigationBaseOptions as c, CompositeNavigationController as d, CompositeNavigationIntent as f, RovingNavigationOptions as h, CompositeContainerProps as i, CompositeNavigationChange as l, CompositeOrientation as m, useCompositeNavigation as n, CompositeFocusStrategy as o, CompositeNavigationOptions as p, ActiveDescendantNavigationOptions as r, CompositeItemProps as s, createCompositeNavigation as t, CompositeNavigationCommand as u };

package/dist/composite-navigation-Skx3LZsv.mjs

@@ -0,0 +1,354 @@
+import { t as createTypeahead } from "./typeahead-B7KDxE_u.mjs";
+import { getCurrentScope, onScopeDispose, toValue } from "vue";
+//#region src/composite-navigation-internal.ts
+const optionDiagnostic = "VIZE_UI_COMPOSITE_NAVIGATION_OPTION";
+function capture(errors, callback) {
+	try {
+		callback();
+	} catch (error) {
+		errors.push(error);
+	}
+}
+function surfaceErrors(errors, message) {
+	if (errors.length === 1) throw errors[0];
+	if (errors.length < 2) return;
+	const Aggregate = globalThis.AggregateError;
+	if (typeof Aggregate === "function") throw new Aggregate(errors, message);
+	const fallback = Object.assign(new Error(message), { errors: [...errors] });
+	fallback.name = "AggregateError";
+	throw fallback;
+}
+function readBoolean(source, name) {
+	const value = toValue(source);
+	if (value === void 0) return false;
+	if (typeof value !== "boolean") throw new TypeError(`${optionDiagnostic}: ${name} must resolve to a boolean`);
+	return value;
+}
+function readOrientation(source) {
+	const value = toValue(source) ?? "vertical";
+	if (value !== "both" && value !== "horizontal" && value !== "vertical") throw new TypeError(`${optionDiagnostic}: orientation must resolve to both, horizontal, or vertical`);
+	return value;
+}
+function readDirection(source) {
+	const value = toValue(source) ?? "ltr";
+	if (value !== "ltr" && value !== "rtl") throw new TypeError(`${optionDiagnostic}: direction must resolve to ltr or rtl`);
+	return value;
+}
+function readPageSize(source) {
+	const value = toValue(source) ?? 10;
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) throw new TypeError(`${optionDiagnostic}: pageSize must resolve to a positive safe integer`);
+	return value;
+}
+function readStrategy(value) {
+	const strategy = value ?? "roving";
+	if (strategy !== "roving" && strategy !== "active-descendant") throw new TypeError(`${optionDiagnostic}: focusStrategy must be roving or active-descendant`);
+	return strategy;
+}
+function keyIntent(event, orientation, direction) {
+	if (event.isComposing || event.altKey || event.ctrlKey || event.metaKey) return null;
+	if (event.key === "Home") return "first";
+	if (event.key === "End") return "last";
+	if (event.key === "PageDown") return "page-next";
+	if (event.key === "PageUp") return "page-previous";
+	if ((orientation === "vertical" || orientation === "both") && event.key === "ArrowDown") return "next";
+	if ((orientation === "vertical" || orientation === "both") && event.key === "ArrowUp") return "previous";
+	if (orientation === "horizontal" || orientation === "both") {
+		if (event.key === "ArrowRight") return direction === "rtl" ? "previous" : "next";
+		if (event.key === "ArrowLeft") return direction === "rtl" ? "next" : "previous";
+	}
+	return null;
+}
+function validateId(value) {
+	if (typeof value !== "string" || value.length === 0) throw new TypeError("VIZE_UI_COMPOSITE_NAVIGATION_ID: an item ID must be non-empty and contain no ASCII whitespace or controls");
+	for (let index = 0; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		if (code <= 32 || code === 127) throw new TypeError("VIZE_UI_COMPOSITE_NAVIGATION_ID: an item ID must be non-empty and contain no ASCII whitespace or controls");
+	}
+	return value;
+}
+function validateOptions(options) {
+	if (!options || typeof options !== "object" || Array.isArray(options)) throw new TypeError(`${optionDiagnostic}: options must be an object`);
+	const registry = options.registry;
+	if (!registry || typeof registry.getNavigationKey !== "function" || !registry.activeKey) throw new TypeError(`${optionDiagnostic}: registry must be a CollectionRegistry`);
+	const strategy = readStrategy(options.focusStrategy);
+	if (strategy === "active-descendant" && typeof options.getItemId !== "function") throw new TypeError(`${optionDiagnostic}: active-descendant requires a getItemId function`);
+	for (const name of [
+		"getItemId",
+		"onNavigate",
+		"scrollIntoView"
+	]) {
+		const callback = options[name];
+		if (callback !== void 0 && typeof callback !== "function") throw new TypeError(`${optionDiagnostic}: ${name} must be a function`);
+	}
+	readOrientation(options.orientation);
+	readDirection(options.direction);
+	readBoolean(options.loop, "loop");
+	readBoolean(options.isDisabled, "isDisabled");
+	readPageSize(options.pageSize);
+	if (strategy === "roving") readBoolean(options.preventScroll, "preventScroll");
+	if (options.typeahead !== void 0 && options.typeahead !== false && (!options.typeahead || typeof options.typeahead !== "object" || Array.isArray(options.typeahead))) throw new TypeError(`${optionDiagnostic}: typeahead must be false or an options object`);
+	return strategy;
+}
+const nonTextInputType = /^(?:button|checkbox|color|file|image|radio|range|reset|submit)$/iu;
+function isEditableDescendant(event) {
+	const path = typeof event.composedPath === "function" ? event.composedPath() : [event.target];
+	for (const candidate of path) {
+		if (candidate === event.currentTarget) break;
+		const target = candidate;
+		const name = target?.localName;
+		if (name === "input") {
+			if (!nonTextInputType.test(target?.type ?? "text")) return true;
+			continue;
+		}
+		if (name === "select" || name === "textarea" || target?.isContentEditable === true) return true;
+	}
+	return false;
+}
+function validateCommand(value) {
+	if (value !== "first" && value !== "last" && value !== "next" && value !== "page-next" && value !== "page-previous" && value !== "previous") throw new TypeError(`${optionDiagnostic}: navigation intent is invalid`);
+	return value;
+}
+//#endregion
+//#region src/composite-navigation-dom.ts
+function eventElement(value) {
+	const candidate = value;
+	return candidate?.nodeType === 1 && typeof candidate.getRootNode === "function" ? candidate : null;
+}
+function focusItem(element, preventScroll, errors) {
+	const focusable = element;
+	if (typeof focusable?.focus !== "function") {
+		errors.push(/* @__PURE__ */ new Error("VIZE_UI_COMPOSITE_NAVIGATION_FOCUS: active roving item is not focusable"));
+		return;
+	}
+	capture(errors, () => {
+		try {
+			focusable.focus?.({ preventScroll });
+		} catch {
+			focusable.focus?.();
+		}
+	});
+}
+function revealItem(item, custom, event, errors) {
+	if (custom) {
+		capture(errors, () => custom(item, event));
+		return;
+	}
+	const reveal = item.element?.scrollIntoView;
+	if (typeof reveal === "function") capture(errors, () => reveal.call(item.element, {
+		block: "nearest",
+		inline: "nearest"
+	}));
+}
+function tokenIncludes(value, token) {
+	return value?.split(/\s+/u).includes(token) === true;
+}
+function relatedElement(host, id) {
+	const root = host.getRootNode();
+	if (typeof root.getElementById === "function") return root.getElementById(id);
+	return host.ownerDocument.getElementById(id);
+}
+function validateActiveDescendant(host, item, id, errors) {
+	const element = item.element;
+	if (!host || !element) return;
+	if (element.id !== id || relatedElement(element, id) !== element) {
+		errors.push(/* @__PURE__ */ new Error("VIZE_UI_COMPOSITE_NAVIGATION_ID_RELATIONSHIP: active descendant ID must uniquely resolve to its registered element"));
+		return;
+	}
+	if (host.contains(element) || tokenIncludes(host.getAttribute("aria-owns"), id)) return;
+	const role = host.getAttribute("role");
+	if (role === "combobox" || role === "searchbox" || role === "textbox") {
+		const controlledIds = host.getAttribute("aria-controls")?.split(/\s+/u) ?? [];
+		for (const controlledId of controlledIds) {
+			const controlled = relatedElement(host, controlledId);
+			if (controlled?.contains(element) || tokenIncludes(controlled?.getAttribute("aria-owns") ?? null, id)) return;
+		}
+	}
+	errors.push(/* @__PURE__ */ new Error("VIZE_UI_COMPOSITE_NAVIGATION_RELATIONSHIP: active descendant must be contained, aria-owned, or controlled by a supported input role"));
+}
+//#endregion
+//#region src/composite-navigation.ts
+const disposedDiagnostic = "VIZE_UI_COMPOSITE_NAVIGATION_DISPOSED";
+const itemDiagnostic = "VIZE_UI_COMPOSITE_NAVIGATION_ITEM";
+const setupDiagnostic = "VIZE_UI_COMPOSITE_NAVIGATION_SETUP";
+/** Create an SSR-safe roving-tabindex or active-descendant collection adapter. */
+function createCompositeNavigation(options) {
+	const strategy = validateOptions(options);
+	const registry = options.registry;
+	const itemHandlers = /* @__PURE__ */ new Map();
+	let container = null;
+	let disposed = false;
+	const assertActive = () => {
+		if (disposed) throw new Error(`${disposedDiagnostic}: the controller has been disposed`);
+	};
+	const getItem = (key) => {
+		const item = registry.getItem(key);
+		if (!item) throw new Error(`${itemDiagnostic}: no item is registered for ${String(key)}`);
+		return item;
+	};
+	const effectiveKey = () => registry.activeKey.value ?? registry.navigableItems.value[0]?.key ?? null;
+	const itemId = (item) => {
+		const getId = options.getItemId;
+		const value = getId?.(item) ?? (item.element?.id || void 0);
+		if (value === void 0) {
+			if (strategy === "active-descendant") throw new Error("VIZE_UI_COMPOSITE_NAVIGATION_ID: active-descendant items require a stable ID");
+			return;
+		}
+		return validateId(value);
+	};
+	const synchronizeDom = (key, originalEvent, moveDomFocus, errors) => {
+		const item = getItem(key);
+		if (strategy === "active-descendant") validateActiveDescendant(container, item, itemId(item), errors);
+		const preventScroll = strategy === "roving" && readBoolean(options.preventScroll, "preventScroll");
+		if (strategy === "roving" && moveDomFocus) focusItem(item.element, preventScroll, errors);
+		if (options.scrollIntoView || strategy === "active-descendant" || moveDomFocus && preventScroll) revealItem(item, options.scrollIntoView, originalEvent, errors);
+	};
+	const notify = (key, previousKey, intent, originalEvent, errors) => {
+		const change = Object.freeze({
+			key,
+			previousKey,
+			intent,
+			originalEvent,
+			focusStrategy: strategy
+		});
+		capture(errors, () => options.onNavigate?.(change));
+	};
+	const commit = (mutate, intent, originalEvent, moveDomFocus) => {
+		const previousKey = registry.activeKey.value;
+		const errors = [];
+		capture(errors, mutate);
+		const key = registry.activeKey.value;
+		if (key !== null && key !== previousKey) {
+			capture(errors, () => synchronizeDom(key, originalEvent, moveDomFocus, errors));
+			notify(key, previousKey, intent, originalEvent, errors);
+		}
+		surfaceErrors(errors, "Composite navigation transition failed");
+		return key;
+	};
+	const pageTarget = (intent) => {
+		const direction = intent === "page-next" ? "next" : "previous";
+		let key = effectiveKey();
+		for (let index = 0; index < readPageSize(options.pageSize); index++) {
+			const next = registry.getNavigationKey(direction, {
+				fromKey: key,
+				loop: false
+			});
+			if (next === null || next === key) break;
+			key = next;
+		}
+		return key;
+	};
+	const navigate = (intent, originalEvent = null) => {
+		assertActive();
+		intent = validateCommand(intent);
+		if (readBoolean(options.isDisabled, "isDisabled")) return null;
+		if (intent === "page-next" || intent === "page-previous") {
+			const target = pageTarget(intent);
+			if (target === null) return null;
+			return commit(() => {
+				registry.setActiveKey(target);
+			}, intent, originalEvent, strategy === "roving");
+		}
+		return commit(() => {
+			registry.moveActive(intent, { loop: readBoolean(options.loop, "loop") });
+		}, intent, originalEvent, strategy === "roving");
+	};
+	const configuredTypeahead = options.typeahead;
+	const typeahead = configuredTypeahead && typeof configuredTypeahead === "object" ? createTypeahead({
+		...configuredTypeahead,
+		registry,
+		isDisabled: () => readBoolean(options.isDisabled, "isDisabled") || readBoolean(configuredTypeahead.isDisabled, "typeahead.isDisabled"),
+		onMatch(match) {
+			const errors = [];
+			if (match.key !== match.previousKey) {
+				capture(errors, () => synchronizeDom(match.key, match.originalEvent, strategy === "roving", errors));
+				notify(match.key, match.previousKey, "typeahead", match.originalEvent, errors);
+			}
+			capture(errors, () => configuredTypeahead.onMatch?.(match));
+			surfaceErrors(errors, "Composite typeahead transition failed");
+		}
+	}) : null;
+	const activateItem = (key, event) => {
+		if (disposed || readBoolean(options.isDisabled, "isDisabled")) return;
+		if (!registry.navigableItems.value.some((item) => item.key === key)) return;
+		commit(() => {
+			registry.setActiveKey(key);
+		}, event.type === "pointerdown" ? "pointer" : "focus", event, false);
+	};
+	const handlersFor = (key) => {
+		const cached = itemHandlers.get(key);
+		if (cached) return cached;
+		for (const cachedKey of itemHandlers.keys()) if (!registry.getItem(cachedKey)) itemHandlers.delete(cachedKey);
+		const handlers = Object.freeze({
+			onFocus: (event) => activateItem(key, event),
+			onPointerdown: (event) => activateItem(key, event)
+		});
+		itemHandlers.set(key, handlers);
+		return handlers;
+	};
+	const onFocus = (event) => {
+		if (disposed) return;
+		container = eventElement(event.currentTarget);
+		if (strategy !== "active-descendant" || event.target !== event.currentTarget || readBoolean(options.isDisabled, "isDisabled")) return;
+		const key = effectiveKey();
+		if (key !== null && registry.activeKey.value === null) commit(() => {
+			registry.setActiveKey(key);
+		}, "focus", event, false);
+	};
+	const onKeydown = (event) => {
+		if (disposed) return;
+		container = eventElement(event.currentTarget);
+		if (event.defaultPrevented || isEditableDescendant(event) || readBoolean(options.isDisabled, "isDisabled")) return;
+		const intent = keyIntent(event, readOrientation(options.orientation), readDirection(options.direction));
+		if (intent && registry.navigableItems.value.length > 0) {
+			event.preventDefault();
+			navigate(intent, event);
+			return;
+		}
+		typeahead?.typeaheadProps.onKeydown(event);
+	};
+	return Object.freeze({
+		activeKey: registry.activeKey,
+		typeahead,
+		getContainerProps: () => {
+			assertActive();
+			const key = effectiveKey();
+			const activeDescendant = strategy === "active-descendant" && key !== null ? itemId(getItem(key)) : void 0;
+			const props = {
+				onFocus,
+				onKeydown,
+				...strategy === "active-descendant" ? { tabindex: 0 } : {},
+				...activeDescendant !== void 0 ? { "aria-activedescendant": activeDescendant } : {}
+			};
+			return Object.freeze(props);
+		},
+		getItemProps: (key) => {
+			assertActive();
+			const item = getItem(key);
+			const handlers = handlersFor(key);
+			const id = itemId(item);
+			const props = {
+				...handlers,
+				...id ? { id } : {},
+				...strategy === "roving" ? { tabindex: effectiveKey() === key ? 0 : -1 } : {}
+			};
+			return Object.freeze(props);
+		},
+		navigate,
+		dispose: () => {
+			if (disposed) return;
+			disposed = true;
+			typeahead?.dispose();
+			itemHandlers.clear();
+			container = null;
+		}
+	});
+}
+/** Create a composite adapter disposed with the current Vue effect scope. */
+function useCompositeNavigation(options) {
+	if (!getCurrentScope()) throw new Error(`${setupDiagnostic}: use inside component setup or an active effect scope`);
+	const controller = createCompositeNavigation(options);
+	onScopeDispose(controller.dispose);
+	return controller;
+}
+//#endregion
+export { useCompositeNavigation as n, createCompositeNavigation as t };

package/dist/composite-navigation.d.mts

@@ -0,0 +1,2 @@
+import { a as CompositeDirection, c as CompositeNavigationBaseOptions, d as CompositeNavigationController, f as CompositeNavigationIntent, h as RovingNavigationOptions, i as CompositeContainerProps, l as CompositeNavigationChange, m as CompositeOrientation, n as useCompositeNavigation, o as CompositeFocusStrategy, p as CompositeNavigationOptions, r as ActiveDescendantNavigationOptions, s as CompositeItemProps, t as createCompositeNavigation, u as CompositeNavigationCommand } from "./composite-navigation-QINW9GLy.mjs";
+export { type ActiveDescendantNavigationOptions, type CompositeContainerProps, type CompositeDirection, type CompositeFocusStrategy, type CompositeItemProps, type CompositeNavigationBaseOptions, type CompositeNavigationChange, type CompositeNavigationCommand, type CompositeNavigationController, type CompositeNavigationIntent, type CompositeNavigationOptions, type CompositeOrientation, type RovingNavigationOptions, createCompositeNavigation, useCompositeNavigation };

package/dist/composite-navigation.mjs

@@ -0,0 +1,2 @@
+import { n as useCompositeNavigation, t as createCompositeNavigation } from "./composite-navigation-Skx3LZsv.mjs";
+export { createCompositeNavigation, useCompositeNavigation };

package/dist/controllable-state.d.mts

@@ -1,2 +1,2 @@
-import { i as useControllableState, n as ControllableStateOptions, r as StateUpdate, t as ControllableState } from "./controllable-state-B9v6FClp.mjs";
+import { i as useControllableState, n as ControllableStateOptions, r as StateUpdate, t as ControllableState } from "./controllable-state-BtoxKahh.mjs";
 export { ControllableState, ControllableStateOptions, StateUpdate, useControllableState };