@vizejs/ui 0.345.0 → 0.350.2

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-DkwZFC80.d.mts → checkbox-DP3_ko7D.d.mts}

@@ -1,5 +1,4 @@
-import { r as StateUpdate } from "./controllable-state-DXsYJ3yl.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-DkwZFC80.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-B_dFZOHO.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 };