@vizejs/ui 0.343.0 → 0.347.7

package/dist/{button-D7sM9Xmj.d.mts → button-BMIqJ_M5.d.mts}

@@ -1,4 +1,4 @@
-import { n as PrimitiveElement, t as PrimitiveAs } from "./primitive-BtvwikH1.mjs";
+import { n as PrimitiveElement, t as PrimitiveAs } from "./primitive-Bog8qvd8.mjs";
 import * as _$vue from "vue";
 
 //#region src/button-keyboard.d.ts

package/dist/button.d.mts

@@ -1,2 +1,2 @@
-import { i as getButtonKeyboardAction, n as ButtonKeyboardAction, r as ButtonKeyboardPhase, t as _default } from "./button-D7sM9Xmj.mjs";
+import { i as getButtonKeyboardAction, n as ButtonKeyboardAction, r as ButtonKeyboardPhase, t as _default } from "./button-BMIqJ_M5.mjs";
 export { _default as Button, ButtonKeyboardAction, ButtonKeyboardPhase, getButtonKeyboardAction };

package/dist/button.mjs

@@ -1,2 +1,2 @@
-import { n as getButtonKeyboardAction, t as ActionButton_default } from "./button-8BOlFJNu.mjs";
+import { n as getButtonKeyboardAction, t as ActionButton_default } from "./button-CaLxP2l2.mjs";
 export { ActionButton_default as Button, getButtonKeyboardAction };

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

@@ -1,4 +1,4 @@
-import { r as StateUpdate } from "./controllable-state-DXsYJ3yl.mjs";
+import { r as StateUpdate } from "./controllable-state-B9v6FClp.mjs";
 import * as _$vue from "vue";
 
 //#region src/checkbox-state.d.ts

package/dist/checkbox.d.mts

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

package/dist/collection-CoOROaho.mjs

@@ -0,0 +1,453 @@
+import { computed, getCurrentScope, onScopeDispose, shallowRef, toValue, watch } from "vue";
+//#region src/collection-keys.ts
+/** Reject keys that cannot serve as stable, serializable item identities. */
+function validateCollectionKey(key) {
+	if (typeof key === "string") {
+		if (key.length === 0 || containsAsciiControl(key)) throw new Error("VIZE_UI_COLLECTION_KEY_VALUE: a string key must be non-empty and contain no ASCII controls");
+		return;
+	}
+	if (!Number.isSafeInteger(key) || Object.is(key, -0)) throw new Error("VIZE_UI_COLLECTION_KEY_VALUE: a numeric key must be a safe integer other than negative zero");
+}
+/** Whether a resolved item list still contains a key. */
+function hasCollectionKey(items, key) {
+	return items.some((item) => item.key === key);
+}
+/**
+* Pick the logical focus successor for a key that left the navigable set.
+*
+* The next navigable item wins, then the previous one, so removing or
+* disabling the active item never orphans logical focus.
+*/
+function recoverCollectionKey(removedKey, previousItems, nextItems) {
+	if (nextItems.length === 0) return null;
+	const nextKeys = new Set(nextItems.map((item) => item.key));
+	const previousIndex = previousItems.findIndex((item) => item.key === removedKey);
+	if (previousIndex < 0) return nextItems[0]?.key ?? null;
+	for (let index = previousIndex + 1; index < previousItems.length; index++) {
+		const key = previousItems[index]?.key;
+		if (key !== void 0 && nextKeys.has(key)) return key;
+	}
+	for (let index = previousIndex - 1; index >= 0; index--) {
+		const key = previousItems[index]?.key;
+		if (key !== void 0 && nextKeys.has(key)) return key;
+	}
+	return nextItems[0]?.key ?? null;
+}
+function containsAsciiControl(value) {
+	for (let index = 0; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		if (code <= 31 || code === 127) return true;
+	}
+	return false;
+}
+//#endregion
+//#region src/collection-observer.ts
+const orderAndTextMutations = {
+	attributeFilter: [
+		"alt",
+		"aria-hidden",
+		"aria-label",
+		"aria-labelledby",
+		"hidden",
+		"inert",
+		"title",
+		"type",
+		"value"
+	],
+	attributes: true,
+	characterData: true,
+	childList: true,
+	subtree: true
+};
+const mountMutations = {
+	childList: true,
+	subtree: true
+};
+/**
+* Observe DOM ordering and accessible text mutations for registered items.
+*
+* One observer is created per owning document. Connected items use their
+* closest common ancestor and disconnected items are observed directly, so
+* attribute and text noise from the rest of the document is never observed.
+* Disconnected items additionally use a structure-only document observer that
+* reports only once one of them mounts, because their insertion point is
+* unknowable beforehand.
+*/
+function observeCollectionMutations(items, onMutation) {
+	const elementsByDocument = /* @__PURE__ */ new Map();
+	for (const { element } of items) {
+		if (element === null) continue;
+		const elements = elementsByDocument.get(element.ownerDocument) ?? [];
+		elements.push(element);
+		elementsByDocument.set(element.ownerDocument, elements);
+	}
+	const observers = [];
+	for (const [ownerDocument, elements] of elementsByDocument) {
+		const MutationObserverConstructor = ownerDocument.defaultView?.MutationObserver;
+		if (MutationObserverConstructor === void 0) continue;
+		const observer = new MutationObserverConstructor(onMutation);
+		const connectedElements = elements.filter((element) => element.isConnected);
+		const disconnectedElements = elements.filter((element) => !element.isConnected);
+		const commonAncestor = connectedElements.length === elements.length ? findCollectionObservationRoot(connectedElements) : null;
+		const connectedRoot = commonAncestor === null ? findCollectionObservationRoot(connectedElements) : commonAncestor;
+		const targets = commonAncestor === null ? new Set([...connectedRoot === null ? connectedElements : [connectedRoot], ...disconnectedElements]) : new Set([commonAncestor]);
+		for (const target of targets) observer.observe(target, orderAndTextMutations);
+		observers.push(observer);
+		if (disconnectedElements.length === 0) continue;
+		const mountObserver = new MutationObserverConstructor(() => {
+			if (disconnectedElements.some((element) => element.isConnected)) onMutation();
+		});
+		mountObserver.observe(ownerDocument.documentElement, mountMutations);
+		observers.push(mountObserver);
+	}
+	return observers;
+}
+function findCollectionObservationRoot(elements) {
+	const firstElement = elements[0];
+	if (firstElement === void 0) return null;
+	let candidate = firstElement.parentNode ?? firstElement;
+	while (candidate !== null) {
+		if (elements.every((element) => candidate === element || candidate?.contains(element) === true)) return candidate;
+		candidate = candidate.parentNode;
+	}
+	return null;
+}
+//#endregion
+//#region src/collection-text.ts
+const ignoredTextTags = new Set([
+	"NOSCRIPT",
+	"SCRIPT",
+	"STYLE",
+	"TEMPLATE"
+]);
+/**
+* Normalize authored or extracted typeahead text without applying a locale.
+*
+* Unicode is normalized to NFC and every whitespace run becomes one ASCII
+* space. Locale-sensitive equality remains the responsibility of a collator.
+*/
+function normalizeCollectionTextValue(value) {
+	return value.normalize("NFC").trim().replace(/\s+/gu, " ");
+}
+/**
+* Extract a practical accessible text value from an item element.
+*
+* `aria-labelledby` and `aria-label` take precedence, hidden descendants are
+* excluded unless explicitly referenced, and image/input fallbacks are
+* included. Complex widgets should still provide `textValue` explicitly when
+* their typeahead label differs from their accessible name.
+*/
+function extractCollectionTextValue(element) {
+	return normalizeCollectionTextValue(readElementText(element, /* @__PURE__ */ new Set(), false));
+}
+/** Whether a candidate text starts with a query under locale-aware comparison. */
+function collectionTextStartsWith(candidate, query, collator) {
+	let codeUnitLength = 0;
+	for (const character of candidate) {
+		codeUnitLength += character.length;
+		if (collator.compare(candidate.slice(0, codeUnitLength), query) === 0) return true;
+	}
+	return false;
+}
+function readElementText(element, visited, referenced) {
+	if (visited.has(element)) return "";
+	visited.add(element);
+	if (!referenced && isCollectionTextHidden(element)) return "";
+	const labelledBy = element.getAttribute("aria-labelledby");
+	if (labelledBy !== null) {
+		const root = element.getRootNode();
+		const referenceRoot = hasGetElementById(root) ? root : element.ownerDocument;
+		const labelledText = labelledBy.split(/\s+/u).filter((id) => id.length > 0).map((id) => referenceRoot.getElementById(id)).filter((label) => label !== null).map((label) => readElementText(label, visited, true)).join(" ");
+		if (normalizeCollectionTextValue(labelledText).length > 0) return labelledText;
+	}
+	const ariaLabel = element.getAttribute("aria-label");
+	if (ariaLabel !== null && normalizeCollectionTextValue(ariaLabel).length > 0) return ariaLabel;
+	const tagName = element.tagName.toUpperCase();
+	if (tagName === "IMG" || tagName === "AREA") {
+		const alternative = element.getAttribute("alt");
+		if (alternative !== null) return alternative;
+	}
+	if (tagName === "INPUT") {
+		const type = element.getAttribute("type")?.toLowerCase();
+		if (type === "button" || type === "reset" || type === "submit") {
+			const value = element.value;
+			if (value.length > 0) return value;
+		}
+	}
+	if (!ignoredTextTags.has(tagName)) {
+		const fragments = [];
+		for (const child of element.childNodes) if (child.nodeType === 3) fragments.push(child.nodeValue ?? "");
+		else if (child.nodeType === 1) fragments.push(readElementText(child, visited, referenced));
+		const content = fragments.join("");
+		if (normalizeCollectionTextValue(content).length > 0) return content;
+	}
+	return element.getAttribute("title") ?? "";
+}
+function hasGetElementById(node) {
+	return "getElementById" in node && typeof node.getElementById === "function";
+}
+function isCollectionTextHidden(element) {
+	return element.hasAttribute("hidden") || element.hasAttribute("inert") || element.getAttribute("aria-hidden")?.trim().toLowerCase() === "true";
+}
+//#endregion
+//#region src/collection-order.ts
+const documentPositionDisconnected = 1;
+const documentPositionPreceding = 2;
+const documentPositionFollowing = 4;
+/** Resolve every reactive source of one record into an immutable snapshot. */
+function resolveCollectionRecord(record) {
+	const { input } = record;
+	const element = input.element === void 0 ? null : toValue(input.element) ?? null;
+	const explicitText = input.textValue === void 0 ? void 0 : toValue(input.textValue);
+	const order = input.order === void 0 ? void 0 : toValue(input.order);
+	if (order !== void 0 && !Number.isSafeInteger(order)) throw new Error(`VIZE_UI_COLLECTION_ORDER_VALUE: ${String(input.key)} requires a safe integer order`);
+	return {
+		sequence: record.sequence,
+		item: Object.freeze({
+			key: input.key,
+			value: input.value,
+			element,
+			textValue: explicitText === null || explicitText === void 0 ? element === null ? "" : extractCollectionTextValue(element) : normalizeCollectionTextValue(explicitText),
+			disabled: input.disabled === void 0 ? false : Boolean(toValue(input.disabled)),
+			order
+		})
+	};
+}
+/**
+* Sort resolved records in place using explicit order, DOM order, or
+* registration order, rejecting ambiguous mixes of explicit orders.
+*/
+function sortCollectionRecords(records) {
+	const explicitOrderCount = records.filter(({ item }) => item.order !== void 0).length;
+	if (explicitOrderCount > 0 && explicitOrderCount !== records.length) throw new Error("VIZE_UI_COLLECTION_ORDER_PARTIAL: every item must provide order when explicit ordering is used");
+	if (explicitOrderCount === records.length && records.length > 0) {
+		const seenOrders = /* @__PURE__ */ new Set();
+		for (const { item } of records) {
+			const order = item.order;
+			if (order === void 0) continue;
+			if (seenOrders.has(order)) throw new Error(`VIZE_UI_COLLECTION_ORDER_DUPLICATE: order ${String(order)} is registered more than once`);
+			seenOrders.add(order);
+		}
+		records.sort((left, right) => (left.item.order ?? 0) - (right.item.order ?? 0));
+		return;
+	}
+	const ownerDocument = records[0]?.item.element?.ownerDocument;
+	if (!(ownerDocument !== void 0 && records.every(({ item }) => item.element !== null && item.element.isConnected && item.element.ownerDocument === ownerDocument))) {
+		records.sort((left, right) => left.sequence - right.sequence);
+		return;
+	}
+	records.sort((left, right) => {
+		const leftElement = left.item.element;
+		const rightElement = right.item.element;
+		if (leftElement !== null && rightElement !== null && leftElement !== rightElement) {
+			const position = leftElement.compareDocumentPosition(rightElement);
+			if ((position & documentPositionDisconnected) === 0) {
+				if ((position & documentPositionFollowing) !== 0) return -1;
+				if ((position & documentPositionPreceding) !== 0) return 1;
+			}
+		}
+		return left.sequence - right.sequence;
+	});
+}
+//#endregion
+//#region src/collection-registry.ts
+/**
+* Create an SSR-safe, mutation-aware registry for one compound collection.
+*
+* The registry never moves DOM focus itself. Consumers bind `activeKey` to
+* roving tabindex or `aria-activedescendant`; synchronous recovery guarantees
+* that removing or disabling the active item selects the next navigable item,
+* then the previous one, before the mutation can leave focus state orphaned.
+*/
+function createCollectionRegistry(options = {}) {
+	const disabledBehavior = options.disabledBehavior ?? "skip";
+	const collator = options.collator ?? new Intl.Collator(void 0, {
+		sensitivity: "base",
+		usage: "search"
+	});
+	const records = /* @__PURE__ */ new Map();
+	const revision = shallowRef(0);
+	const activeKeyState = shallowRef(null);
+	const activeKey = computed(() => activeKeyState.value);
+	let sequence = 0;
+	let disposed = false;
+	let mutationObservers = [];
+	let observedElements;
+	let observedConnected = [];
+	const items = computed(() => {
+		revision.value;
+		const resolved = [...records.values()].map(resolveCollectionRecord);
+		sortCollectionRecords(resolved);
+		return Object.freeze(resolved.map(({ item }) => item));
+	});
+	const navigableItems = computed(() => {
+		const resolved = items.value.filter((item) => disabledBehavior === "focusable" || !item.disabled);
+		return Object.freeze(resolved);
+	});
+	const updateActiveKey = (key, reason) => {
+		const previousKey = activeKeyState.value;
+		if (previousKey === key) return false;
+		activeKeyState.value = key;
+		options.onActiveKeyChange?.(Object.freeze({
+			key,
+			previousKey,
+			reason
+		}));
+		return true;
+	};
+	const stopRecovery = watch(navigableItems, (nextItems, previousItems) => {
+		const activeKey = activeKeyState.value;
+		if (activeKey === null || hasCollectionKey(nextItems, activeKey)) return;
+		const reason = hasCollectionKey(items.value, activeKey) ? "item-disabled" : "item-removed";
+		updateActiveKey(recoverCollectionKey(activeKey, previousItems, nextItems), reason);
+	}, { flush: "sync" });
+	const stopObservation = watch(items, (nextItems) => {
+		const nextElements = nextItems.map(({ element }) => element);
+		const nextConnected = nextElements.map((element) => element?.isConnected === true);
+		if (observedElements !== void 0 && observedElements.length === nextElements.length && observedElements.every((element, index) => element === nextElements[index] && observedConnected[index] === nextConnected[index])) return;
+		for (const observer of mutationObservers) observer.disconnect();
+		mutationObservers = observeCollectionMutations(nextItems, () => {
+			if (!disposed) revision.value += 1;
+		});
+		observedElements = nextElements;
+		observedConnected = nextConnected;
+	}, {
+		flush: "sync",
+		immediate: true
+	});
+	const assertMutable = () => {
+		if (disposed) throw new Error("VIZE_UI_COLLECTION_DISPOSED: a disposed registry cannot be mutated");
+	};
+	const refresh = () => {
+		assertMutable();
+		revision.value += 1;
+	};
+	const getItem = (key) => items.value.find((item) => item.key === key);
+	const setActiveKey = (key) => {
+		assertMutable();
+		if (key === null) return updateActiveKey(null, "programmatic");
+		const item = getItem(key);
+		if (item === void 0) throw new Error(`VIZE_UI_COLLECTION_KEY_MISSING: no item is registered for ${String(key)}`);
+		if (disabledBehavior === "skip" && item.disabled) throw new Error(`VIZE_UI_COLLECTION_KEY_DISABLED: ${String(key)} is not navigable`);
+		return updateActiveKey(key, "programmatic");
+	};
+	const getNavigationKey = (direction, navigationOptions = {}) => {
+		const candidates = navigableItems.value;
+		if (candidates.length === 0) return null;
+		if (direction === "first") return candidates[0]?.key ?? null;
+		if (direction === "last") return candidates.at(-1)?.key ?? null;
+		const fromKey = navigationOptions.fromKey === void 0 ? activeKeyState.value : navigationOptions.fromKey;
+		if (fromKey === null) return direction === "next" ? candidates[0]?.key ?? null : candidates.at(-1)?.key ?? null;
+		const candidateIndex = candidates.findIndex((item) => item.key === fromKey);
+		if (candidateIndex >= 0) {
+			const target = candidates[candidateIndex + (direction === "next" ? 1 : -1)];
+			if (target !== void 0) return target.key;
+			if (navigationOptions.loop === true) return direction === "next" ? candidates[0]?.key ?? null : candidates.at(-1)?.key ?? null;
+			return fromKey;
+		}
+		const allItems = items.value;
+		const itemIndex = allItems.findIndex((item) => item.key === fromKey);
+		if (itemIndex >= 0) {
+			const step = direction === "next" ? 1 : -1;
+			for (let index = itemIndex + step; index >= 0 && index < allItems.length; index += step) {
+				const candidate = allItems[index];
+				if (candidate !== void 0 && hasCollectionKey(candidates, candidate.key)) return candidate.key;
+			}
+			if (navigationOptions.loop !== true) return null;
+		}
+		return direction === "next" ? candidates[0]?.key ?? null : candidates.at(-1)?.key ?? null;
+	};
+	const moveActive = (direction, navigationOptions = {}) => {
+		assertMutable();
+		const target = getNavigationKey(direction, navigationOptions);
+		if (target !== null) updateActiveKey(target, "navigation");
+		return target;
+	};
+	const findByTextValue = (query, searchOptions = {}) => {
+		const normalizedQuery = normalizeCollectionTextValue(query);
+		if (normalizedQuery.length === 0) return null;
+		const candidates = navigableItems.value;
+		if (candidates.length === 0) return null;
+		const fromKey = searchOptions.fromKey === void 0 ? activeKeyState.value : searchOptions.fromKey;
+		const fromIndex = fromKey === null ? -1 : candidates.findIndex((candidate) => candidate.key === fromKey);
+		const after = candidates.slice(fromIndex + 1);
+		const before = searchOptions.loop === false ? [] : candidates.slice(0, fromIndex + 1);
+		const searchCandidates = [...after, ...before];
+		const searchCollator = searchOptions.collator ?? collator;
+		const match = searchOptions.match ?? "prefix";
+		for (const candidate of searchCandidates) {
+			if (candidate.textValue.length === 0) continue;
+			if (match === "exact" ? searchCollator.compare(candidate.textValue, normalizedQuery) === 0 : collectionTextStartsWith(candidate.textValue, normalizedQuery, searchCollator)) return candidate.key;
+		}
+		return null;
+	};
+	const moveActiveByTextValue = (query, searchOptions = {}) => {
+		assertMutable();
+		const target = findByTextValue(query, searchOptions);
+		if (target !== null) updateActiveKey(target, "typeahead");
+		return target;
+	};
+	const register = (input) => {
+		assertMutable();
+		validateCollectionKey(input.key);
+		if (records.has(input.key)) throw new Error(`VIZE_UI_COLLECTION_KEY_DUPLICATE: ${String(input.key)} is already registered`);
+		const record = {
+			input: Object.freeze({ ...input }),
+			sequence: sequence++
+		};
+		records.set(input.key, record);
+		try {
+			revision.value += 1;
+		} catch (error) {
+			records.delete(input.key);
+			revision.value += 1;
+			throw error;
+		}
+		const unregister = () => {
+			if (records.get(input.key) !== record) return false;
+			records.delete(input.key);
+			revision.value += 1;
+			return true;
+		};
+		const registration = Object.freeze({
+			key: input.key,
+			registered: computed(() => {
+				revision.value;
+				return records.get(input.key) === record;
+			}),
+			unregister
+		});
+		if (getCurrentScope() !== void 0) onScopeDispose(unregister);
+		return registration;
+	};
+	const dispose = () => {
+		if (disposed) return false;
+		disposed = true;
+		stopRecovery();
+		stopObservation();
+		for (const observer of mutationObservers) observer.disconnect();
+		mutationObservers = [];
+		records.clear();
+		revision.value += 1;
+		updateActiveKey(null, "registry-disposed");
+		return true;
+	};
+	const registry = Object.freeze({
+		items,
+		navigableItems,
+		activeKey,
+		register,
+		getItem,
+		refresh,
+		setActiveKey,
+		getNavigationKey,
+		moveActive,
+		findByTextValue,
+		moveActiveByTextValue,
+		dispose
+	});
+	if (getCurrentScope() !== void 0) onScopeDispose(dispose);
+	return registry;
+}
+//#endregion
+export { extractCollectionTextValue as n, normalizeCollectionTextValue as r, createCollectionRegistry as t };

package/dist/collection-aHZ6Pf0e.d.mts

@@ -0,0 +1,185 @@
+import { ComputedRef, MaybeRefOrGetter } from "vue";
+
+//#region src/collection-types.d.ts
+/** Serializable identity accepted by every collection primitive. */
+type CollectionKey = string | number;
+/** How disabled items participate in focus navigation and typeahead. */
+type CollectionDisabledBehavior = "skip" | "focusable";
+/** Direction understood by {@link CollectionRegistry.getNavigationKey}. */
+type CollectionNavigationDirection = "first" | "last" | "next" | "previous";
+/** Why the registry changed its active key. */
+type CollectionActiveChangeReason = "programmatic" | "navigation" | "typeahead" | "item-removed" | "item-disabled" | "registry-disposed";
+/** Reactive sources registered for one logical collection item. */
+interface CollectionItemInput<Key extends CollectionKey, Value> {
+  /** Stable, request-independent identity. Keys must be unique within a registry. */
+  readonly key: Key;
+  /** Consumer-owned data associated with this item. */
+  readonly value: Value;
+  /** Rendered element used for live DOM ordering and text extraction. */
+  readonly element?: MaybeRefOrGetter<Element | null | undefined>;
+  /**
+   * Explicit typeahead text. `null` and `undefined` select accessible DOM text
+   * extraction; an empty string deliberately opts the item out of typeahead.
+   */
+  readonly textValue?: MaybeRefOrGetter<string | null | undefined>;
+  /** Whether activation is disabled. Navigation follows `disabledBehavior`. */
+  readonly disabled?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Deterministic order for virtualized, portalled, or server-only items.
+   *
+   * If one item supplies an order, every item must supply a unique safe integer.
+   * Otherwise DOM order is used once every item is connected in one document;
+   * registration order is the SSR, partial-mount, and disconnected fallback.
+   */
+  readonly order?: MaybeRefOrGetter<number | undefined>;
+}
+/** Immutable, resolved view of a registered collection item. */
+interface CollectionItem<Key extends CollectionKey, Value> {
+  /** Stable item identity. */
+  readonly key: Key;
+  /** Consumer-owned item data. */
+  readonly value: Value;
+  /** Current rendered element, or `null` during SSR and before mount. */
+  readonly element: Element | null;
+  /** Normalized text used by typeahead. */
+  readonly textValue: string;
+  /** Current disabled state. */
+  readonly disabled: boolean;
+  /** Explicit virtual order, or `undefined` when DOM order is authoritative. */
+  readonly order: number | undefined;
+}
+/** Active-key transition reported to collection consumers. */
+interface CollectionActiveChange<Key extends CollectionKey> {
+  /** New active key, or `null` when no navigable item remains. */
+  readonly key: Key | null;
+  /** Active key before the transition. */
+  readonly previousKey: Key | null;
+  /** Stable cause suitable for focus and announcement policies. */
+  readonly reason: CollectionActiveChangeReason;
+}
+/** Options for {@link createCollectionRegistry}. */
+interface CollectionRegistryOptions<Key extends CollectionKey> {
+  /**
+   * Whether disabled items are omitted from navigation or remain focusable.
+   *
+   * Menus commonly use `"focusable"`; listboxes and roving tab stops commonly
+   * use `"skip"`.
+   *
+   * @default "skip"
+   */
+  readonly disabledBehavior?: CollectionDisabledBehavior;
+  /** Locale-aware comparator used by typeahead matching. */
+  readonly collator?: Intl.Collator;
+  /** Called synchronously after a distinct active-key transition. */
+  readonly onActiveKeyChange?: (change: CollectionActiveChange<Key>) => void;
+}
+/** Options for directional collection navigation. */
+interface CollectionNavigationOptions<Key extends CollectionKey> {
+  /**
+   * Key navigation starts from.
+   *
+   * @default The registry active key
+   */
+  readonly fromKey?: Key | null;
+  /**
+   * Whether navigation wraps at the first and last item.
+   *
+   * @default false
+   */
+  readonly loop?: boolean;
+}
+/** Options for locale-aware collection text lookup. */
+interface CollectionTextSearchOptions<Key extends CollectionKey> {
+  /**
+   * Search begins after this key so repeated input cycles matching items.
+   *
+   * @default The registry active key
+   */
+  readonly fromKey?: Key | null;
+  /**
+   * Match normalized prefixes or the complete normalized text.
+   *
+   * @default "prefix"
+   */
+  readonly match?: "prefix" | "exact";
+  /**
+   * Whether search wraps to the beginning of the collection.
+   *
+   * @default true
+   */
+  readonly loop?: boolean;
+  /** Per-search locale comparator override. */
+  readonly collator?: Intl.Collator;
+}
+/** Idempotent lifecycle handle returned by {@link CollectionRegistry.register}. */
+interface CollectionRegistration<Key extends CollectionKey> {
+  /** Registered stable key. */
+  readonly key: Key;
+  /** Whether this exact registration still owns its key. */
+  readonly registered: ComputedRef<boolean>;
+  /** Remove this registration and report whether it was present. */
+  readonly unregister: () => boolean;
+}
+/** Type-safe registry shared by compound collection components. */
+interface CollectionRegistry<Key extends CollectionKey, Value> {
+  /** All items in deterministic virtual, DOM, or registration order. */
+  readonly items: ComputedRef<readonly CollectionItem<Key, Value>[]>;
+  /** Items eligible for focus navigation under the disabled policy. */
+  readonly navigableItems: ComputedRef<readonly CollectionItem<Key, Value>[]>;
+  /** Logical focus key used by roving-tabindex and `aria-activedescendant` adapters. */
+  readonly activeKey: ComputedRef<Key | null>;
+  /** Register one item. Vue scope disposal unregisters it automatically. */
+  readonly register: (input: CollectionItemInput<Key, Value>) => CollectionRegistration<Key>;
+  /** Resolve the latest immutable snapshot for a key. */
+  readonly getItem: (key: Key) => CollectionItem<Key, Value> | undefined;
+  /**
+   * Re-resolve reactive sources, DOM order, and extracted text immediately.
+   *
+   * A scoped MutationObserver calls this automatically for connected items;
+   * the explicit hook supports custom renderers and observer-free environments.
+   */
+  readonly refresh: () => void;
+  /** Set a registered, navigable active key, or clear it with `null`. */
+  readonly setActiveKey: (key: Key | null) => boolean;
+  /** Resolve a directional target without changing active state. */
+  readonly getNavigationKey: (direction: CollectionNavigationDirection, options?: CollectionNavigationOptions<Key>) => Key | null;
+  /** Move active state directionally and return the resulting target. */
+  readonly moveActive: (direction: CollectionNavigationDirection, options?: CollectionNavigationOptions<Key>) => Key | null;
+  /** Find the next locale-aware text match without changing active state. */
+  readonly findByTextValue: (query: string, options?: CollectionTextSearchOptions<Key>) => Key | null;
+  /** Move active state to the next locale-aware text match. */
+  readonly moveActiveByTextValue: (query: string, options?: CollectionTextSearchOptions<Key>) => Key | null;
+  /** Stop observation, clear items, and reject future mutations. */
+  readonly dispose: () => boolean;
+}
+//#endregion
+//#region src/collection-registry.d.ts
+/**
+ * Create an SSR-safe, mutation-aware registry for one compound collection.
+ *
+ * The registry never moves DOM focus itself. Consumers bind `activeKey` to
+ * roving tabindex or `aria-activedescendant`; synchronous recovery guarantees
+ * that removing or disabling the active item selects the next navigable item,
+ * then the previous one, before the mutation can leave focus state orphaned.
+ */
+declare function createCollectionRegistry<Key extends CollectionKey, Value>(options?: CollectionRegistryOptions<Key>): CollectionRegistry<Key, Value>;
+//#endregion
+//#region src/collection-text.d.ts
+/**
+ * Normalize authored or extracted typeahead text without applying a locale.
+ *
+ * Unicode is normalized to NFC and every whitespace run becomes one ASCII
+ * space. Locale-sensitive equality remains the responsibility of a collator.
+ */
+declare function normalizeCollectionTextValue(value: string): string;
+/**
+ * Extract a practical accessible text value from an item element.
+ *
+ * `aria-labelledby` and `aria-label` take precedence, hidden descendants are
+ * excluded unless explicitly referenced, and image/input fallbacks are
+ * included. Complex widgets should still provide `textValue` explicitly when
+ * their typeahead label differs from their accessible name.
+ */
+declare function extractCollectionTextValue(element: Element): string;
+//#endregion
+export { CollectionActiveChangeReason as a, CollectionItemInput as c, CollectionNavigationOptions as d, CollectionRegistration as f, CollectionTextSearchOptions as h, CollectionActiveChange as i, CollectionKey as l, CollectionRegistryOptions as m, normalizeCollectionTextValue as n, CollectionDisabledBehavior as o, CollectionRegistry as p, createCollectionRegistry as r, CollectionItem as s, extractCollectionTextValue as t, CollectionNavigationDirection as u };

package/dist/collection.d.mts

@@ -0,0 +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 };

package/dist/collection.mjs

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