@wow-two-beta/ui-vue 0.0.4 → 0.0.6

package/dist/chunks/UseNavigationProgress-Bx_MWd39.js

@@ -0,0 +1,51 @@
+import { inject, shallowRef, provide } from "vue";
+const NavigationProgressKey = Symbol("wow-two.navigation-progress");
+function createNavigationProgress() {
+  const count = shallowRef(0);
+  const begin = () => {
+    count.value += 1;
+    let ended = false;
+    return () => {
+      if (ended) return;
+      ended = true;
+      count.value = Math.max(0, count.value - 1);
+    };
+  };
+  const end = () => {
+    count.value = Math.max(0, count.value - 1);
+  };
+  const track = (promise) => {
+    const done = begin();
+    return promise.finally(done);
+  };
+  return {
+    get isBusy() {
+      return count.value > 0;
+    },
+    begin,
+    end,
+    track
+  };
+}
+function provideNavigationProgress(state = createNavigationProgress()) {
+  provide(NavigationProgressKey, state);
+  return state;
+}
+function useOptionalNavigationProgress() {
+  return inject(NavigationProgressKey, null);
+}
+function useNavigationProgress() {
+  const state = useOptionalNavigationProgress();
+  if (state === null) {
+    throw new Error("useNavigationProgress must be used within a <ProgressProvider>.");
+  }
+  return state;
+}
+export {
+  NavigationProgressKey as N,
+  useOptionalNavigationProgress as a,
+  createNavigationProgress as c,
+  provideNavigationProgress as p,
+  useNavigationProgress as u
+};
+//# sourceMappingURL=UseNavigationProgress-Bx_MWd39.js.map

package/dist/chunks/UseNavigationProgress-Bx_MWd39.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseNavigationProgress-Bx_MWd39.js","sources":["../../src/router/hooks/UseNavigationProgress.ts"],"sourcesContent":["import { inject, provide, shallowRef, type InjectionKey } from 'vue';\n\n/**\n * Defines the navigation-progress controls plus the ref-counted manual busy flag exposed to app code.\n *\n * `isBusy` is a REACTIVE PROPERTY — a native getter over the internal ref, the same shape `auth`'s\n * `AuthApi` uses. Read it in a template, a `computed`, or a `watch` and it re-evaluates; destructuring\n * (`const { isBusy } = useNavigationProgress()`) takes a one-time copy and will not update.\n */\nexport interface NavigationProgressState {\n  /** The ref-counted busy flag — true while at least one manual span is in flight. */\n  readonly isBusy: boolean;\n\n  /** Starts a manual busy span; returns an idempotent function that ends only that span. */\n  readonly begin: () => () => void;\n\n  /** Ends one manual busy span — the raw counterpart to `begin`, clamped at zero. */\n  readonly end: () => void;\n\n  /** Tracks a promise as a manual busy span — begins now, ends when it settles; resolves with the promise's value. */\n  readonly track: <T>(promise: Promise<T>) => Promise<T>;\n}\n\n/** The injection key backing `ProgressProvider` — React's `createContext(null)` counterpart. */\nexport const NavigationProgressKey: InjectionKey<NavigationProgressState> = Symbol('wow-two.navigation-progress');\n\n/**\n * Creates a standalone navigation-progress state — ref-counts manual busy spans. Headless and\n * component-free, so a plain module (a store, a test) can drive the indicator without mounting a\n * provider. `ProgressProvider` is this factory plus a `provide`.\n */\nexport function createNavigationProgress(): NavigationProgressState {\n  const count = shallowRef(0);\n\n  const begin = (): (() => void) => {\n    count.value += 1;\n    let ended = false;\n    return () => {\n      if (ended) return;\n      ended = true;\n      count.value = Math.max(0, count.value - 1);\n    };\n  };\n\n  const end = (): void => {\n    count.value = Math.max(0, count.value - 1);\n  };\n\n  const track = <T>(promise: Promise<T>): Promise<T> => {\n    const done = begin();\n    return promise.finally(done);\n  };\n\n  // Native getter over the counter ref — a read inside a template / computed / watch tracks it,\n  // so no re-created object is needed on each transition (React rebuilt the value via `useMemo`).\n  return {\n    get isBusy() {\n      return count.value > 0;\n    },\n    begin,\n    end,\n    track,\n  };\n}\n\n/** Provides a navigation-progress state to the current component's subtree; returns the state it provided. */\nexport function provideNavigationProgress(\n  state: NavigationProgressState = createNavigationProgress(),\n): NavigationProgressState {\n  provide(NavigationProgressKey, state);\n  return state;\n}\n\n/** @internal Reads the navigation-progress state, or null when used outside a `ProgressProvider`. */\nexport function useOptionalNavigationProgress(): NavigationProgressState | null {\n  return inject(NavigationProgressKey, null);\n}\n\n/** Provides access to the navigation-progress controls (begin / end / track) from the nearest `ProgressProvider`. */\nexport function useNavigationProgress(): NavigationProgressState {\n  const state = useOptionalNavigationProgress();\n  if (state === null) {\n    throw new Error('useNavigationProgress must be used within a <ProgressProvider>.');\n  }\n  return state;\n}\n"],"names":[],"mappings":";AAwBO,MAAM,wBAA+D,OAAO,6BAA6B;AAOzG,SAAS,2BAAoD;AAClE,QAAM,QAAQ,WAAW,CAAC;AAE1B,QAAM,QAAQ,MAAoB;AAChC,UAAM,SAAS;AACf,QAAI,QAAQ;AACZ,WAAO,MAAM;AACX,UAAI,MAAO;AACX,cAAQ;AACR,YAAM,QAAQ,KAAK,IAAI,GAAG,MAAM,QAAQ,CAAC;AAAA,IAC3C;AAAA,EACF;AAEA,QAAM,MAAM,MAAY;AACtB,UAAM,QAAQ,KAAK,IAAI,GAAG,MAAM,QAAQ,CAAC;AAAA,EAC3C;AAEA,QAAM,QAAQ,CAAI,YAAoC;AACpD,UAAM,OAAO,MAAA;AACb,WAAO,QAAQ,QAAQ,IAAI;AAAA,EAC7B;AAIA,SAAO;AAAA,IACL,IAAI,SAAS;AACX,aAAO,MAAM,QAAQ;AAAA,IACvB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAEJ;AAGO,SAAS,0BACd,QAAiC,4BACR;AACzB,UAAQ,uBAAuB,KAAK;AACpC,SAAO;AACT;AAGO,SAAS,gCAAgE;AAC9E,SAAO,OAAO,uBAAuB,IAAI;AAC3C;AAGO,SAAS,wBAAiD;AAC/D,QAAM,QAAQ,8BAAA;AACd,MAAI,UAAU,MAAM;AAClB,UAAM,IAAI,MAAM,iEAAiE;AAAA,EACnF;AACA,SAAO;AACT;"}

package/dist/chunks/UseOutsideClick-8TTSb9x6.js

@@ -0,0 +1,57 @@
+import { watchPostEffect, toValue } from "vue";
+const AttributeValue = {
+  /** Refers to the affirmative state — `aria-expanded="true"`, `data-copied="true"`. */
+  True: "true",
+  /** Refers to the explicit negative state, for attributes where absence is not the same as false. */
+  False: "false"
+};
+const DomEvent = {
+  /** Refers to a pointer or keyboard activation. */
+  Click: "click",
+  /** Refers to a committed value change — fires on blur for a native input. */
+  Change: "change",
+  /** Refers to a failed operation surfaced as an event. */
+  Error: "error",
+  /** Refers to a key press. */
+  KeyDown: "keydown",
+  /** Refers to a key release. */
+  KeyUp: "keyup",
+  /** Refers to a pointer contacting the element. */
+  PointerDown: "pointerdown",
+  /** Refers to a pointer releasing over the element. */
+  PointerUp: "pointerup",
+  /** Refers to a pointer leaving the element. */
+  PointerLeave: "pointerleave",
+  /** Refers to a pointer interaction the browser cancelled. */
+  PointerCancel: "pointercancel"
+};
+function useOutsideClick(targets, handler, enabled = true) {
+  const targetList = Array.isArray(targets) ? targets : [targets];
+  watchPostEffect((onCleanup) => {
+    if (!toValue(enabled) || typeof document === "undefined") return;
+    const documents = /* @__PURE__ */ new Set([document]);
+    for (const candidate of targetList) {
+      const owner = toValue(candidate)?.ownerDocument;
+      if (owner) documents.add(owner);
+    }
+    const onPointerDown = (e) => {
+      const target = e.target;
+      if (!target) return;
+      for (const candidate of targetList) {
+        const element = toValue(candidate);
+        if (element && (e.composedPath().includes(element) || element.contains(target))) return;
+      }
+      handler(e);
+    };
+    for (const owner of documents) owner.addEventListener("pointerdown", onPointerDown, true);
+    onCleanup(() => {
+      for (const owner of documents) owner.removeEventListener("pointerdown", onPointerDown, true);
+    });
+  });
+}
+export {
+  AttributeValue as A,
+  DomEvent as D,
+  useOutsideClick as u
+};
+//# sourceMappingURL=UseOutsideClick-8TTSb9x6.js.map

package/dist/chunks/UseOutsideClick-8TTSb9x6.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseOutsideClick-8TTSb9x6.js","sources":["../../src/foundation/dom/enums/AttributeValue.ts","../../src/foundation/dom/enums/DomEvent.ts","../../src/foundation/dom/hooks/UseOutsideClick.ts"],"sourcesContent":["/* Provides the literal strings a DOM attribute carries for a boolean state. */\n\n/** Defines the value a boolean DOM or ARIA attribute is set to. */\nexport const AttributeValue = {\n  /** Refers to the affirmative state — `aria-expanded=\"true\"`, `data-copied=\"true\"`. */\n  True: 'true',\n\n  /** Refers to the explicit negative state, for attributes where absence is not the same as false. */\n  False: 'false',\n} as const;\n\n/** Defines the value a boolean DOM or ARIA attribute is set to. */\nexport type AttributeValue = (typeof AttributeValue)[keyof typeof AttributeValue];\n","/* Provides the DOM event names components re-emit or intercept, plus the handler-prop derivation. */\n\n/** Defines a DOM event name. */\nexport const DomEvent = {\n  /** Refers to a pointer or keyboard activation. */\n  Click: 'click',\n\n  /** Refers to a committed value change — fires on blur for a native input. */\n  Change: 'change',\n\n  /** Refers to a failed operation surfaced as an event. */\n  Error: 'error',\n\n  /** Refers to a key press. */\n  KeyDown: 'keydown',\n\n  /** Refers to a key release. */\n  KeyUp: 'keyup',\n\n  /** Refers to a pointer contacting the element. */\n  PointerDown: 'pointerdown',\n\n  /** Refers to a pointer releasing over the element. */\n  PointerUp: 'pointerup',\n\n  /** Refers to a pointer leaving the element. */\n  PointerLeave: 'pointerleave',\n\n  /** Refers to a pointer interaction the browser cancelled. */\n  PointerCancel: 'pointercancel',\n} as const;\n\n/** Defines a DOM event name. */\nexport type DomEvent = (typeof DomEvent)[keyof typeof DomEvent];\n\n/** Defines the Vue handler-prop name carrying a DOM event — `'error'` becomes `'onError'`. */\nexport type HandlerProp<TEvent extends string> = `on${Capitalize<TEvent>}`;\n","import { toValue, watchPostEffect, type MaybeRefOrGetter } from 'vue';\n\n/** One element source — a template ref, a plain element, or a getter that resolves to either. */\nexport type OutsideClickTarget = MaybeRefOrGetter<HTMLElement | null | undefined>;\n\n/**\n * Fire `handler` when the user clicks outside any of the provided targets.\n * Uses `pointerdown` so it fires before focus shifts (avoids losing focus\n * inside an overlay before a click on a trigger registers).\n *\n * Pass a `useTemplateRef` (or an array of them) — each is resolved at event\n * time, so a target that mounts later is still honoured without re-attaching.\n */\nexport function useOutsideClick(\n  targets: OutsideClickTarget | ReadonlyArray<OutsideClickTarget>,\n  handler: (event: PointerEvent) => void,\n  enabled: MaybeRefOrGetter<boolean> = true,\n): void {\n  // `Array.isArray` does not narrow a `ReadonlyArray` union, hence the assertions.\n  const targetList: ReadonlyArray<OutsideClickTarget> = Array.isArray(targets)\n    ? (targets as ReadonlyArray<OutsideClickTarget>)\n    : [targets as OutsideClickTarget];\n\n  watchPostEffect((onCleanup) => {\n    if (!toValue(enabled) || typeof document === 'undefined') return;\n\n    const documents = new Set([document]);\n    for (const candidate of targetList) {\n      const owner = toValue(candidate)?.ownerDocument;\n      if (owner) documents.add(owner);\n    }\n\n    const onPointerDown = (e: PointerEvent): void => {\n      const target = e.target as Node | null;\n      if (!target) return;\n      for (const candidate of targetList) {\n        const element = toValue(candidate);\n        if (element && (e.composedPath().includes(element) || element.contains(target))) return;\n      }\n      handler(e);\n    };\n\n    for (const owner of documents) owner.addEventListener('pointerdown', onPointerDown, true);\n    onCleanup(() => {\n      for (const owner of documents) owner.removeEventListener('pointerdown', onPointerDown, true);\n    });\n  });\n}\n"],"names":[],"mappings":";AAGO,MAAM,iBAAiB;AAAA;AAAA,EAE5B,MAAM;AAAA;AAAA,EAGN,OAAO;AACT;ACNO,MAAM,WAAW;AAAA;AAAA,EAEtB,OAAO;AAAA;AAAA,EAGP,QAAQ;AAAA;AAAA,EAGR,OAAO;AAAA;AAAA,EAGP,SAAS;AAAA;AAAA,EAGT,OAAO;AAAA;AAAA,EAGP,aAAa;AAAA;AAAA,EAGb,WAAW;AAAA;AAAA,EAGX,cAAc;AAAA;AAAA,EAGd,eAAe;AACjB;ACjBO,SAAS,gBACd,SACA,SACA,UAAqC,MAC/B;AAEN,QAAM,aAAgD,MAAM,QAAQ,OAAO,IACtE,UACD,CAAC,OAA6B;AAElC,kBAAgB,CAAC,cAAc;AAC7B,QAAI,CAAC,QAAQ,OAAO,KAAK,OAAO,aAAa,YAAa;AAE1D,UAAM,YAAY,oBAAI,IAAI,CAAC,QAAQ,CAAC;AACpC,eAAW,aAAa,YAAY;AAClC,YAAM,QAAQ,QAAQ,SAAS,GAAG;AAClC,UAAI,MAAO,WAAU,IAAI,KAAK;AAAA,IAChC;AAEA,UAAM,gBAAgB,CAAC,MAA0B;AAC/C,YAAM,SAAS,EAAE;AACjB,UAAI,CAAC,OAAQ;AACb,iBAAW,aAAa,YAAY;AAClC,cAAM,UAAU,QAAQ,SAAS;AACjC,YAAI,YAAY,EAAE,aAAA,EAAe,SAAS,OAAO,KAAK,QAAQ,SAAS,MAAM,GAAI;AAAA,MACnF;AACA,cAAQ,CAAC;AAAA,IACX;AAEA,eAAW,SAAS,UAAW,OAAM,iBAAiB,eAAe,eAAe,IAAI;AACxF,cAAU,MAAM;AACd,iBAAW,SAAS,UAAW,OAAM,oBAAoB,eAAe,eAAe,IAAI;AAAA,IAC7F,CAAC;AAAA,EACH,CAAC;AACH;"}

package/dist/chunks/UseRecentItems-Bgj28t5Y.js

@@ -0,0 +1,63 @@
+import { shallowRef, computed, onMounted, watch, toValue, onScopeDispose } from "vue";
+import { l as localStorageStorageBroker } from "./StorageBroker-COC81ZGB.js";
+function canSyncAcrossTabs(broker) {
+  return broker === localStorageStorageBroker && typeof window !== "undefined";
+}
+function usePersistentState(key, initial, options) {
+  const broker = options?.broker ?? localStorageStorageBroker;
+  const state = shallowRef(initial);
+  const setValue = (next) => {
+    const resolved = typeof next === "function" ? next(state.value) : next;
+    broker.write(toValue(key), resolved);
+    state.value = resolved;
+  };
+  const value = computed({
+    get: () => state.value,
+    set: setValue
+  });
+  function hydrate() {
+    const persisted = broker.read(toValue(key));
+    state.value = persisted ?? initial;
+  }
+  onMounted(hydrate);
+  watch(() => toValue(key), hydrate, { flush: "sync" });
+  let detachStorage = null;
+  onMounted(() => {
+    if (!canSyncAcrossTabs(broker)) return;
+    function onStorage(event) {
+      const currentKey = toValue(key);
+      if (event.storageArea !== null && event.storageArea !== window.localStorage) return;
+      if (event.key !== null && event.key !== currentKey) return;
+      state.value = event.newValue === null ? initial : broker.read(currentKey) ?? initial;
+    }
+    window.addEventListener("storage", onStorage);
+    detachStorage = () => window.removeEventListener("storage", onStorage);
+  });
+  onScopeDispose(() => {
+    detachStorage?.();
+    detachStorage = null;
+  });
+  return { value, setValue };
+}
+const DefaultMax = 24;
+function prependRecent(items, item, identify, max) {
+  const id = identify(item);
+  const withoutDuplicate = items.filter((existing) => identify(existing) !== id);
+  return [item, ...withoutDuplicate].slice(0, Math.max(0, max));
+}
+function useRecentItems(key, options) {
+  const { identify, max = DefaultMax, broker } = options;
+  const state = usePersistentState(key, [], { broker });
+  const recents = computed(() => state.value.value);
+  const push = (item) => {
+    state.setValue((previous) => prependRecent(previous, item, identify, toValue(max)));
+  };
+  const clear = () => state.setValue([]);
+  return { recents, push, clear };
+}
+export {
+  useRecentItems as a,
+  prependRecent as p,
+  usePersistentState as u
+};
+//# sourceMappingURL=UseRecentItems-Bgj28t5Y.js.map

package/dist/chunks/UseRecentItems-Bgj28t5Y.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseRecentItems-Bgj28t5Y.js","sources":["../../src/foundation/storage/hooks/UsePersistentState.ts","../../src/foundation/storage/hooks/UseRecentItems.ts"],"sourcesContent":["import {\n  computed,\n  onMounted,\n  onScopeDispose,\n  shallowRef,\n  toValue,\n  watch,\n  type MaybeRefOrGetter,\n  type ShallowRef,\n  type WritableComputedRef,\n} from 'vue';\n\nimport { localStorageStorageBroker, type StorageBroker } from '../StorageBroker';\n\n/** Defines the options that tune where and how `usePersistentState` persists. */\nexport interface PersistentStateOptions {\n  /** The persistence seam to read and write through; defaults to `localStorageStorageBroker`. */\n  readonly broker?: StorageBroker;\n}\n\n/** A setter that accepts a next value or an updater fn, mirroring the original's `useState` dispatch. */\nexport type SetPersistentState<T> = (next: T | ((previous: T) => T)) => void;\n\n/** The persistent-state handle — a writable value plus the updater-accepting setter it delegates to. */\nexport interface PersistentState<T> {\n  /**\n   * The live value. Writable: `value.value = next` runs the same write-through path as `setValue(next)`.\n   * A writable computed rather than a plain ref, so persistence is driven by the assignment itself —\n   * mutating a nested field in place does not persist, exactly as the original required a setter call.\n   */\n  readonly value: WritableComputedRef<T>;\n\n  /** Sets the next value — or derives it from the previous one — and writes it through the broker. */\n  readonly setValue: SetPersistentState<T>;\n}\n\n/**\n * Resolves whether cross-tab sync is available — the `storage` event fires only for the shared\n * `localStorage`, and only in a browser.\n */\nfunction canSyncAcrossTabs(broker: StorageBroker): boolean {\n  return broker === localStorageStorageBroker && typeof window !== 'undefined';\n}\n\n/**\n * Manages a piece of state mirrored into a `StorageBroker` under `key`. Hydrates from the broker on\n * mount (SSR-safe: the first render always uses `initial`, then a mount hook adopts any persisted value, so\n * server and client markup match), writes through on every set, and — when backed by `localStorage` —\n * adopts writes from other tabs via the window `storage` event.\n *\n * Returns `{ value, setValue }` rather than a tuple: `value` is writable (`state.value = next`), and\n * `setValue` is kept because it additionally accepts an updater fn. `key` may be a ref or getter — changing\n * it re-hydrates from the new slot.\n */\nexport function usePersistentState<T>(\n  key: MaybeRefOrGetter<string>,\n  initial: T,\n  options?: PersistentStateOptions,\n): PersistentState<T> {\n  const broker = options?.broker ?? localStorageStorageBroker;\n\n  // `initial` is the first-paint value on both server and client; a mount hook reconciles it with storage,\n  // so hydration never diverges. Cast: `shallowRef`'s return type is a conditional over an unresolved `T`.\n  const state = shallowRef(initial) as ShallowRef<T>;\n\n  const setValue: SetPersistentState<T> = (next) => {\n    const resolved = typeof next === 'function' ? (next as (previous: T) => T)(state.value) : (next as T);\n    broker.write(toValue(key), resolved);\n    state.value = resolved;\n  };\n\n  const value = computed<T>({\n    get: () => state.value,\n    set: setValue,\n  });\n\n  /** Adopts the persisted value for the current key — a hit wins over what is held, a miss leaves it alone. */\n  function hydrate(): void {\n    const persisted = broker.read<T>(toValue(key));\n    state.value = persisted ?? initial;\n  }\n\n  onMounted(hydrate);\n  // A key swap re-reads from the new slot. Adoption assigns `state` directly, never through `setValue`, so\n  // reading a value never writes it back.\n  watch(() => toValue(key), hydrate, { flush: 'sync' });\n\n  // Adopt writes made under the same key in another tab. Guarded so a non-localStorage or SSR context attaches\n  // no listener. `event.newValue === null` means the key was removed elsewhere — fall back to `initial`.\n  let detachStorage: (() => void) | null = null;\n\n  onMounted(() => {\n    if (!canSyncAcrossTabs(broker)) return;\n\n    function onStorage(event: StorageEvent): void {\n      const currentKey = toValue(key);\n      if (event.storageArea !== null && event.storageArea !== window.localStorage) return;\n      if (event.key !== null && event.key !== currentKey) return;\n      state.value = event.newValue === null ? initial : (broker.read<T>(currentKey) ?? initial);\n    }\n\n    window.addEventListener('storage', onStorage);\n    detachStorage = () => window.removeEventListener('storage', onStorage);\n  });\n\n  // Registered at setup level — `onScopeDispose` only binds to the component's effect scope while that scope\n  // is current, which it is not inside `onMounted`.\n  onScopeDispose(() => {\n    detachStorage?.();\n    detachStorage = null;\n  });\n\n  return { value, setValue };\n}\n","import { computed, toValue, type ComputedRef, type MaybeRefOrGetter } from 'vue';\n\nimport { type StorageBroker } from '../StorageBroker';\nimport { usePersistentState } from './UsePersistentState';\n\n/** The default cap on retained recents, applied when `max` is omitted. */\nconst DefaultMax = 24;\n\n/** Defines the options that configure a recent-items list — identity, cap, and the persistence seam. */\nexport interface RecentItemsOptions<T> {\n  /** Derives a stable de-duplication key for an item; re-pushing a matching item moves it to the front. */\n  readonly identify: (item: T) => string;\n\n  /** The maximum number of items retained, most-recent-first; defaults to 24. */\n  readonly max?: MaybeRefOrGetter<number>;\n\n  /** The persistence seam the list stores through. Defaults to `localStorageStorageBroker` via `usePersistentState`. */\n  readonly broker?: StorageBroker;\n}\n\n/** Represents a most-recently-used list plus the operations that mutate it. */\nexport interface RecentItems<T> {\n  /** The retained items, most-recent-first. */\n  readonly recents: ComputedRef<ReadonlyArray<T>>;\n\n  /** Records `item` as the most recent — de-duplicated by identity and capped at `max`. */\n  readonly push: (item: T) => void;\n\n  /** Empties the list. */\n  readonly clear: () => void;\n}\n\n/**\n * Prepends `item` to `items` as the most recent, de-duplicating by `identify` (an existing match is removed so\n * the item resurfaces at the front) and capping the result to `max`. Pure — the reducer the composable writes\n * through its adapter.\n */\nexport function prependRecent<T>(\n  items: ReadonlyArray<T>,\n  item: T,\n  identify: (item: T) => string,\n  max: number,\n): ReadonlyArray<T> {\n  const id = identify(item);\n  const withoutDuplicate = items.filter((existing) => identify(existing) !== id);\n  return [item, ...withoutDuplicate].slice(0, Math.max(0, max));\n}\n\n/**\n * Manages a persisted most-recently-used list under `key`, layered on `usePersistentState`. `push` records an\n * item at the front, de-duplicated by `identify` and capped at `max` (default 24); `clear` empties it. The list\n * inherits the underlying composable's hydrate-on-mount, write-through, and cross-tab sync.\n *\n * `recents` is a read-only computed — mutate the list through `push` / `clear`, never in place.\n */\nexport function useRecentItems<T>(key: MaybeRefOrGetter<string>, options: RecentItemsOptions<T>): RecentItems<T> {\n  const { identify, max = DefaultMax, broker } = options;\n\n  const state = usePersistentState<ReadonlyArray<T>>(key, [], { broker });\n\n  const recents = computed<ReadonlyArray<T>>(() => state.value.value);\n\n  const push = (item: T): void => {\n    state.setValue((previous) => prependRecent(previous, item, identify, toValue(max)));\n  };\n\n  const clear = (): void => state.setValue([]);\n\n  return { recents, push, clear };\n}\n"],"names":[],"mappings":";;AAwCA,SAAS,kBAAkB,QAAgC;AACzD,SAAO,WAAW,6BAA6B,OAAO,WAAW;AACnE;AAYO,SAAS,mBACd,KACA,SACA,SACoB;AACpB,QAAM,SAAS,SAAS,UAAU;AAIlC,QAAM,QAAQ,WAAW,OAAO;AAEhC,QAAM,WAAkC,CAAC,SAAS;AAChD,UAAM,WAAW,OAAO,SAAS,aAAc,KAA4B,MAAM,KAAK,IAAK;AAC3F,WAAO,MAAM,QAAQ,GAAG,GAAG,QAAQ;AACnC,UAAM,QAAQ;AAAA,EAChB;AAEA,QAAM,QAAQ,SAAY;AAAA,IACxB,KAAK,MAAM,MAAM;AAAA,IACjB,KAAK;AAAA,EAAA,CACN;AAGD,WAAS,UAAgB;AACvB,UAAM,YAAY,OAAO,KAAQ,QAAQ,GAAG,CAAC;AAC7C,UAAM,QAAQ,aAAa;AAAA,EAC7B;AAEA,YAAU,OAAO;AAGjB,QAAM,MAAM,QAAQ,GAAG,GAAG,SAAS,EAAE,OAAO,QAAQ;AAIpD,MAAI,gBAAqC;AAEzC,YAAU,MAAM;AACd,QAAI,CAAC,kBAAkB,MAAM,EAAG;AAEhC,aAAS,UAAU,OAA2B;AAC5C,YAAM,aAAa,QAAQ,GAAG;AAC9B,UAAI,MAAM,gBAAgB,QAAQ,MAAM,gBAAgB,OAAO,aAAc;AAC7E,UAAI,MAAM,QAAQ,QAAQ,MAAM,QAAQ,WAAY;AACpD,YAAM,QAAQ,MAAM,aAAa,OAAO,UAAW,OAAO,KAAQ,UAAU,KAAK;AAAA,IACnF;AAEA,WAAO,iBAAiB,WAAW,SAAS;AAC5C,oBAAgB,MAAM,OAAO,oBAAoB,WAAW,SAAS;AAAA,EACvE,CAAC;AAID,iBAAe,MAAM;AACnB,oBAAA;AACA,oBAAgB;AAAA,EAClB,CAAC;AAED,SAAO,EAAE,OAAO,SAAA;AAClB;AC3GA,MAAM,aAAa;AA+BZ,SAAS,cACd,OACA,MACA,UACA,KACkB;AAClB,QAAM,KAAK,SAAS,IAAI;AACxB,QAAM,mBAAmB,MAAM,OAAO,CAAC,aAAa,SAAS,QAAQ,MAAM,EAAE;AAC7E,SAAO,CAAC,MAAM,GAAG,gBAAgB,EAAE,MAAM,GAAG,KAAK,IAAI,GAAG,GAAG,CAAC;AAC9D;AASO,SAAS,eAAkB,KAA+B,SAAgD;AAC/G,QAAM,EAAE,UAAU,MAAM,YAAY,WAAW;AAE/C,QAAM,QAAQ,mBAAqC,KAAK,CAAA,GAAI,EAAE,QAAQ;AAEtE,QAAM,UAAU,SAA2B,MAAM,MAAM,MAAM,KAAK;AAElE,QAAM,OAAO,CAAC,SAAkB;AAC9B,UAAM,SAAS,CAAC,aAAa,cAAc,UAAU,MAAM,UAAU,QAAQ,GAAG,CAAC,CAAC;AAAA,EACpF;AAEA,QAAM,QAAQ,MAAY,MAAM,SAAS,CAAA,CAAE;AAE3C,SAAO,EAAE,SAAS,MAAM,MAAA;AAC1B;"}

package/dist/chunks/UseReducedMotion-NZ5fg-Xb.js

@@ -0,0 +1,36 @@
+import { shallowRef, onMounted, watch, toValue, onScopeDispose } from "vue";
+function subscribeMediaQuery(query, onChange) {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") return () => void 0;
+  const list = window.matchMedia(query);
+  const listener = (event) => onChange(event.matches);
+  list.addEventListener("change", listener);
+  onChange(list.matches);
+  return () => list.removeEventListener("change", listener);
+}
+function useMediaQuery(query) {
+  const matches = shallowRef(false);
+  let dispose;
+  function unsubscribe() {
+    dispose?.();
+    dispose = void 0;
+  }
+  function subscribe() {
+    unsubscribe();
+    dispose = subscribeMediaQuery(toValue(query), (value) => {
+      matches.value = value;
+    });
+  }
+  onMounted(subscribe);
+  watch(() => toValue(query), subscribe);
+  onScopeDispose(unsubscribe);
+  return matches;
+}
+function useReducedMotion() {
+  return useMediaQuery("(prefers-reduced-motion: reduce)");
+}
+export {
+  useMediaQuery as a,
+  subscribeMediaQuery as s,
+  useReducedMotion as u
+};
+//# sourceMappingURL=UseReducedMotion-NZ5fg-Xb.js.map

package/dist/chunks/UseReducedMotion-NZ5fg-Xb.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseReducedMotion-NZ5fg-Xb.js","sources":["../../src/foundation/device/hooks/UseMediaQuery.ts","../../src/foundation/device/hooks/UseReducedMotion.ts"],"sourcesContent":["import { onMounted, onScopeDispose, shallowRef, toValue, watch, type MaybeRefOrGetter, type ShallowRef } from 'vue';\n\n/**\n * Reactively follow a CSS media query. Pass a query string like\n * `'(min-width: 768px)'` or `'(prefers-reduced-motion: reduce)'`, or a ref /\n * getter when the query itself changes.\n *\n * SSR-safe — the ref holds `false` on the server and during the first render,\n * then syncs to the real value once mounted. The subscription is the Vue\n * counterpart of the original's `useSyncExternalStore`: subscribe on mount,\n * unsubscribe when the scope is disposed.\n */\n/** Subscribes to one media query and reports its initial browser value. */\nexport function subscribeMediaQuery(query: string, onChange: (matches: boolean) => void): () => void {\n  if (typeof window === 'undefined' || typeof window.matchMedia !== 'function') return () => undefined;\n  const list = window.matchMedia(query);\n  const listener = (event: MediaQueryListEvent): void => onChange(event.matches);\n  list.addEventListener('change', listener);\n  onChange(list.matches);\n  return () => list.removeEventListener('change', listener);\n}\n\nexport function useMediaQuery(query: MaybeRefOrGetter<string>): Readonly<ShallowRef<boolean>> {\n  const matches = shallowRef(false);\n\n  let dispose: (() => void) | undefined;\n  function unsubscribe(): void {\n    dispose?.();\n    dispose = undefined;\n  }\n  function subscribe(): void {\n    unsubscribe();\n    dispose = subscribeMediaQuery(toValue(query), (value) => {\n      matches.value = value;\n    });\n  }\n  onMounted(subscribe);\n  // A changed query is a new subscription; `subscribe` drops the old listener first.\n  watch(() => toValue(query), subscribe);\n  onScopeDispose(unsubscribe);\n\n  return matches;\n}\n","import type { ShallowRef } from 'vue';\n\nimport { useMediaQuery } from './UseMediaQuery';\n\n/**\n * Returns a ref that is `true` when the user has requested reduced motion via\n * OS settings. Components should short-circuit looping/transitional animations\n * to a static final state when it is `true`.\n */\nexport function useReducedMotion(): Readonly<ShallowRef<boolean>> {\n  return useMediaQuery('(prefers-reduced-motion: reduce)');\n}\n"],"names":[],"mappings":";AAaO,SAAS,oBAAoB,OAAe,UAAkD;AACnG,MAAI,OAAO,WAAW,eAAe,OAAO,OAAO,eAAe,mBAAmB,MAAM;AAC3F,QAAM,OAAO,OAAO,WAAW,KAAK;AACpC,QAAM,WAAW,CAAC,UAAqC,SAAS,MAAM,OAAO;AAC7E,OAAK,iBAAiB,UAAU,QAAQ;AACxC,WAAS,KAAK,OAAO;AACrB,SAAO,MAAM,KAAK,oBAAoB,UAAU,QAAQ;AAC1D;AAEO,SAAS,cAAc,OAAgE;AAC5F,QAAM,UAAU,WAAW,KAAK;AAEhC,MAAI;AACJ,WAAS,cAAoB;AAC3B,cAAA;AACA,cAAU;AAAA,EACZ;AACA,WAAS,YAAkB;AACzB,gBAAA;AACA,cAAU,oBAAoB,QAAQ,KAAK,GAAG,CAAC,UAAU;AACvD,cAAQ,QAAQ;AAAA,IAClB,CAAC;AAAA,EACH;AACA,YAAU,SAAS;AAEnB,QAAM,MAAM,QAAQ,KAAK,GAAG,SAAS;AACrC,iBAAe,WAAW;AAE1B,SAAO;AACT;ACjCO,SAAS,mBAAkD;AAChE,SAAO,cAAc,kCAAkC;AACzD;"}

package/dist/chunks/UseResizeObserver-BUU7lC-n.js

@@ -0,0 +1,17 @@
+import { watchPostEffect, toValue } from "vue";
+function useResizeObserver(target, callback, enabled = true) {
+  watchPostEffect((onCleanup) => {
+    const element = toValue(target);
+    if (!toValue(enabled) || !element || typeof ResizeObserver === "undefined") return;
+    const observer = new ResizeObserver((entries) => {
+      const entry = entries[0];
+      if (entry) callback(entry);
+    });
+    observer.observe(element);
+    onCleanup(() => observer.disconnect());
+  });
+}
+export {
+  useResizeObserver as u
+};
+//# sourceMappingURL=UseResizeObserver-BUU7lC-n.js.map

package/dist/chunks/UseResizeObserver-BUU7lC-n.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseResizeObserver-BUU7lC-n.js","sources":["../../src/foundation/observers/hooks/UseResizeObserver.ts"],"sourcesContent":["import { toValue, watchPostEffect, type MaybeRefOrGetter } from 'vue';\n\n/**\n * Run `callback` whenever the referenced element's size changes. The effect is\n * post-flush, so the element is in the DOM (and laid out) before the observer\n * attaches. Disconnects automatically when the element changes, `enabled`\n * flips, or the scope is disposed.\n *\n * Takes the element as a ref or getter rather than handing one back, so the\n * caller keeps ownership of its `useTemplateRef`.\n */\nexport function useResizeObserver<T extends HTMLElement = HTMLElement>(\n  target: MaybeRefOrGetter<T | null | undefined>,\n  callback: (entry: ResizeObserverEntry) => void,\n  enabled: MaybeRefOrGetter<boolean> = true,\n): void {\n  watchPostEffect((onCleanup) => {\n    const element = toValue(target);\n    if (!toValue(enabled) || !element || typeof ResizeObserver === 'undefined') return;\n    const observer = new ResizeObserver((entries) => {\n      const entry = entries[0];\n      if (entry) callback(entry);\n    });\n    observer.observe(element);\n    onCleanup(() => observer.disconnect());\n  });\n}\n"],"names":[],"mappings":";AAWO,SAAS,kBACd,QACA,UACA,UAAqC,MAC/B;AACN,kBAAgB,CAAC,cAAc;AAC7B,UAAM,UAAU,QAAQ,MAAM;AAC9B,QAAI,CAAC,QAAQ,OAAO,KAAK,CAAC,WAAW,OAAO,mBAAmB,YAAa;AAC5E,UAAM,WAAW,IAAI,eAAe,CAAC,YAAY;AAC/C,YAAM,QAAQ,QAAQ,CAAC;AACvB,UAAI,gBAAgB,KAAK;AAAA,IAC3B,CAAC;AACD,aAAS,QAAQ,OAAO;AACxB,cAAU,MAAM,SAAS,YAAY;AAAA,EACvC,CAAC;AACH;"}

package/dist/chunks/UseScrollLock-DSk4L9xF.js

@@ -0,0 +1,38 @@
+import { watchPostEffect, toValue } from "vue";
+let lockCount = 0;
+let originalOverflow = null;
+let originalPaddingRight = null;
+function getScrollbarWidth() {
+  return window.innerWidth - document.documentElement.clientWidth;
+}
+function useScrollLock(enabled = true) {
+  watchPostEffect((onCleanup) => {
+    if (!toValue(enabled) || typeof document === "undefined") return;
+    if (lockCount === 0) {
+      const body = document.body;
+      const scrollbarWidth = getScrollbarWidth();
+      originalOverflow = body.style.overflow;
+      originalPaddingRight = body.style.paddingRight;
+      body.style.overflow = "hidden";
+      if (scrollbarWidth > 0) {
+        const padding = Number.parseFloat(window.getComputedStyle(body).paddingRight) || 0;
+        body.style.paddingRight = `${padding + scrollbarWidth}px`;
+      }
+    }
+    lockCount += 1;
+    onCleanup(() => {
+      lockCount -= 1;
+      if (lockCount === 0) {
+        const body = document.body;
+        body.style.overflow = originalOverflow ?? "";
+        body.style.paddingRight = originalPaddingRight ?? "";
+        originalOverflow = null;
+        originalPaddingRight = null;
+      }
+    });
+  });
+}
+export {
+  useScrollLock as u
+};
+//# sourceMappingURL=UseScrollLock-DSk4L9xF.js.map

package/dist/chunks/UseScrollLock-DSk4L9xF.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseScrollLock-DSk4L9xF.js","sources":["../../src/foundation/dom/hooks/UseScrollLock.ts"],"sourcesContent":["import { toValue, watchPostEffect, type MaybeRefOrGetter } from 'vue';\n\nlet lockCount = 0;\nlet originalOverflow: string | null = null;\nlet originalPaddingRight: string | null = null;\n\nfunction getScrollbarWidth(): number {\n  return window.innerWidth - document.documentElement.clientWidth;\n}\n\n/**\n * Prevent body scroll while at least one consumer has the lock active.\n * Internally counted — multiple overlays may lock; only the last unlock restores.\n * Compensates for scrollbar width to avoid layout shift.\n *\n * `enabled` may be a ref or a getter (`() => props.isEnabled`), so the lock\n * follows a prop without the consumer re-invoking anything. The counter is\n * module-level and shared, exactly as in the original.\n */\nexport function useScrollLock(enabled: MaybeRefOrGetter<boolean> = true): void {\n  watchPostEffect((onCleanup) => {\n    if (!toValue(enabled) || typeof document === 'undefined') return;\n    if (lockCount === 0) {\n      const body = document.body;\n      const scrollbarWidth = getScrollbarWidth();\n      originalOverflow = body.style.overflow;\n      originalPaddingRight = body.style.paddingRight;\n      body.style.overflow = 'hidden';\n      if (scrollbarWidth > 0) {\n        const padding = Number.parseFloat(window.getComputedStyle(body).paddingRight) || 0;\n        body.style.paddingRight = `${padding + scrollbarWidth}px`;\n      }\n    }\n    lockCount += 1;\n\n    onCleanup(() => {\n      lockCount -= 1;\n      if (lockCount === 0) {\n        const body = document.body;\n        body.style.overflow = originalOverflow ?? '';\n        body.style.paddingRight = originalPaddingRight ?? '';\n        originalOverflow = null;\n        originalPaddingRight = null;\n      }\n    });\n  });\n}\n"],"names":[],"mappings":";AAEA,IAAI,YAAY;AAChB,IAAI,mBAAkC;AACtC,IAAI,uBAAsC;AAE1C,SAAS,oBAA4B;AACnC,SAAO,OAAO,aAAa,SAAS,gBAAgB;AACtD;AAWO,SAAS,cAAc,UAAqC,MAAY;AAC7E,kBAAgB,CAAC,cAAc;AAC7B,QAAI,CAAC,QAAQ,OAAO,KAAK,OAAO,aAAa,YAAa;AAC1D,QAAI,cAAc,GAAG;AACnB,YAAM,OAAO,SAAS;AACtB,YAAM,iBAAiB,kBAAA;AACvB,yBAAmB,KAAK,MAAM;AAC9B,6BAAuB,KAAK,MAAM;AAClC,WAAK,MAAM,WAAW;AACtB,UAAI,iBAAiB,GAAG;AACtB,cAAM,UAAU,OAAO,WAAW,OAAO,iBAAiB,IAAI,EAAE,YAAY,KAAK;AACjF,aAAK,MAAM,eAAe,GAAG,UAAU,cAAc;AAAA,MACvD;AAAA,IACF;AACA,iBAAa;AAEb,cAAU,MAAM;AACd,mBAAa;AACb,UAAI,cAAc,GAAG;AACnB,cAAM,OAAO,SAAS;AACtB,aAAK,MAAM,WAAW,oBAAoB;AAC1C,aAAK,MAAM,eAAe,wBAAwB;AAClD,2BAAmB;AACnB,+BAAuB;AAAA,MACzB;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AACH;"}

package/dist/chunks/UseTypeahead-C-y7nBo2.js

@@ -0,0 +1,82 @@
+import { onScopeDispose, watch, toValue } from "vue";
+function isPrintableKey(event) {
+  if (event.ctrlKey || event.metaKey || event.altKey) return false;
+  return event.key.length === 1;
+}
+function isAllSameChar(buffer) {
+  return buffer.length > 0 && [...buffer].every((c) => c === buffer[0]);
+}
+function useTypeahead(options) {
+  let buffer = "";
+  let timer = null;
+  const isEnabled = () => toValue(options.enabled ?? true);
+  function clearTimer() {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  }
+  function reset() {
+    buffer = "";
+    clearTimer();
+  }
+  onScopeDispose(clearTimer);
+  function onKeyDown(event) {
+    if (!isEnabled() || event.isComposing) return false;
+    if (!isPrintableKey(event)) return false;
+    const isSpace = event.key === " ";
+    const hasBuffer = buffer.length > 0;
+    if (isSpace && !hasBuffer) return false;
+    const list = toValue(options.items);
+    if (list.length === 0) return false;
+    const nextBuffer = buffer + event.key;
+    buffer = nextBuffer;
+    clearTimer();
+    timer = setTimeout(
+      () => {
+        buffer = "";
+        timer = null;
+      },
+      toValue(options.timeout ?? 500)
+    );
+    const labelOf = (item) => options.getLabel(item).toLowerCase();
+    const disabledOf = (item) => options.isDisabled ? options.isDisabled(item) : false;
+    const startFrom = options.getActiveIndex ? options.getActiveIndex() : -1;
+    let matchIndex = -1;
+    if (isAllSameChar(nextBuffer)) {
+      const char = nextBuffer[0].toLowerCase();
+      for (let step = 1; step <= list.length; step += 1) {
+        const idx = (startFrom + step + list.length) % list.length;
+        const item = list[idx];
+        if (!disabledOf(item) && labelOf(item).startsWith(char)) {
+          matchIndex = idx;
+          break;
+        }
+      }
+    } else {
+      const prefix = nextBuffer.toLowerCase();
+      const begin = startFrom < 0 ? 0 : startFrom;
+      for (let step = 0; step < list.length; step += 1) {
+        const idx = (begin + step) % list.length;
+        const item = list[idx];
+        if (!disabledOf(item) && labelOf(item).startsWith(prefix)) {
+          matchIndex = idx;
+          break;
+        }
+      }
+    }
+    if (matchIndex >= 0) {
+      options.onMatch(list[matchIndex], matchIndex);
+      return true;
+    }
+    return true;
+  }
+  watch(isEnabled, (nowEnabled) => {
+    if (!nowEnabled) reset();
+  });
+  return { onKeyDown, reset };
+}
+export {
+  useTypeahead as u
+};
+//# sourceMappingURL=UseTypeahead-C-y7nBo2.js.map

package/dist/chunks/UseTypeahead-C-y7nBo2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseTypeahead-C-y7nBo2.js","sources":["../../src/foundation/selection/hooks/UseTypeahead.ts"],"sourcesContent":["import { onScopeDispose, toValue, watch, type MaybeRefOrGetter } from 'vue';\n\n/** Resolves the typeahead item pool — a static array, a ref, or a getter read lazily on each keystroke. */\ntype ItemSource<T> = MaybeRefOrGetter<ReadonlyArray<T>>;\n\n/** Configures {@link useTypeahead}. `T` is the item type the caller stores per option. */\nexport interface UseTypeaheadOptions<T> {\n  /** Supplies the items to match against; a ref or function is re-read on every keystroke (live lists). */\n  items: ItemSource<T>;\n\n  /** Extracts the comparable label from an item. Matching is case-insensitive on this string. */\n  getLabel: (item: T) => string;\n\n  /** Reports whether an item is disabled; disabled items are skipped during matching. */\n  isDisabled?: (item: T) => boolean;\n\n  /** Fires with the matched item and its index in the (live) item array when a keystroke resolves. */\n  onMatch: (item: T, index: number) => void;\n\n  /** Returns the index of the currently-active item — same-letter cycling starts after it. */\n  getActiveIndex?: () => number;\n\n  /** Disables the matcher when `false`; every key falls through unhandled. Defaults to `true`. */\n  enabled?: MaybeRefOrGetter<boolean>;\n\n  /** Idle time (ms) after which the typed buffer resets. Defaults to `500`. */\n  timeout?: MaybeRefOrGetter<number>;\n}\n\n/** The keyboard handler + manual reset returned by {@link useTypeahead}. */\nexport interface UseTypeaheadReturn {\n  /** Feeds a keydown into the matcher. Returns `true` when consumed (caller should stop), else `false`. */\n  onKeyDown: (event: KeyboardEvent) => boolean;\n\n  /** Clears the typed buffer immediately (e.g. on blur / close). */\n  reset: () => void;\n}\n\n/** Reports whether a key event carries a single printable character (and no command modifier). */\nfunction isPrintableKey(event: KeyboardEvent): boolean {\n  if (event.ctrlKey || event.metaKey || event.altKey) return false;\n  // Printable keys surface as a single char in `key`; named keys (Enter, ArrowDown…) are multi-char.\n  return event.key.length === 1;\n}\n\n/** Reports whether every char in the buffer is the same letter — the \"cycle\" case (e.g. \"aaa\"). */\nfunction isAllSameChar(buffer: string): boolean {\n  return buffer.length > 0 && [...buffer].every((c) => c === buffer[0]);\n}\n\n/**\n * APG-correct type-to-select matcher (WAI-ARIA listbox/combobox typeahead). Accumulates printable\n * chars into a buffer (resets after `timeout` ms idle): a repeated single char cycles to the next\n * label starting with it (after `getActiveIndex()`, wrap-around), else prefix-matches the whole\n * buffer case-insensitively; disabled items skipped. On a hit `onMatch(item, index)` fires; consumed\n * keys return `true`, others `false` to fall through. Space is typeable only while buffering (a\n * leading Space reaches the caller). SSR-safe; reset timer cleared when the scope is disposed.\n *\n * `items`, `enabled` and `timeout` may each be a ref or getter and are read per keystroke, so the\n * matcher tracks a live list without the original's options-in-a-ref indirection. The callbacks\n * (`getLabel`, `onMatch`, …) are read off the options object at call time — pass a `reactive`\n * options object if they must be swappable.\n */\nexport function useTypeahead<T>(options: UseTypeaheadOptions<T>): UseTypeaheadReturn {\n  let buffer = '';\n  let timer: ReturnType<typeof setTimeout> | null = null;\n\n  const isEnabled = (): boolean => toValue(options.enabled ?? true);\n\n  function clearTimer(): void {\n    if (timer !== null) {\n      clearTimeout(timer);\n      timer = null;\n    }\n  }\n\n  function reset(): void {\n    buffer = '';\n    clearTimer();\n  }\n\n  /* Clears the pending reset timer on teardown (no stale fire after the scope is gone). */\n  onScopeDispose(clearTimer);\n\n  function onKeyDown(event: KeyboardEvent): boolean {\n    if (!isEnabled() || event.isComposing) return false;\n    if (!isPrintableKey(event)) return false;\n\n    const isSpace = event.key === ' ';\n    const hasBuffer = buffer.length > 0;\n    /* Reserve Space: with no active buffer, hand it back so the caller can select; while typing,\n       a Space is a real character (matches labels with spaces) and is consumed. */\n    if (isSpace && !hasBuffer) return false;\n\n    const list = toValue(options.items);\n    if (list.length === 0) return false;\n\n    const nextBuffer = buffer + event.key;\n    buffer = nextBuffer;\n\n    /* Restart the idle window on every accepted keystroke. */\n    clearTimer();\n    timer = setTimeout(\n      () => {\n        buffer = '';\n        timer = null;\n      },\n      toValue(options.timeout ?? 500),\n    );\n\n    const labelOf = (item: T): string => options.getLabel(item).toLowerCase();\n    const disabledOf = (item: T): boolean => (options.isDisabled ? options.isDisabled(item) : false);\n    const startFrom = options.getActiveIndex ? options.getActiveIndex() : -1;\n\n    let matchIndex = -1;\n    if (isAllSameChar(nextBuffer)) {\n      /* Same-letter repeat → cycle to the next label starting with that letter, after the active one. */\n      const char = nextBuffer[0]!.toLowerCase();\n      for (let step = 1; step <= list.length; step += 1) {\n        const idx = (startFrom + step + list.length) % list.length;\n        const item = list[idx]!;\n        if (!disabledOf(item) && labelOf(item).startsWith(char)) {\n          matchIndex = idx;\n          break;\n        }\n      }\n    } else {\n      /* Multi-char buffer → prefix-match the whole buffer; scan from the current item forward so a\n         refining sequence stays put when the active item still matches. */\n      const prefix = nextBuffer.toLowerCase();\n      const begin = startFrom < 0 ? 0 : startFrom;\n      for (let step = 0; step < list.length; step += 1) {\n        const idx = (begin + step) % list.length;\n        const item = list[idx]!;\n        if (!disabledOf(item) && labelOf(item).startsWith(prefix)) {\n          matchIndex = idx;\n          break;\n        }\n      }\n    }\n\n    if (matchIndex >= 0) {\n      options.onMatch(list[matchIndex]!, matchIndex);\n      return true;\n    }\n    /* No label matched, but the char was consumed into the buffer (and Space, once buffering,\n       must not double as select) — report handled so the caller doesn't also act on it. */\n    return true;\n  }\n\n  /* `enabled` toggling off mid-type should not leave a stale buffer/timer armed. */\n  watch(isEnabled, (nowEnabled) => {\n    if (!nowEnabled) reset();\n  });\n\n  return { onKeyDown, reset };\n}\n"],"names":[],"mappings":";AAuCA,SAAS,eAAe,OAA+B;AACrD,MAAI,MAAM,WAAW,MAAM,WAAW,MAAM,OAAQ,QAAO;AAE3D,SAAO,MAAM,IAAI,WAAW;AAC9B;AAGA,SAAS,cAAc,QAAyB;AAC9C,SAAO,OAAO,SAAS,KAAK,CAAC,GAAG,MAAM,EAAE,MAAM,CAAC,MAAM,MAAM,OAAO,CAAC,CAAC;AACtE;AAeO,SAAS,aAAgB,SAAqD;AACnF,MAAI,SAAS;AACb,MAAI,QAA8C;AAElD,QAAM,YAAY,MAAe,QAAQ,QAAQ,WAAW,IAAI;AAEhE,WAAS,aAAmB;AAC1B,QAAI,UAAU,MAAM;AAClB,mBAAa,KAAK;AAClB,cAAQ;AAAA,IACV;AAAA,EACF;AAEA,WAAS,QAAc;AACrB,aAAS;AACT,eAAA;AAAA,EACF;AAGA,iBAAe,UAAU;AAEzB,WAAS,UAAU,OAA+B;AAChD,QAAI,CAAC,UAAA,KAAe,MAAM,YAAa,QAAO;AAC9C,QAAI,CAAC,eAAe,KAAK,EAAG,QAAO;AAEnC,UAAM,UAAU,MAAM,QAAQ;AAC9B,UAAM,YAAY,OAAO,SAAS;AAGlC,QAAI,WAAW,CAAC,UAAW,QAAO;AAElC,UAAM,OAAO,QAAQ,QAAQ,KAAK;AAClC,QAAI,KAAK,WAAW,EAAG,QAAO;AAE9B,UAAM,aAAa,SAAS,MAAM;AAClC,aAAS;AAGT,eAAA;AACA,YAAQ;AAAA,MACN,MAAM;AACJ,iBAAS;AACT,gBAAQ;AAAA,MACV;AAAA,MACA,QAAQ,QAAQ,WAAW,GAAG;AAAA,IAAA;AAGhC,UAAM,UAAU,CAAC,SAAoB,QAAQ,SAAS,IAAI,EAAE,YAAA;AAC5D,UAAM,aAAa,CAAC,SAAsB,QAAQ,aAAa,QAAQ,WAAW,IAAI,IAAI;AAC1F,UAAM,YAAY,QAAQ,iBAAiB,QAAQ,mBAAmB;AAEtE,QAAI,aAAa;AACjB,QAAI,cAAc,UAAU,GAAG;AAE7B,YAAM,OAAO,WAAW,CAAC,EAAG,YAAA;AAC5B,eAAS,OAAO,GAAG,QAAQ,KAAK,QAAQ,QAAQ,GAAG;AACjD,cAAM,OAAO,YAAY,OAAO,KAAK,UAAU,KAAK;AACpD,cAAM,OAAO,KAAK,GAAG;AACrB,YAAI,CAAC,WAAW,IAAI,KAAK,QAAQ,IAAI,EAAE,WAAW,IAAI,GAAG;AACvD,uBAAa;AACb;AAAA,QACF;AAAA,MACF;AAAA,IACF,OAAO;AAGL,YAAM,SAAS,WAAW,YAAA;AAC1B,YAAM,QAAQ,YAAY,IAAI,IAAI;AAClC,eAAS,OAAO,GAAG,OAAO,KAAK,QAAQ,QAAQ,GAAG;AAChD,cAAM,OAAO,QAAQ,QAAQ,KAAK;AAClC,cAAM,OAAO,KAAK,GAAG;AACrB,YAAI,CAAC,WAAW,IAAI,KAAK,QAAQ,IAAI,EAAE,WAAW,MAAM,GAAG;AACzD,uBAAa;AACb;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEA,QAAI,cAAc,GAAG;AACnB,cAAQ,QAAQ,KAAK,UAAU,GAAI,UAAU;AAC7C,aAAO;AAAA,IACT;AAGA,WAAO;AAAA,EACT;AAGA,QAAM,WAAW,CAAC,eAAe;AAC/B,QAAI,CAAC,WAAY,OAAA;AAAA,EACnB,CAAC;AAED,SAAO,EAAE,WAAW,MAAA;AACtB;"}

package/dist/chunks/index-BNxprnsV.js

@@ -0,0 +1,81 @@
+import { c as cn } from "./Cn-CzDCF-Ah.js";
+import { A as AbsolutePositionPreset, C as CssExtensions, R as RadiusToken, S as SizePreset } from "./CssExtensions-ctGVlfYU.js";
+import { C as ColorExtensions, a as ColorTone } from "./ColorExtensions-DiCSaVbJ.js";
+import { S as SurfaceVariant, s as surfaceVariants } from "./SurfaceStyles-BYLzCbuJ.js";
+import { P as Padding, R as Radius, S as Size, T as Tone } from "./StyleTokens-Bkz7Dm5L.js";
+import { a as ToneFamily, T as Tones } from "./Tones-DSlTgkaB.js";
+import { S as Severity } from "./Severity-D0C5oAt-.js";
+import { O as Orientation } from "./Orientation-u-sYunuG.js";
+import { A as Align } from "./Align-DqFtCY3a.js";
+import { S as Side } from "./Side-Kw61CDou.js";
+import { C as CornerPosition } from "./CornerPosition-FneGck5D.js";
+import { O as OverlayPosition } from "./OverlayPosition-BNybkMGG.js";
+import { P as ProgressTone } from "./ProgressTone-BpLPUptx.js";
+import { S as StatusTone } from "./StatusTone-BoPK1s09.js";
+import { tv } from "tailwind-variants";
+const Layer = {
+  /** Slips under the base layer; visually hidden. */
+  Hide: -1,
+  /** Sits in the default DOM flow with no z-index applied. */
+  Base: 0,
+  /** Slightly elevates over siblings — badges, sticky list items, in-grid overlays. */
+  Raised: 10,
+  /** Pins widgets inside a section — panels, inline overlays. */
+  Docked: 20,
+  /** Anchors a page-level sticky header or footer. */
+  Sticky: 30,
+  /** Hosts system banners — cookie notice, status banner, persistent Fab. */
+  Banner: 40,
+  /** Hosts dropdowns, popovers, comboboxes, menus, hover-cards anchored to a trigger. */
+  Dropdown: 50,
+  /** Dims the page behind a modal — backdrop / scrim layer. */
+  Overlay: 60,
+  /** Hosts modal / dialog / drawer / sheet content above its backdrop. */
+  Modal: 70,
+  /** Hosts popovers / menus opened FROM inside a modal — must beat Modal. */
+  Popover: 80,
+  /** Hosts toasts, snackbars, undo bars — survives above modals. */
+  Toast: 90,
+  /** Hosts tooltips and live-cursors — highest functional layer. */
+  Tooltip: 100,
+  /** Hosts DevTools / design-system inspector overlays — always wins. */
+  Debug: 9999
+};
+function layerStyle(layer) {
+  return { zIndex: Layer[layer] };
+}
+const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  AbsolutePositionPreset,
+  Align,
+  ColorExtensions,
+  ColorTone,
+  CornerPosition,
+  CssExtensions,
+  Layer,
+  Orientation,
+  OverlayPosition,
+  Padding,
+  ProgressTone,
+  Radius,
+  RadiusToken,
+  Severity,
+  Side,
+  Size,
+  SizePreset,
+  StatusTone,
+  SurfaceVariant,
+  Tone,
+  ToneFamily,
+  Tones,
+  cn,
+  layerStyle,
+  surfaceVariants,
+  tv
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  Layer as L,
+  index as i,
+  layerStyle as l
+};
+//# sourceMappingURL=index-BNxprnsV.js.map

package/dist/chunks/index-BNxprnsV.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BNxprnsV.js","sources":["../../src/foundation/styles/constants/Layers.ts"],"sourcesContent":["/* Provides semantic z-index tiers — the single source of truth for stacking order. */\n\n/** Contains the semantic z-index tiers; matching `z-{name}` utilities ship via @theme. */\nexport const Layer = {\n  /** Slips under the base layer; visually hidden. */\n  Hide: -1,\n  /** Sits in the default DOM flow with no z-index applied. */\n  Base: 0,\n  /** Slightly elevates over siblings — badges, sticky list items, in-grid overlays. */\n  Raised: 10,\n  /** Pins widgets inside a section — panels, inline overlays. */\n  Docked: 20,\n  /** Anchors a page-level sticky header or footer. */\n  Sticky: 30,\n  /** Hosts system banners — cookie notice, status banner, persistent Fab. */\n  Banner: 40,\n  /** Hosts dropdowns, popovers, comboboxes, menus, hover-cards anchored to a trigger. */\n  Dropdown: 50,\n  /** Dims the page behind a modal — backdrop / scrim layer. */\n  Overlay: 60,\n  /** Hosts modal / dialog / drawer / sheet content above its backdrop. */\n  Modal: 70,\n  /** Hosts popovers / menus opened FROM inside a modal — must beat Modal. */\n  Popover: 80,\n  /** Hosts toasts, snackbars, undo bars — survives above modals. */\n  Toast: 90,\n  /** Hosts tooltips and live-cursors — highest functional layer. */\n  Tooltip: 100,\n  /** Hosts DevTools / design-system inspector overlays — always wins. */\n  Debug: 9999,\n} as const;\n\n/** Represents the name of a semantic z-index tier. */\nexport type LayerName = keyof typeof Layer;\n\n/** Provides an inline `style` object for programmatic z-index assignment. */\nexport function layerStyle(layer: LayerName): { zIndex: number } {\n  return { zIndex: Layer[layer] };\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;AAGO,MAAM,QAAQ;AAAA;AAAA,EAEnB,MAAM;AAAA;AAAA,EAEN,MAAM;AAAA;AAAA,EAEN,QAAQ;AAAA;AAAA,EAER,QAAQ;AAAA;AAAA,EAER,QAAQ;AAAA;AAAA,EAER,QAAQ;AAAA;AAAA,EAER,UAAU;AAAA;AAAA,EAEV,SAAS;AAAA;AAAA,EAET,OAAO;AAAA;AAAA,EAEP,SAAS;AAAA;AAAA,EAET,OAAO;AAAA;AAAA,EAEP,SAAS;AAAA;AAAA,EAET,OAAO;AACT;AAMO,SAAS,WAAW,OAAsC;AAC/D,SAAO,EAAE,QAAQ,MAAM,KAAK,EAAA;AAC9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}