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

package/dist/foundation/observers/hooks/UseInView.d.ts

@@ -0,0 +1,41 @@
+import { ComputedRef, MaybeRefOrGetter } from 'vue';
+import { IntersectionOptions } from '../ObserveIntersection';
+/** Root/margin/threshold plus the lifecycle knobs the composable adds. */
+export interface UseInViewOptions extends IntersectionOptions {
+    /**
+     * Stop observing permanently after the first intersection. The state stays `true` from then on, even if the
+     * element scrolls away or `target` is later pointed at a different node. Use for anything that should happen
+     * once — lazy loads, entrance animations, "seen" analytics.
+     */
+    readonly once?: boolean;
+    /** Suspend observation without tearing down. Flipping it back re-observes the current target. */
+    readonly disabled?: boolean;
+    /**
+     * What `inView` reports when `IntersectionObserver` does not exist in this environment. Defaults to `true`
+     * (fail open — show the content). Set `false` only when hidden is the safer wrong answer.
+     */
+    readonly fallbackInView?: boolean;
+}
+/** What `useInView` returns. */
+export interface InViewState {
+    /** Whether the element currently meets the threshold. */
+    readonly inView: ComputedRef<boolean>;
+    /**
+     * The entry behind the current value — `intersectionRatio`, `boundingClientRect`, `time`. `null` before the
+     * observer's first callback and whenever the API is unavailable.
+     */
+    readonly entry: ComputedRef<IntersectionObserverEntry | null>;
+}
+/**
+ * Tracks whether the element behind `target` is intersecting the root.
+ *
+ * Takes the element as a ref or getter rather than handing one back, so the caller keeps ownership of its
+ * `useTemplateRef`. The first callback arrives asynchronously (a frame or so after mount), so `inView` is
+ * `false` on the very first read even for an element sitting in the middle of the viewport — assert against it
+ * with `waitFor`, never synchronously.
+ *
+ * @param target Points at the element to watch. Changing it re-observes.
+ * @param options Root, margin, threshold, plus `once` / `disabled` / `fallbackInView`.
+ * @returns `{ inView, entry }`, updating only when `isIntersecting` or `intersectionRatio` actually changes.
+ */
+export declare function useInView<T extends Element>(target: MaybeRefOrGetter<T | null | undefined>, options?: MaybeRefOrGetter<UseInViewOptions | undefined>): InViewState;

package/dist/foundation/observers/hooks/UseIntersectionObserver.d.ts

@@ -0,0 +1,18 @@
+import { MaybeRefOrGetter } from 'vue';
+import { IntersectionOptions } from '../ObserveIntersection';
+/** Root/margin/threshold plus the one lifecycle knob that makes sense for a shared observer. */
+export interface UseIntersectionObserverOptions extends IntersectionOptions {
+    /** Suspend observation of every target without tearing down. Flipping it back re-observes them all. */
+    readonly disabled?: boolean;
+}
+/**
+ * Observes many elements through a single `IntersectionObserver`.
+ *
+ * The callback fires once per entry, and `entry.target` identifies which element it belongs to — the usual
+ * consumer keeps a `Map` from element to row id, or compares against its own refs.
+ *
+ * @param targets The elements to observe, as a ref or getter over the list. Nulls are skipped.
+ * @param callback Receives each entry plus the shared observer.
+ * @param options Root, margin, threshold, `disabled`.
+ */
+export declare function useIntersectionObserver(targets: MaybeRefOrGetter<readonly (Element | null | undefined)[]>, callback: (entry: IntersectionObserverEntry, observer: IntersectionObserver) => void, options?: MaybeRefOrGetter<UseIntersectionObserverOptions | undefined>): void;

package/dist/foundation/observers/hooks/UseMutationObserver.d.ts

@@ -0,0 +1,21 @@
+import { MaybeRefOrGetter } from 'vue';
+import { MutationOptions } from '../ObserveMutation';
+/** The `MutationObserverInit` flags plus the one lifecycle knob. */
+export interface UseMutationObserverOptions extends MutationOptions {
+    /** Suspend observation without tearing down. Flipping it back re-subscribes to the current node. */
+    readonly disabled?: boolean;
+}
+/**
+ * Runs `callback` whenever the node behind `target` mutates.
+ *
+ * With no options, watches `childList` — additions and removals of direct children. Add `subtree: true` to
+ * extend that (and every other flag) to descendants.
+ *
+ * Takes the node as a ref or getter rather than handing one back. Records describe what ALREADY happened; the
+ * DOM is in its post-mutation state by the time the callback runs.
+ *
+ * @param target Points at the node to watch. Changing it re-subscribes.
+ * @param callback Receives the batch of records plus the observer, so a caller can disconnect from inside.
+ * @param options Which mutation kinds to report, plus `disabled`.
+ */
+export declare function useMutationObserver<T extends Node>(target: MaybeRefOrGetter<T | null | undefined>, callback: (records: ReadonlyArray<MutationRecord>, observer: MutationObserver) => void, options?: MaybeRefOrGetter<UseMutationObserverOptions | undefined>): void;

package/dist/foundation/observers/index.d.ts

@@ -1,7 +1,8 @@
 export { observeIntersection, supportsIntersectionObserver, type IntersectionOptions, type Disposer, } from './ObserveIntersection';
 export { observeMutation, supportsMutationObserver, type MutationOptions } from './ObserveMutation';
 export { visibilityThresholds } from './VisibilitySteps';
-export { useInView, type UseInViewOptions, type InViewState } from './UseInView';
-export { useVisibility, type UseVisibilityOptions, type VisibilityState } from './UseVisibility';
-export { useIntersectionObserver, type UseIntersectionObserverOptions } from './UseIntersectionObserver';
-export { useMutationObserver, type UseMutationObserverOptions } from './UseMutationObserver';
+export { useInView, type UseInViewOptions, type InViewState } from './hooks/UseInView';
+export { useVisibility, type UseVisibilityOptions, type VisibilityState } from './hooks/UseVisibility';
+export { useIntersectionObserver, type UseIntersectionObserverOptions } from './hooks/UseIntersectionObserver';
+export { useMutationObserver, type UseMutationObserverOptions } from './hooks/UseMutationObserver';
+export * from './hooks/UseResizeObserver';

package/dist/foundation/observers/index.js

@@ -1,5 +1,6 @@
 import { shallowRef, watchPostEffect, toValue, computed, onScopeDispose } from "vue";
-const NOOP$1 = () => {
+import { u } from "../../chunks/UseResizeObserver-BUU7lC-n.js";
+const NoopDisposer$1 = () => {
 };
 function supportsIntersectionObserver() {
   return typeof IntersectionObserver !== "undefined";
@@ -19,7 +20,7 @@ function intersectionSignature(options) {
   return `${options?.rootMargin ?? "0px"}|${thresholdKey}`;
 }
 function observeIntersection(element, callback, options) {
-  if (!supportsIntersectionObserver()) return NOOP$1;
+  if (!supportsIntersectionObserver()) return NoopDisposer$1;
   const observer = new IntersectionObserver((entries, self) => {
     for (const entry of entries) callback(entry, self);
   }, toIntersectionInit(options));
@@ -31,7 +32,7 @@ function observeIntersection(element, callback, options) {
     observer.disconnect();
   };
 }
-const NOOP = () => {
+const NoopDisposer = () => {
 };
 function supportsMutationObserver() {
   return typeof MutationObserver !== "undefined";
@@ -57,7 +58,7 @@ function toMutationInit(options) {
   return init;
 }
 function observeMutation(node, callback, options) {
-  if (!supportsMutationObserver()) return NOOP;
+  if (!supportsMutationObserver()) return NoopDisposer;
   const observer = new MutationObserver((records, self) => {
     callback(records, self);
   });
@@ -69,21 +70,21 @@ function observeMutation(node, callback, options) {
     observer.disconnect();
   };
 }
-const MIN_STEPS = 1;
-const MAX_STEPS = 100;
-const PRECISION = 4;
+const MinSteps = 1;
+const MaxSteps = 100;
+const DecimalPlaces = 4;
 function visibilityThresholds(steps) {
-  const count = Number.isFinite(steps) ? Math.min(Math.max(Math.round(steps), MIN_STEPS), MAX_STEPS) : MIN_STEPS;
-  const factor = 10 ** PRECISION;
+  const count = Number.isFinite(steps) ? Math.min(Math.max(Math.round(steps), MinSteps), MaxSteps) : MinSteps;
+  const factor = 10 ** DecimalPlaces;
   const ladder = [];
   for (let index = 0; index <= count; index += 1) {
     ladder.push(Math.round(index / count * factor) / factor);
   }
   return Object.freeze(ladder);
 }
-const INITIAL_STATE = { inView: false, entry: null };
+const InitialState = { inView: false, entry: null };
 function useInView(target, options) {
-  const state = shallowRef(INITIAL_STATE);
+  const state = shallowRef(InitialState);
   let settled = false;
   watchPostEffect((onCleanup) => {
     if (settled) return;
@@ -118,11 +119,11 @@ function useInView(target, options) {
     entry: computed(() => state.value.entry)
   };
 }
-const DEFAULT_STEPS = 20;
+const DefaultSteps = 20;
 function useVisibility(target, options) {
   const { inView, entry } = useInView(target, () => {
     const opts = toValue(options);
-    return { ...opts, threshold: visibilityThresholds(opts?.steps ?? DEFAULT_STEPS) };
+    return { ...opts, threshold: visibilityThresholds(opts?.steps ?? DefaultSteps) };
   });
   const ratio = computed(() => entry.value?.intersectionRatio ?? (inView.value ? 1 : 0));
   return { ratio, inView, entry };
@@ -193,6 +194,7 @@ export {
   useInView,
   useIntersectionObserver,
   useMutationObserver,
+  u as useResizeObserver,
   useVisibility,
   visibilityThresholds
 };

package/dist/foundation/observers/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../src/foundation/observers/ObserveIntersection.ts","../../../src/foundation/observers/ObserveMutation.ts","../../../src/foundation/observers/VisibilitySteps.ts","../../../src/foundation/observers/UseInView.ts","../../../src/foundation/observers/UseVisibility.ts","../../../src/foundation/observers/UseIntersectionObserver.ts","../../../src/foundation/observers/UseMutationObserver.ts"],"sourcesContent":["// The Vue-free core of the intersection half of this slice. Every composable here is a thin lifecycle wrapper over\n// `observeIntersection`, which means a router guard, an analytics probe, or a plain script can watch an element\n// without pulling Vue in — and means the observer's own semantics are proven in one place rather than three.\n//\n// A DISPOSER, NOT AN OBSERVER, IS RETURNED. Handing back the `IntersectionObserver` would invite callers to keep\n// observing other elements on it, and then a single `disconnect()` from one owner would silently stop everybody\n// else's. A disposer is the smallest capability that still cleans up, and it is idempotent so a double-dispose\n// (a watcher re-run that cleans up twice, a `finally` that also runs on the happy path) is not an error.\n//\n// ABSENT API ⇒ A NO-OP DISPOSER, NEVER A THROW. On the server there is no `IntersectionObserver` at all, and in a\n// pre-2019 browser there is none either. Both are the same shape of problem — the element can never be reported\n// as intersecting — so both take the same branch. Callers decide what \"unknown visibility\" means for them; see\n// `fallbackInView` in `UseInView`, which fails OPEN so reveal-on-scroll content is never stranded invisible.\n//\n// THRESHOLDS ARE COPIED ON THE WAY IN. `IntersectionObserverInit.threshold` is a mutable `number[]` in lib.dom,\n// but this slice accepts `readonly number[]` so a consumer can pass a frozen module constant. The copy is what\n// bridges the two, and it also stops the browser from ever holding a reference to a caller's array.\n\n/** Root, margin, and threshold — the three knobs `IntersectionObserver` itself takes, with readonly thresholds. */\nexport interface IntersectionOptions {\n  /**\n   * Element (or document) whose bounds define \"in view\". Defaults to the browser viewport when `null`/omitted.\n   * Must be an ancestor of every observed target, or the browser reports nothing.\n   */\n  readonly root?: Element | Document | null;\n\n  /**\n   * CSS-margin string that grows or shrinks the root box before intersection is computed — e.g. `'200px'` to\n   * start loading an image a screen early, `'-50%'` to fire only past the halfway line. Defaults to `'0px'`.\n   */\n  readonly rootMargin?: string;\n\n  /**\n   * Visible fraction(s), each `0`–`1`, at which the callback fires. A single number fires on crossing it in\n   * either direction; an array fires at every listed step. Defaults to `0` (any pixel).\n   */\n  readonly threshold?: number | readonly number[];\n}\n\n/** A disposer that is safe to call more than once. */\nexport type Disposer = () => void;\n\n/** Shared no-op for the unsupported path, so the caller's cleanup is unconditional. */\nconst NOOP: Disposer = () => {};\n\n/** Whether a usable `IntersectionObserver` exists — false on the server and in pre-2019 browsers. */\nexport function supportsIntersectionObserver(): boolean {\n  return typeof IntersectionObserver !== 'undefined';\n}\n\n/**\n * Normalizes this slice's options into the mutable init the DOM constructor demands.\n *\n * Internal — not exported from the barrel. Shared so the single- and multi-element paths can never configure\n * their observers differently.\n *\n * @param options Slice-level options, or `undefined` for all defaults.\n * @returns An init object with `threshold` copied into a mutable array when it was a list.\n */\nexport function toIntersectionInit(options?: IntersectionOptions): IntersectionObserverInit {\n  const threshold = options?.threshold;\n  const init: IntersectionObserverInit = {\n    root: options?.root ?? null,\n    rootMargin: options?.rootMargin ?? '0px',\n    threshold: typeof threshold === 'number' ? threshold : [...(threshold ?? [0])],\n  };\n  return init;\n}\n\n/**\n * Fingerprints the scalar options so a composable can tell a real config change from a new object literal.\n *\n * Internal — not exported from the barrel. `root` is deliberately absent: it is an object, so composables compare it by\n * identity alongside this string rather than trying to stringify a DOM node.\n *\n * @param options Slice-level options, or `undefined`.\n * @returns A stable string that changes only when `rootMargin` or `threshold` actually changes.\n */\nexport function intersectionSignature(options?: IntersectionOptions): string {\n  const threshold = options?.threshold;\n  const thresholdKey = typeof threshold === 'number' ? String(threshold) : (threshold ?? [0]).join(',');\n  return `${options?.rootMargin ?? '0px'}|${thresholdKey}`;\n}\n\n/**\n * Observes one element's intersection with a root and returns a disposer.\n *\n * The callback is invoked once per entry (not once per batch), because a single-element observer receiving a\n * batch means the browser coalesced several crossings and the caller wants each of them.\n *\n * Fires an initial entry asynchronously shortly after observation begins, describing the element's CURRENT\n * state — so a consumer never has to measure the first frame by hand.\n *\n * @param element The target to watch.\n * @param callback Receives each entry plus the observer, so `once`-style callers can stop from inside.\n * @param options Root, margin, threshold.\n * @returns An idempotent disposer. A no-op when `IntersectionObserver` is unavailable.\n */\nexport function observeIntersection(\n  element: Element,\n  callback: (entry: IntersectionObserverEntry, observer: IntersectionObserver) => void,\n  options?: IntersectionOptions,\n): Disposer {\n  if (!supportsIntersectionObserver()) return NOOP;\n\n  const observer = new IntersectionObserver((entries, self) => {\n    for (const entry of entries) callback(entry, self);\n  }, toIntersectionInit(options));\n\n  observer.observe(element);\n\n  let disposed = false;\n  return () => {\n    if (disposed) return;\n    disposed = true;\n    observer.disconnect();\n  };\n}\n","// The Vue-free core of the mutation half of this slice. Same contract as `ObserveIntersection`: a disposer, an\n// idempotent one, and a no-op rather than a throw when the API is absent.\n//\n// AN EMPTY INIT IS A `TypeError`, SO IT IS NEVER SENT. `MutationObserver.observe` throws outright unless at least\n// one of `childList`, `attributes`, or `characterData` is true — a genuinely surprising failure, because the\n// mistake (`observe(el)` with no options, or an options object holding only `subtree`) reads as \"watch\n// everything\". This module defaults to `{ childList: true }` in exactly that case, which is what the caller who\n// wrote nothing meant, and turns a runtime crash into a working observer.\n//\n// THE SPEC'S IMPLICIT FLAGS ARE MADE EXPLICIT. Per DOM, `attributeFilter` implies `attributes: true` and\n// `attributeOldValue` implies it too (likewise `characterDataOldValue` → `characterData`). Relying on the\n// implication would make the \"did the caller request anything?\" test above wrong for an options object holding\n// only a filter — so the implications are resolved here, before the emptiness check, not left to the engine.\n//\n// RECORDS ARRIVE BATCHED AND ARE PASSED THROUGH BATCHED. Unlike intersection entries, mutation records are a\n// transaction: \"these things changed together, in this order\". Splitting them into one call per record would\n// destroy that grouping and make a consumer that only cares about the net effect re-derive it.\n\n/** The `MutationObserverInit` flags, with a readonly `attributeFilter`. */\nexport interface MutationOptions {\n  /** Watch additions and removals of direct children. Defaults to `true` only when nothing else is requested. */\n  readonly childList?: boolean;\n\n  /** Watch attribute changes on the target. Implied by `attributeFilter` / `attributeOldValue`. */\n  readonly attributes?: boolean;\n\n  /** Watch text content changes. Implied by `characterDataOldValue`. */\n  readonly characterData?: boolean;\n\n  /** Extend every other flag to the whole subtree rather than the target alone. Off on its own — never enough. */\n  readonly subtree?: boolean;\n\n  /**\n   * Restrict attribute watching to these names, e.g. `['data-state', 'aria-expanded']`. Narrowing this is the\n   * cheapest win available: an unfiltered `attributes: true` on a busy node reports every class toggle.\n   */\n  readonly attributeFilter?: readonly string[];\n\n  /** Include the previous value on each attribute record. */\n  readonly attributeOldValue?: boolean;\n\n  /** Include the previous value on each character-data record. */\n  readonly characterDataOldValue?: boolean;\n}\n\n/** A disposer that is safe to call more than once. */\nexport type Disposer = () => void;\n\n/** Shared no-op for the unsupported path, so the caller's cleanup is unconditional. */\nconst NOOP: Disposer = () => {};\n\n/** Whether a usable `MutationObserver` exists — false on the server. */\nexport function supportsMutationObserver(): boolean {\n  return typeof MutationObserver !== 'undefined';\n}\n\n/**\n * Normalizes slice options into a valid `MutationObserverInit`, resolving the spec's implied flags and\n * substituting `{ childList: true }` for an init that would otherwise throw.\n *\n * Internal — not exported from the barrel.\n *\n * @param options Slice-level options, or `undefined` for the childList default.\n * @returns An init guaranteed to satisfy `observe`.\n */\nexport function toMutationInit(options?: MutationOptions): MutationObserverInit {\n  const attributes =\n    options?.attributes ?? (options?.attributeFilter !== undefined || options?.attributeOldValue === true);\n  const characterData = options?.characterData ?? options?.characterDataOldValue === true;\n  const childList = options?.childList ?? false;\n\n  // Nothing asked for ⇒ the caller meant \"tell me when the children change\", not \"throw\".\n  if (!attributes && !characterData && !childList) {\n    return { childList: true, subtree: options?.subtree ?? false };\n  }\n\n  const init: MutationObserverInit = {\n    childList,\n    attributes,\n    characterData,\n    subtree: options?.subtree ?? false,\n  };\n  if (options?.attributeFilter !== undefined) init.attributeFilter = [...options.attributeFilter];\n  if (options?.attributeOldValue !== undefined) init.attributeOldValue = options.attributeOldValue;\n  if (options?.characterDataOldValue !== undefined) {\n    init.characterDataOldValue = options.characterDataOldValue;\n  }\n  return init;\n}\n\n/**\n * Fingerprints the options so a composable can tell a real config change from a new object literal.\n *\n * Internal — not exported from the barrel.\n *\n * @param options Slice-level options, or `undefined`.\n * @returns A stable string that changes only when a flag actually changes.\n */\nexport function mutationSignature(options?: MutationOptions): string {\n  const init = toMutationInit(options);\n  return [\n    init.childList === true,\n    init.attributes === true,\n    init.characterData === true,\n    init.subtree === true,\n    init.attributeOldValue === true,\n    init.characterDataOldValue === true,\n    (init.attributeFilter ?? []).join(','),\n  ].join('|');\n}\n\n/**\n * Observes DOM mutations on a node and returns a disposer.\n *\n * @param node The target to watch. Any `Node` — an element, but a text node or fragment works too.\n * @param callback Receives the batch of records plus the observer, so a caller can stop from inside.\n * @param options Which mutation kinds to report; defaults to `{ childList: true }`.\n * @returns An idempotent disposer. A no-op when `MutationObserver` is unavailable.\n */\nexport function observeMutation(\n  node: Node,\n  callback: (records: readonly MutationRecord[], observer: MutationObserver) => void,\n  options?: MutationOptions,\n): Disposer {\n  if (!supportsMutationObserver()) return NOOP;\n\n  const observer = new MutationObserver((records, self) => {\n    callback(records, self);\n  });\n\n  observer.observe(node, toMutationInit(options));\n\n  let disposed = false;\n  return () => {\n    if (disposed) return;\n    disposed = true;\n    observer.disconnect();\n  };\n}\n","// The one piece of arithmetic in this slice, kept pure and DOM-free so it is testable in node — same split the\n// gestures slice makes between `GestureMath` and its composables.\n//\n// WHY A THRESHOLD LADDER AT ALL: `IntersectionObserver` does not stream a continuous ratio. It fires only when a\n// listed threshold is CROSSED, so an observer built with `threshold: 0` reports `intersectionRatio` exactly twice\n// per pass — on the way in and on the way out — and a consumer polling that value for a progress bar sees it\n// jump 0 → 1. Sampling a percentage means asking for the samples up front. `useVisibility` exists to hide that.\n//\n// STEPS ARE CAPPED, AND THE CAP IS THE POINT. Each threshold is a wake-up: the browser recomputes intersection\n// and dispatches a callback that can wake every watcher on the value. `steps: 1000` is not a smoother read, it is\n// a thousand updates per scroll-through for a number a human sees three digits of. 100 is already finer than any\n// UI needs.\n//\n// ROUNDING IS NOT COSMETIC. `3 / 15` is `0.19999999999999998`; a ladder built from raw division carries float\n// noise into the DOM and makes two ladders that should be equal compare unequal in the composables' option signature.\n// Rounding to 4 decimals is far below any threshold the browser can distinguish and makes the output stable.\n\n/** Fewest steps that still describes a range — `[0, 1]`, i.e. \"empty or full\". */\nconst MIN_STEPS = 1;\n\n/** Most steps allowed; see the header — beyond this the ladder costs more than the precision is worth. */\nconst MAX_STEPS = 100;\n\n/** Decimal places each threshold is rounded to, killing float noise well below observer precision. */\nconst PRECISION = 4;\n\n/**\n * Builds an evenly spaced threshold ladder for `IntersectionObserver`.\n *\n * Always includes both `0` and `1`, so a consumer is told when the element leaves entirely and when it is fully\n * visible regardless of how coarse the sampling is.\n *\n * `steps` is clamped to `1`–`100` and rounded to an integer; a `NaN`, an infinity, or a negative collapses to the\n * minimum rather than throwing, because a bad number here should degrade the resolution of a progress readout,\n * never break the page that renders it.\n *\n * @param steps How many intervals to divide `0`–`1` into. `steps: 4` ⇒ `[0, 0.25, 0.5, 0.75, 1]`.\n * @returns A frozen ascending ladder of `steps + 1` thresholds, first `0` and last `1`.\n */\nexport function visibilityThresholds(steps: number): readonly number[] {\n  const count = Number.isFinite(steps) ? Math.min(Math.max(Math.round(steps), MIN_STEPS), MAX_STEPS) : MIN_STEPS;\n\n  const factor = 10 ** PRECISION;\n  const ladder: number[] = [];\n  for (let index = 0; index <= count; index += 1) {\n    ladder.push(Math.round((index / count) * factor) / factor);\n  }\n  return Object.freeze(ladder);\n}\n","// `useInView` — \"is this element on screen?\" as a boolean, over `observeIntersection`. The primitive under\n// lazy-loading, reveal-on-scroll, infinite-scroll sentinels, and autoplay-when-visible.\n//\n// THE WHOLE REF-DIFFING MACHINE THE REACT ORIGINAL NEEDED IS GONE, and its absence is the point. There, a\n// `RefObject` mutation does not re-render, so the hook had to run an effect after EVERY render and diff\n// `ref.current` against what was actually observed — otherwise it kept observing a node detached three renders\n// ago and reported a stale `false` for an element that IS on screen. In Vue a template ref is itself reactive,\n// so `watchPostEffect` re-runs precisely when the element changes and never otherwise. Options are read through\n// `toValue` in the same effect, so a changed threshold re-subscribes for free — no fingerprint comparison, no\n// no-deps effect, no separate unmount-only cleanup.\n//\n// POST-FLUSH, so the element is in the DOM before the observer attaches — the same reason\n// `foundation/hooks`' `useResizeObserver` is post-flush. Under SSR the target resolves to `null` and the effect\n// returns before touching `IntersectionObserver`.\n//\n// UNSUPPORTED FAILS OPEN, AND FAILS OPEN FROM THE EFFECT. `inView: false` is right while the answer is unknown\n// but wrong forever: reveal-on-scroll content stays invisible and lazy images never load, i.e. the page is\n// broken for the user with the oldest browser. So when `IntersectionObserver` is missing the state reports\n// `true` (`fallbackInView`, opt-out). It does that from the EFFECT, never from the seed value, because the\n// effect does not run on the server — computing the fallback at setup would make the server emit `true` and the\n// client hydrate `false`, which is a hydration mismatch.\n//\n// `once` DISCONNECTS PERMANENTLY, including across a later element change. A reveal that un-reveals is a bug,\n// and a lazy-loaded image does not need un-loading; keeping the observer alive after the first hit is pure cost\n// on the scroll path where cost is most visible.\n\nimport { computed, shallowRef, toValue, watchPostEffect, type ComputedRef, type MaybeRefOrGetter } from 'vue';\n\nimport { observeIntersection, supportsIntersectionObserver, type IntersectionOptions } from './ObserveIntersection';\n\n/** Root/margin/threshold plus the lifecycle knobs the composable adds. */\nexport interface UseInViewOptions extends IntersectionOptions {\n  /**\n   * Stop observing permanently after the first intersection. The state stays `true` from then on, even if the\n   * element scrolls away or `target` is later pointed at a different node. Use for anything that should happen\n   * once — lazy loads, entrance animations, \"seen\" analytics.\n   */\n  readonly once?: boolean;\n\n  /** Suspend observation without tearing down. Flipping it back re-observes the current target. */\n  readonly disabled?: boolean;\n\n  /**\n   * What `inView` reports when `IntersectionObserver` does not exist in this environment. Defaults to `true`\n   * (fail open — show the content). Set `false` only when hidden is the safer wrong answer.\n   */\n  readonly fallbackInView?: boolean;\n}\n\n/** What `useInView` returns. */\nexport interface InViewState {\n  /** Whether the element currently meets the threshold. */\n  readonly inView: ComputedRef<boolean>;\n\n  /**\n   * The entry behind the current value — `intersectionRatio`, `boundingClientRect`, `time`. `null` before the\n   * observer's first callback and whenever the API is unavailable.\n   */\n  readonly entry: ComputedRef<IntersectionObserverEntry | null>;\n}\n\n/** The reactive snapshot both fields are derived from — one write keeps the pair consistent. */\ninterface InViewSnapshot {\n  readonly inView: boolean;\n  readonly entry: IntersectionObserverEntry | null;\n}\n\n/** Pre-observation state. Module-level so the identity is stable across instances. */\nconst INITIAL_STATE: InViewSnapshot = { inView: false, entry: null };\n\n/**\n * Tracks whether the element behind `target` is intersecting the root.\n *\n * Takes the element as a ref or getter rather than handing one back, so the caller keeps ownership of its\n * `useTemplateRef`. The first callback arrives asynchronously (a frame or so after mount), so `inView` is\n * `false` on the very first read even for an element sitting in the middle of the viewport — assert against it\n * with `waitFor`, never synchronously.\n *\n * @param target Points at the element to watch. Changing it re-observes.\n * @param options Root, margin, threshold, plus `once` / `disabled` / `fallbackInView`.\n * @returns `{ inView, entry }`, updating only when `isIntersecting` or `intersectionRatio` actually changes.\n */\nexport function useInView<T extends Element>(\n  target: MaybeRefOrGetter<T | null | undefined>,\n  options?: MaybeRefOrGetter<UseInViewOptions | undefined>,\n): InViewState {\n  const state = shallowRef<InViewSnapshot>(INITIAL_STATE);\n\n  /** `once` already fired — this composable is done for good, across every later element change. */\n  let settled = false;\n\n  watchPostEffect((onCleanup) => {\n    if (settled) return;\n\n    const opts = toValue(options);\n    const element = opts?.disabled === true ? null : toValue(target);\n    if (!element) return;\n\n    if (!supportsIntersectionObserver()) {\n      const fallback = opts?.fallbackInView ?? true;\n      if (state.value.inView !== fallback || state.value.entry !== null) {\n        state.value = { inView: fallback, entry: null };\n      }\n      return;\n    }\n\n    const dispose = observeIntersection(\n      element,\n      (entry) => {\n        const previous = state.value;\n        if (\n          previous.entry?.isIntersecting !== entry.isIntersecting ||\n          previous.entry?.intersectionRatio !== entry.intersectionRatio\n        ) {\n          state.value = { inView: entry.isIntersecting, entry };\n        }\n\n        if (entry.isIntersecting && toValue(options)?.once === true) {\n          settled = true;\n          dispose();\n        }\n      },\n      opts,\n    );\n\n    onCleanup(dispose);\n  });\n\n  return {\n    inView: computed(() => state.value.inView),\n    entry: computed(() => state.value.entry),\n  };\n}\n","// `useVisibility` — HOW MUCH of an element is on screen, as a 0–1 number, where `useInView` answers only whether\n// any of it is. Drives scroll-progress bars, parallax and scrub animations, \"80% read\" analytics, and volume or\n// opacity that tracks how much of a player is showing.\n//\n// IT IS `useInView` WITH A GENERATED THRESHOLD LADDER, NOT A SECOND OBSERVER IMPLEMENTATION. The only real\n// difference between the two composables is how many thresholds the observer was built with — the lifecycle\n// (element changes, `once`, `disabled`, unsupported-fails-open, teardown) is identical, and a second copy of it\n// would be a second set of the subtle bugs that lifecycle exists to prevent. So the whole composable is: pick\n// the ladder, delegate, read `intersectionRatio` off the entry.\n//\n// `threshold` IS DELIBERATELY NOT ACCEPTED. It is the one option this composable computes from `steps`; letting\n// a caller pass both would mean silently ignoring one of them. `Omit`ing it makes that a compile error instead.\n//\n// THE RATIO IS READ FROM THE ENTRY, NOT ACCUMULATED. The browser already computed it; tracking it separately\n// would drift the moment a callback is coalesced or arrives out of order.\n\nimport { computed, toValue, type ComputedRef, type MaybeRefOrGetter } from 'vue';\n\nimport { useInView, type UseInViewOptions } from './UseInView';\nimport { visibilityThresholds } from './VisibilitySteps';\n\n/** Sampling resolution when `steps` is omitted — 5% granularity, fine enough for a progress readout. */\nconst DEFAULT_STEPS = 20;\n\n/** Everything `useInView` takes except `threshold`, which `steps` replaces. */\nexport interface UseVisibilityOptions extends Omit<UseInViewOptions, 'threshold'> {\n  /**\n   * How many intervals to sample `0`–`1` in. Higher = smoother `ratio`, more callbacks, more updates.\n   * Defaults to `20` (5% granularity); clamped to `1`–`100`.\n   */\n  readonly steps?: number;\n}\n\n/** What `useVisibility` returns. */\nexport interface VisibilityState {\n  /**\n   * Visible fraction of the element, `0`–`1`, quantized to the `steps` ladder. `1` when the API is unavailable\n   * and the fallback reports the element as visible.\n   */\n  readonly ratio: ComputedRef<number>;\n\n  /** Whether any part meets the lowest threshold — the same boolean `useInView` returns. */\n  readonly inView: ComputedRef<boolean>;\n\n  /** The entry behind the current values, or `null` before the first callback / when unsupported. */\n  readonly entry: ComputedRef<IntersectionObserverEntry | null>;\n}\n\n/**\n * Tracks what fraction of the element behind `target` is visible.\n *\n * Updates once per crossed step, so a full scroll-through of the default ladder is ~20 updates rather than\n * the 2 a plain `useInView` would give.\n *\n * @param target Points at the element to watch. Changing it re-observes.\n * @param options `steps` plus root / margin / `once` / `disabled` / `fallbackInView`.\n * @returns `{ ratio, inView, entry }`.\n */\nexport function useVisibility<T extends Element>(\n  target: MaybeRefOrGetter<T | null | undefined>,\n  options?: MaybeRefOrGetter<UseVisibilityOptions | undefined>,\n): VisibilityState {\n  // A getter, so a changed `steps` rebuilds the ladder and re-subscribes through `useInView`'s own effect.\n  const { inView, entry } = useInView(target, () => {\n    const opts = toValue(options);\n    return { ...opts, threshold: visibilityThresholds(opts?.steps ?? DEFAULT_STEPS) };\n  });\n\n  // No entry yet ⇒ derive from the boolean, so the unsupported fail-open path reports a full 1 rather than a 0\n  // that would read as \"scrolled past\" to a progress consumer.\n  const ratio = computed(() => entry.value?.intersectionRatio ?? (inView.value ? 1 : 0));\n\n  return { ratio, inView, entry };\n}\n","// `useIntersectionObserver` — the MULTI-element form: many targets, ONE observer, one callback.\n//\n// AN OBSERVER PER LIST ITEM IS THE CLASSIC PERFORMANCE MISTAKE THIS COMPOSABLE EXISTS TO PREVENT. Reaching for\n// `useInView` inside a row component feels natural and scales badly: a 500-row table builds 500 observers, and\n// the browser then walks 500 separate observation sets on every scroll-driven intersection pass instead of one.\n// The API is explicitly built for the many-target case — `observe()` takes an element, and a single observer\n// delivers ALL of their entries in one batched callback. That batching is the win, and it only exists if the\n// targets share an observer.\n//\n// THE OBSERVER SURVIVES TARGET CHURN. Rows mount and unmount constantly; rebuilding the observer for each would\n// throw away the batching AND re-fire an initial callback for every surviving target. So the effect diffs the\n// live target set against what is currently observed and issues only `observe()` / `unobserve()` for the delta.\n// A new observer is constructed exactly once per options change — nothing else. That is why the observer and\n// its observed set live OUTSIDE the effect and the teardown hangs off `onScopeDispose` rather than the\n// watcher's `onCleanup`: a per-run cleanup would be the churn this design exists to avoid.\n//\n// NO `once` HERE, ON PURPOSE. It is per-TARGET state, and this composable shares one observer across all of\n// them: honouring it would mean either disconnecting everybody on the first target's hit, or tracking a\n// per-element settled set — which is `useInView` per item, i.e. the thing this composable exists to avoid. A\n// consumer wanting once-per-row semantics keeps that bookkeeping in its own state, where the row identity\n// already lives.\n//\n// POST-FLUSH, and the targets are read through `toValue`, so the effect re-runs exactly when the reactive target\n// list changes. Under SSR the list resolves empty and nothing is constructed.\n\nimport { onScopeDispose, toValue, watchPostEffect, type MaybeRefOrGetter } from 'vue';\n\nimport {\n  intersectionSignature,\n  supportsIntersectionObserver,\n  toIntersectionInit,\n  type IntersectionOptions,\n} from './ObserveIntersection';\n\n/** Root/margin/threshold plus the one lifecycle knob that makes sense for a shared observer. */\nexport interface UseIntersectionObserverOptions extends IntersectionOptions {\n  /** Suspend observation of every target without tearing down. Flipping it back re-observes them all. */\n  readonly disabled?: boolean;\n}\n\n/**\n * Observes many elements through a single `IntersectionObserver`.\n *\n * The callback fires once per entry, and `entry.target` identifies which element it belongs to — the usual\n * consumer keeps a `Map` from element to row id, or compares against its own refs.\n *\n * @param targets The elements to observe, as a ref or getter over the list. Nulls are skipped.\n * @param callback Receives each entry plus the shared observer.\n * @param options Root, margin, threshold, `disabled`.\n */\nexport function useIntersectionObserver(\n  targets: MaybeRefOrGetter<readonly (Element | null | undefined)[]>,\n  callback: (entry: IntersectionObserverEntry, observer: IntersectionObserver) => void,\n  options?: MaybeRefOrGetter<UseIntersectionObserverOptions | undefined>,\n): void {\n  let observer: IntersectionObserver | null = null;\n  const observed = new Set<Element>();\n  let signature: string | null = null;\n  let root: Element | Document | null = null;\n\n  /** Drops the observer and forgets every target. */\n  function teardown(): void {\n    observer?.disconnect();\n    observer = null;\n    observed.clear();\n  }\n\n  watchPostEffect(() => {\n    const opts = toValue(options);\n    const nextSignature = intersectionSignature(opts);\n    const nextRoot = opts?.root ?? null;\n\n    // Observer init is immutable once constructed, so an options change is the one thing that forces a rebuild.\n    if (nextSignature !== signature || nextRoot !== root) {\n      teardown();\n      signature = nextSignature;\n      root = nextRoot;\n    }\n\n    const next = new Set<Element>();\n    if (opts?.disabled !== true) {\n      for (const element of toValue(targets)) {\n        if (element) next.add(element);\n      }\n    }\n\n    if (next.size === 0) {\n      teardown();\n      return;\n    }\n    if (!supportsIntersectionObserver()) return;\n\n    const current =\n      observer ??\n      new IntersectionObserver((entries, self) => {\n        for (const entry of entries) callback(entry, self);\n      }, toIntersectionInit(opts));\n    observer = current;\n\n    // Snapshot before mutating — deleting from a Set mid-iteration is legal but reads as a trap.\n    for (const element of [...observed]) {\n      if (!next.has(element)) {\n        current.unobserve(element);\n        observed.delete(element);\n      }\n    }\n    for (const element of next) {\n      if (!observed.has(element)) {\n        current.observe(element);\n        observed.add(element);\n      }\n    }\n  });\n\n  onScopeDispose(teardown);\n}\n","// `useMutationObserver` — react to DOM changes made by code this component does not own: a third-party widget\n// that injects nodes, a portal target filling in, a `contenteditable` the user is typing into, an external\n// script toggling an attribute. Inside Vue you use reactive state; this is the escape hatch for everything\n// outside it.\n//\n// THE CALLBACK IS CALLED THROUGH THE CLOSURE, so consumers never have to memoize it. Mutation callbacks are\n// usually written inline and usually close over reactive state; a component's `setup` runs once, so the one the\n// consumer passes is the one and only, and the subscription itself is never churned by its identity.\n//\n// SUBSCRIPTION LIFECYCLE IS A PLAIN POST-FLUSH EFFECT. The React original needed a no-deps effect plus a\n// signature fingerprint because a `RefObject` mutating does not re-render; in Vue a template ref is reactive, so\n// `watchPostEffect` re-runs exactly when the node or the options change and never otherwise. `mutationSignature`\n// stays exported from the core for a non-Vue caller, but this file has no use for it.\n//\n// RECORDS ARRIVE AS A BATCH AND ARE PASSED THROUGH AS ONE. They are a transaction; see `ObserveMutation`.\n//\n// NO `once` KNOB. Unlike an intersection, \"the DOM changed once\" is almost never the interesting event — the\n// consumer wants the mutations for as long as the node is mounted. A caller that genuinely wants one shot\n// disconnects from inside the callback, which is why the observer is handed to it.\n\nimport { toValue, watchPostEffect, type MaybeRefOrGetter } from 'vue';\n\nimport { observeMutation, supportsMutationObserver, type MutationOptions } from './ObserveMutation';\n\n/** The `MutationObserverInit` flags plus the one lifecycle knob. */\nexport interface UseMutationObserverOptions extends MutationOptions {\n  /** Suspend observation without tearing down. Flipping it back re-subscribes to the current node. */\n  readonly disabled?: boolean;\n}\n\n/**\n * Runs `callback` whenever the node behind `target` mutates.\n *\n * With no options, watches `childList` — additions and removals of direct children. Add `subtree: true` to\n * extend that (and every other flag) to descendants.\n *\n * Takes the node as a ref or getter rather than handing one back. Records describe what ALREADY happened; the\n * DOM is in its post-mutation state by the time the callback runs.\n *\n * @param target Points at the node to watch. Changing it re-subscribes.\n * @param callback Receives the batch of records plus the observer, so a caller can disconnect from inside.\n * @param options Which mutation kinds to report, plus `disabled`.\n */\nexport function useMutationObserver<T extends Node>(\n  target: MaybeRefOrGetter<T | null | undefined>,\n  callback: (records: readonly MutationRecord[], observer: MutationObserver) => void,\n  options?: MaybeRefOrGetter<UseMutationObserverOptions | undefined>,\n): void {\n  watchPostEffect((onCleanup) => {\n    const opts = toValue(options);\n    const node = opts?.disabled === true ? null : toValue(target);\n    if (!node || !supportsMutationObserver()) return;\n\n    const dispose = observeMutation(node, (records, observer) => callback(records, observer), opts);\n    onCleanup(dispose);\n  });\n}\n"],"names":["NOOP"],"mappings":"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"}
+{"version":3,"file":"index.js","sources":["../../../src/foundation/observers/ObserveIntersection.ts","../../../src/foundation/observers/ObserveMutation.ts","../../../src/foundation/observers/VisibilitySteps.ts","../../../src/foundation/observers/hooks/UseInView.ts","../../../src/foundation/observers/hooks/UseVisibility.ts","../../../src/foundation/observers/hooks/UseIntersectionObserver.ts","../../../src/foundation/observers/hooks/UseMutationObserver.ts"],"sourcesContent":["// The Vue-free core of the intersection half of this slice. Every composable here is a thin lifecycle wrapper over\n// `observeIntersection`, which means a router guard, an analytics probe, or a plain script can watch an element\n// without pulling Vue in — and means the observer's own semantics are proven in one place rather than three.\n//\n// A DISPOSER, NOT AN OBSERVER, IS RETURNED. Handing back the `IntersectionObserver` would invite callers to keep\n// observing other elements on it, and then a single `disconnect()` from one owner would silently stop everybody\n// else's. A disposer is the smallest capability that still cleans up, and it is idempotent so a double-dispose\n// (a watcher re-run that cleans up twice, a `finally` that also runs on the happy path) is not an error.\n//\n// ABSENT API ⇒ A NO-OP DISPOSER, NEVER A THROW. On the server there is no `IntersectionObserver` at all, and in a\n// pre-2019 browser there is none either. Both are the same shape of problem — the element can never be reported\n// as intersecting — so both take the same branch. Callers decide what \"unknown visibility\" means for them; see\n// `fallbackInView` in `UseInView`, which fails OPEN so reveal-on-scroll content is never stranded invisible.\n//\n// THRESHOLDS ARE COPIED ON THE WAY IN. `IntersectionObserverInit.threshold` is a mutable `number[]` in lib.dom,\n// but this slice accepts `readonly number[]` so a consumer can pass a frozen module constant. The copy is what\n// bridges the two, and it also stops the browser from ever holding a reference to a caller's array.\n\n/** Root, margin, and threshold — the three knobs `IntersectionObserver` itself takes, with readonly thresholds. */\nexport interface IntersectionOptions {\n  /**\n   * Element (or document) whose bounds define \"in view\". Defaults to the browser viewport when `null`/omitted.\n   * Must be an ancestor of every observed target, or the browser reports nothing.\n   */\n  readonly root?: Element | Document | null;\n\n  /**\n   * CSS-margin string that grows or shrinks the root box before intersection is computed — e.g. `'200px'` to\n   * start loading an image a screen early, `'-50%'` to fire only past the halfway line. Defaults to `'0px'`.\n   */\n  readonly rootMargin?: string;\n\n  /**\n   * Visible fraction(s), each `0`–`1`, at which the callback fires. A single number fires on crossing it in\n   * either direction; an array fires at every listed step. Defaults to `0` (any pixel).\n   */\n  readonly threshold?: number | ReadonlyArray<number>;\n}\n\n/** A disposer that is safe to call more than once. */\nexport type Disposer = () => void;\n\n/** Shared no-op for the unsupported path, so the caller's cleanup is unconditional. */\nconst NoopDisposer: Disposer = () => {};\n\n/** Whether a usable `IntersectionObserver` exists — false on the server and in pre-2019 browsers. */\nexport function supportsIntersectionObserver(): boolean {\n  return typeof IntersectionObserver !== 'undefined';\n}\n\n/**\n * Normalizes this slice's options into the mutable init the DOM constructor demands.\n *\n * Internal — not exported from the barrel. Shared so the single- and multi-element paths can never configure\n * their observers differently.\n *\n * @param options Slice-level options, or `undefined` for all defaults.\n * @returns An init object with `threshold` copied into a mutable array when it was a list.\n */\nexport function toIntersectionInit(options?: IntersectionOptions): IntersectionObserverInit {\n  const threshold = options?.threshold;\n  const init: IntersectionObserverInit = {\n    root: options?.root ?? null,\n    rootMargin: options?.rootMargin ?? '0px',\n    threshold: typeof threshold === 'number' ? threshold : [...(threshold ?? [0])],\n  };\n  return init;\n}\n\n/**\n * Fingerprints the scalar options so a composable can tell a real config change from a new object literal.\n *\n * Internal — not exported from the barrel. `root` is deliberately absent: it is an object, so composables compare it by\n * identity alongside this string rather than trying to stringify a DOM node.\n *\n * @param options Slice-level options, or `undefined`.\n * @returns A stable string that changes only when `rootMargin` or `threshold` actually changes.\n */\nexport function intersectionSignature(options?: IntersectionOptions): string {\n  const threshold = options?.threshold;\n  const thresholdKey = typeof threshold === 'number' ? String(threshold) : (threshold ?? [0]).join(',');\n  return `${options?.rootMargin ?? '0px'}|${thresholdKey}`;\n}\n\n/**\n * Observes one element's intersection with a root and returns a disposer.\n *\n * The callback is invoked once per entry (not once per batch), because a single-element observer receiving a\n * batch means the browser coalesced several crossings and the caller wants each of them.\n *\n * Fires an initial entry asynchronously shortly after observation begins, describing the element's CURRENT\n * state — so a consumer never has to measure the first frame by hand.\n *\n * @param element The target to watch.\n * @param callback Receives each entry plus the observer, so `once`-style callers can stop from inside.\n * @param options Root, margin, threshold.\n * @returns An idempotent disposer. A no-op when `IntersectionObserver` is unavailable.\n */\nexport function observeIntersection(\n  element: Element,\n  callback: (entry: IntersectionObserverEntry, observer: IntersectionObserver) => void,\n  options?: IntersectionOptions,\n): Disposer {\n  if (!supportsIntersectionObserver()) return NoopDisposer;\n\n  const observer = new IntersectionObserver((entries, self) => {\n    for (const entry of entries) callback(entry, self);\n  }, toIntersectionInit(options));\n\n  observer.observe(element);\n\n  let disposed = false;\n  return () => {\n    if (disposed) return;\n    disposed = true;\n    observer.disconnect();\n  };\n}\n","// The Vue-free core of the mutation half of this slice. Same contract as `ObserveIntersection`: a disposer, an\n// idempotent one, and a no-op rather than a throw when the API is absent.\n//\n// AN EMPTY INIT IS A `TypeError`, SO IT IS NEVER SENT. `MutationObserver.observe` throws outright unless at least\n// one of `childList`, `attributes`, or `characterData` is true — a genuinely surprising failure, because the\n// mistake (`observe(el)` with no options, or an options object holding only `subtree`) reads as \"watch\n// everything\". This module defaults to `{ childList: true }` in exactly that case, which is what the caller who\n// wrote nothing meant, and turns a runtime crash into a working observer.\n//\n// THE SPEC'S IMPLICIT FLAGS ARE MADE EXPLICIT. Per DOM, `attributeFilter` implies `attributes: true` and\n// `attributeOldValue` implies it too (likewise `characterDataOldValue` → `characterData`). Relying on the\n// implication would make the \"did the caller request anything?\" test above wrong for an options object holding\n// only a filter — so the implications are resolved here, before the emptiness check, not left to the engine.\n//\n// RECORDS ARRIVE BATCHED AND ARE PASSED THROUGH BATCHED. Unlike intersection entries, mutation records are a\n// transaction: \"these things changed together, in this order\". Splitting them into one call per record would\n// destroy that grouping and make a consumer that only cares about the net effect re-derive it.\n\n/** The `MutationObserverInit` flags, with a readonly `attributeFilter`. */\nexport interface MutationOptions {\n  /** Watch additions and removals of direct children. Defaults to `true` only when nothing else is requested. */\n  readonly childList?: boolean;\n\n  /** Watch attribute changes on the target. Implied by `attributeFilter` / `attributeOldValue`. */\n  readonly attributes?: boolean;\n\n  /** Watch text content changes. Implied by `characterDataOldValue`. */\n  readonly characterData?: boolean;\n\n  /** Extend every other flag to the whole subtree rather than the target alone. Off on its own — never enough. */\n  readonly subtree?: boolean;\n\n  /**\n   * Restrict attribute watching to these names, e.g. `['data-state', 'aria-expanded']`. Narrowing this is the\n   * cheapest win available: an unfiltered `attributes: true` on a busy node reports every class toggle.\n   */\n  readonly attributeFilter?: ReadonlyArray<string>;\n\n  /** Include the previous value on each attribute record. */\n  readonly attributeOldValue?: boolean;\n\n  /** Include the previous value on each character-data record. */\n  readonly characterDataOldValue?: boolean;\n}\n\n/** A disposer that is safe to call more than once. */\nexport type Disposer = () => void;\n\n/** Shared no-op for the unsupported path, so the caller's cleanup is unconditional. */\nconst NoopDisposer: Disposer = () => {};\n\n/** Whether a usable `MutationObserver` exists — false on the server. */\nexport function supportsMutationObserver(): boolean {\n  return typeof MutationObserver !== 'undefined';\n}\n\n/**\n * Normalizes slice options into a valid `MutationObserverInit`, resolving the spec's implied flags and\n * substituting `{ childList: true }` for an init that would otherwise throw.\n *\n * Internal — not exported from the barrel.\n *\n * @param options Slice-level options, or `undefined` for the childList default.\n * @returns An init guaranteed to satisfy `observe`.\n */\nexport function toMutationInit(options?: MutationOptions): MutationObserverInit {\n  const attributes =\n    options?.attributes ?? (options?.attributeFilter !== undefined || options?.attributeOldValue === true);\n  const characterData = options?.characterData ?? options?.characterDataOldValue === true;\n  const childList = options?.childList ?? false;\n\n  // Nothing asked for ⇒ the caller meant \"tell me when the children change\", not \"throw\".\n  if (!attributes && !characterData && !childList) {\n    return { childList: true, subtree: options?.subtree ?? false };\n  }\n\n  const init: MutationObserverInit = {\n    childList,\n    attributes,\n    characterData,\n    subtree: options?.subtree ?? false,\n  };\n  if (options?.attributeFilter !== undefined) init.attributeFilter = [...options.attributeFilter];\n  if (options?.attributeOldValue !== undefined) init.attributeOldValue = options.attributeOldValue;\n  if (options?.characterDataOldValue !== undefined) {\n    init.characterDataOldValue = options.characterDataOldValue;\n  }\n  return init;\n}\n\n/**\n * Fingerprints the options so a composable can tell a real config change from a new object literal.\n *\n * Internal — not exported from the barrel.\n *\n * @param options Slice-level options, or `undefined`.\n * @returns A stable string that changes only when a flag actually changes.\n */\nexport function mutationSignature(options?: MutationOptions): string {\n  const init = toMutationInit(options);\n  return [\n    init.childList === true,\n    init.attributes === true,\n    init.characterData === true,\n    init.subtree === true,\n    init.attributeOldValue === true,\n    init.characterDataOldValue === true,\n    (init.attributeFilter ?? []).join(','),\n  ].join('|');\n}\n\n/**\n * Observes DOM mutations on a node and returns a disposer.\n *\n * @param node The target to watch. Any `Node` — an element, but a text node or fragment works too.\n * @param callback Receives the batch of records plus the observer, so a caller can stop from inside.\n * @param options Which mutation kinds to report; defaults to `{ childList: true }`.\n * @returns An idempotent disposer. A no-op when `MutationObserver` is unavailable.\n */\nexport function observeMutation(\n  node: Node,\n  callback: (records: ReadonlyArray<MutationRecord>, observer: MutationObserver) => void,\n  options?: MutationOptions,\n): Disposer {\n  if (!supportsMutationObserver()) return NoopDisposer;\n\n  const observer = new MutationObserver((records, self) => {\n    callback(records, self);\n  });\n\n  observer.observe(node, toMutationInit(options));\n\n  let disposed = false;\n  return () => {\n    if (disposed) return;\n    disposed = true;\n    observer.disconnect();\n  };\n}\n","// The one piece of arithmetic in this slice, kept pure and DOM-free so it is testable in node — same split the\n// gestures slice makes between `GestureMath` and its composables.\n//\n// WHY A THRESHOLD LADDER AT ALL: `IntersectionObserver` does not stream a continuous ratio. It fires only when a\n// listed threshold is CROSSED, so an observer built with `threshold: 0` reports `intersectionRatio` exactly twice\n// per pass — on the way in and on the way out — and a consumer polling that value for a progress bar sees it\n// jump 0 → 1. Sampling a percentage means asking for the samples up front. `useVisibility` exists to hide that.\n//\n// STEPS ARE CAPPED, AND THE CAP IS THE POINT. Each threshold is a wake-up: the browser recomputes intersection\n// and dispatches a callback that can wake every watcher on the value. `steps: 1000` is not a smoother read, it is\n// a thousand updates per scroll-through for a number a human sees three digits of. 100 is already finer than any\n// UI needs.\n//\n// ROUNDING IS NOT COSMETIC. `3 / 15` is `0.19999999999999998`; a ladder built from raw division carries float\n// noise into the DOM and makes two ladders that should be equal compare unequal in the composables' option signature.\n// Rounding to 4 decimals is far below any threshold the browser can distinguish and makes the output stable.\n\n/** Fewest steps that still describes a range — `[0, 1]`, i.e. \"empty or full\". */\nconst MinSteps = 1;\n\n/** Most steps allowed; see the header — beyond this the ladder costs more than the precision is worth. */\nconst MaxSteps = 100;\n\n/** Decimal places each threshold is rounded to, killing float noise well below observer precision. */\nconst DecimalPlaces = 4;\n\n/**\n * Builds an evenly spaced threshold ladder for `IntersectionObserver`.\n *\n * Always includes both `0` and `1`, so a consumer is told when the element leaves entirely and when it is fully\n * visible regardless of how coarse the sampling is.\n *\n * `steps` is clamped to `1`–`100` and rounded to an integer; a `NaN`, an infinity, or a negative collapses to the\n * minimum rather than throwing, because a bad number here should degrade the resolution of a progress readout,\n * never break the page that renders it.\n *\n * @param steps How many intervals to divide `0`–`1` into. `steps: 4` ⇒ `[0, 0.25, 0.5, 0.75, 1]`.\n * @returns A frozen ascending ladder of `steps + 1` thresholds, first `0` and last `1`.\n */\nexport function visibilityThresholds(steps: number): ReadonlyArray<number> {\n  const count = Number.isFinite(steps) ? Math.min(Math.max(Math.round(steps), MinSteps), MaxSteps) : MinSteps;\n\n  const factor = 10 ** DecimalPlaces;\n  const ladder: number[] = [];\n  for (let index = 0; index <= count; index += 1) {\n    ladder.push(Math.round((index / count) * factor) / factor);\n  }\n  return Object.freeze(ladder);\n}\n","// `useInView` — \"is this element on screen?\" as a boolean, over `observeIntersection`. The primitive under\n// lazy-loading, reveal-on-scroll, infinite-scroll sentinels, and autoplay-when-visible.\n//\n// THE WHOLE REF-DIFFING MACHINE THE REACT ORIGINAL NEEDED IS GONE, and its absence is the point. There, a\n// `RefObject` mutation does not re-render, so the hook had to run an effect after EVERY render and diff\n// `ref.current` against what was actually observed — otherwise it kept observing a node detached three renders\n// ago and reported a stale `false` for an element that IS on screen. In Vue a template ref is itself reactive,\n// so `watchPostEffect` re-runs precisely when the element changes and never otherwise. Options are read through\n// `toValue` in the same effect, so a changed threshold re-subscribes for free — no fingerprint comparison, no\n// no-deps effect, no separate unmount-only cleanup.\n//\n// POST-FLUSH, so the element is in the DOM before the observer attaches — the same reason\n// `foundation/observers`' `useResizeObserver` is post-flush. Under SSR the target resolves to `null` and the effect\n// returns before touching `IntersectionObserver`.\n//\n// UNSUPPORTED FAILS OPEN, AND FAILS OPEN FROM THE EFFECT. `inView: false` is right while the answer is unknown\n// but wrong forever: reveal-on-scroll content stays invisible and lazy images never load, i.e. the page is\n// broken for the user with the oldest browser. So when `IntersectionObserver` is missing the state reports\n// `true` (`fallbackInView`, opt-out). It does that from the EFFECT, never from the seed value, because the\n// effect does not run on the server — computing the fallback at setup would make the server emit `true` and the\n// client hydrate `false`, which is a hydration mismatch.\n//\n// `once` DISCONNECTS PERMANENTLY, including across a later element change. A reveal that un-reveals is a bug,\n// and a lazy-loaded image does not need un-loading; keeping the observer alive after the first hit is pure cost\n// on the scroll path where cost is most visible.\n\nimport { computed, shallowRef, toValue, watchPostEffect, type ComputedRef, type MaybeRefOrGetter } from 'vue';\n\nimport { observeIntersection, supportsIntersectionObserver, type IntersectionOptions } from '../ObserveIntersection';\n\n/** Root/margin/threshold plus the lifecycle knobs the composable adds. */\nexport interface UseInViewOptions extends IntersectionOptions {\n  /**\n   * Stop observing permanently after the first intersection. The state stays `true` from then on, even if the\n   * element scrolls away or `target` is later pointed at a different node. Use for anything that should happen\n   * once — lazy loads, entrance animations, \"seen\" analytics.\n   */\n  readonly once?: boolean;\n\n  /** Suspend observation without tearing down. Flipping it back re-observes the current target. */\n  readonly disabled?: boolean;\n\n  /**\n   * What `inView` reports when `IntersectionObserver` does not exist in this environment. Defaults to `true`\n   * (fail open — show the content). Set `false` only when hidden is the safer wrong answer.\n   */\n  readonly fallbackInView?: boolean;\n}\n\n/** What `useInView` returns. */\nexport interface InViewState {\n  /** Whether the element currently meets the threshold. */\n  readonly inView: ComputedRef<boolean>;\n\n  /**\n   * The entry behind the current value — `intersectionRatio`, `boundingClientRect`, `time`. `null` before the\n   * observer's first callback and whenever the API is unavailable.\n   */\n  readonly entry: ComputedRef<IntersectionObserverEntry | null>;\n}\n\n/** The reactive snapshot both fields are derived from — one write keeps the pair consistent. */\ninterface InViewSnapshot {\n  readonly inView: boolean;\n  readonly entry: IntersectionObserverEntry | null;\n}\n\n/** Pre-observation state. Module-level so the identity is stable across instances. */\nconst InitialState: InViewSnapshot = { inView: false, entry: null };\n\n/**\n * Tracks whether the element behind `target` is intersecting the root.\n *\n * Takes the element as a ref or getter rather than handing one back, so the caller keeps ownership of its\n * `useTemplateRef`. The first callback arrives asynchronously (a frame or so after mount), so `inView` is\n * `false` on the very first read even for an element sitting in the middle of the viewport — assert against it\n * with `waitFor`, never synchronously.\n *\n * @param target Points at the element to watch. Changing it re-observes.\n * @param options Root, margin, threshold, plus `once` / `disabled` / `fallbackInView`.\n * @returns `{ inView, entry }`, updating only when `isIntersecting` or `intersectionRatio` actually changes.\n */\nexport function useInView<T extends Element>(\n  target: MaybeRefOrGetter<T | null | undefined>,\n  options?: MaybeRefOrGetter<UseInViewOptions | undefined>,\n): InViewState {\n  const state = shallowRef<InViewSnapshot>(InitialState);\n\n  /** `once` already fired — this composable is done for good, across every later element change. */\n  let settled = false;\n\n  watchPostEffect((onCleanup) => {\n    if (settled) return;\n\n    const opts = toValue(options);\n    const element = opts?.disabled === true ? null : toValue(target);\n    if (!element) return;\n\n    if (!supportsIntersectionObserver()) {\n      const fallback = opts?.fallbackInView ?? true;\n      if (state.value.inView !== fallback || state.value.entry !== null) {\n        state.value = { inView: fallback, entry: null };\n      }\n      return;\n    }\n\n    const dispose = observeIntersection(\n      element,\n      (entry) => {\n        const previous = state.value;\n        if (\n          previous.entry?.isIntersecting !== entry.isIntersecting ||\n          previous.entry?.intersectionRatio !== entry.intersectionRatio\n        ) {\n          state.value = { inView: entry.isIntersecting, entry };\n        }\n\n        if (entry.isIntersecting && toValue(options)?.once === true) {\n          settled = true;\n          dispose();\n        }\n      },\n      opts,\n    );\n\n    onCleanup(dispose);\n  });\n\n  return {\n    inView: computed(() => state.value.inView),\n    entry: computed(() => state.value.entry),\n  };\n}\n","// `useVisibility` — HOW MUCH of an element is on screen, as a 0–1 number, where `useInView` answers only whether\n// any of it is. Drives scroll-progress bars, parallax and scrub animations, \"80% read\" analytics, and volume or\n// opacity that tracks how much of a player is showing.\n//\n// IT IS `useInView` WITH A GENERATED THRESHOLD LADDER, NOT A SECOND OBSERVER IMPLEMENTATION. The only real\n// difference between the two composables is how many thresholds the observer was built with — the lifecycle\n// (element changes, `once`, `disabled`, unsupported-fails-open, teardown) is identical, and a second copy of it\n// would be a second set of the subtle bugs that lifecycle exists to prevent. So the whole composable is: pick\n// the ladder, delegate, read `intersectionRatio` off the entry.\n//\n// `threshold` IS DELIBERATELY NOT ACCEPTED. It is the one option this composable computes from `steps`; letting\n// a caller pass both would mean silently ignoring one of them. `Omit`ing it makes that a compile error instead.\n//\n// THE RATIO IS READ FROM THE ENTRY, NOT ACCUMULATED. The browser already computed it; tracking it separately\n// would drift the moment a callback is coalesced or arrives out of order.\n\nimport { computed, toValue, type ComputedRef, type MaybeRefOrGetter } from 'vue';\n\nimport { useInView, type UseInViewOptions } from './UseInView';\nimport { visibilityThresholds } from '../VisibilitySteps';\n\n/** Sampling resolution when `steps` is omitted — 5% granularity, fine enough for a progress readout. */\nconst DefaultSteps = 20;\n\n/** Everything `useInView` takes except `threshold`, which `steps` replaces. */\nexport interface UseVisibilityOptions extends Omit<UseInViewOptions, 'threshold'> {\n  /**\n   * How many intervals to sample `0`–`1` in. Higher = smoother `ratio`, more callbacks, more updates.\n   * Defaults to `20` (5% granularity); clamped to `1`–`100`.\n   */\n  readonly steps?: number;\n}\n\n/** What `useVisibility` returns. */\nexport interface VisibilityState {\n  /**\n   * Visible fraction of the element, `0`–`1`, quantized to the `steps` ladder. `1` when the API is unavailable\n   * and the fallback reports the element as visible.\n   */\n  readonly ratio: ComputedRef<number>;\n\n  /** Whether any part meets the lowest threshold — the same boolean `useInView` returns. */\n  readonly inView: ComputedRef<boolean>;\n\n  /** The entry behind the current values, or `null` before the first callback / when unsupported. */\n  readonly entry: ComputedRef<IntersectionObserverEntry | null>;\n}\n\n/**\n * Tracks what fraction of the element behind `target` is visible.\n *\n * Updates once per crossed step, so a full scroll-through of the default ladder is ~20 updates rather than\n * the 2 a plain `useInView` would give.\n *\n * @param target Points at the element to watch. Changing it re-observes.\n * @param options `steps` plus root / margin / `once` / `disabled` / `fallbackInView`.\n * @returns `{ ratio, inView, entry }`.\n */\nexport function useVisibility<T extends Element>(\n  target: MaybeRefOrGetter<T | null | undefined>,\n  options?: MaybeRefOrGetter<UseVisibilityOptions | undefined>,\n): VisibilityState {\n  // A getter, so a changed `steps` rebuilds the ladder and re-subscribes through `useInView`'s own effect.\n  const { inView, entry } = useInView(target, () => {\n    const opts = toValue(options);\n    return { ...opts, threshold: visibilityThresholds(opts?.steps ?? DefaultSteps) };\n  });\n\n  // No entry yet ⇒ derive from the boolean, so the unsupported fail-open path reports a full 1 rather than a 0\n  // that would read as \"scrolled past\" to a progress consumer.\n  const ratio = computed(() => entry.value?.intersectionRatio ?? (inView.value ? 1 : 0));\n\n  return { ratio, inView, entry };\n}\n","// `useIntersectionObserver` — the MULTI-element form: many targets, ONE observer, one callback.\n//\n// AN OBSERVER PER LIST ITEM IS THE CLASSIC PERFORMANCE MISTAKE THIS COMPOSABLE EXISTS TO PREVENT. Reaching for\n// `useInView` inside a row component feels natural and scales badly: a 500-row table builds 500 observers, and\n// the browser then walks 500 separate observation sets on every scroll-driven intersection pass instead of one.\n// The API is explicitly built for the many-target case — `observe()` takes an element, and a single observer\n// delivers ALL of their entries in one batched callback. That batching is the win, and it only exists if the\n// targets share an observer.\n//\n// THE OBSERVER SURVIVES TARGET CHURN. Rows mount and unmount constantly; rebuilding the observer for each would\n// throw away the batching AND re-fire an initial callback for every surviving target. So the effect diffs the\n// live target set against what is currently observed and issues only `observe()` / `unobserve()` for the delta.\n// A new observer is constructed exactly once per options change — nothing else. That is why the observer and\n// its observed set live OUTSIDE the effect and the teardown hangs off `onScopeDispose` rather than the\n// watcher's `onCleanup`: a per-run cleanup would be the churn this design exists to avoid.\n//\n// NO `once` HERE, ON PURPOSE. It is per-TARGET state, and this composable shares one observer across all of\n// them: honouring it would mean either disconnecting everybody on the first target's hit, or tracking a\n// per-element settled set — which is `useInView` per item, i.e. the thing this composable exists to avoid. A\n// consumer wanting once-per-row semantics keeps that bookkeeping in its own state, where the row identity\n// already lives.\n//\n// POST-FLUSH, and the targets are read through `toValue`, so the effect re-runs exactly when the reactive target\n// list changes. Under SSR the list resolves empty and nothing is constructed.\n\nimport { onScopeDispose, toValue, watchPostEffect, type MaybeRefOrGetter } from 'vue';\n\nimport {\n  intersectionSignature,\n  supportsIntersectionObserver,\n  toIntersectionInit,\n  type IntersectionOptions,\n} from '../ObserveIntersection';\n\n/** Root/margin/threshold plus the one lifecycle knob that makes sense for a shared observer. */\nexport interface UseIntersectionObserverOptions extends IntersectionOptions {\n  /** Suspend observation of every target without tearing down. Flipping it back re-observes them all. */\n  readonly disabled?: boolean;\n}\n\n/**\n * Observes many elements through a single `IntersectionObserver`.\n *\n * The callback fires once per entry, and `entry.target` identifies which element it belongs to — the usual\n * consumer keeps a `Map` from element to row id, or compares against its own refs.\n *\n * @param targets The elements to observe, as a ref or getter over the list. Nulls are skipped.\n * @param callback Receives each entry plus the shared observer.\n * @param options Root, margin, threshold, `disabled`.\n */\nexport function useIntersectionObserver(\n  targets: MaybeRefOrGetter<readonly (Element | null | undefined)[]>,\n  callback: (entry: IntersectionObserverEntry, observer: IntersectionObserver) => void,\n  options?: MaybeRefOrGetter<UseIntersectionObserverOptions | undefined>,\n): void {\n  let observer: IntersectionObserver | null = null;\n  const observed = new Set<Element>();\n  let signature: string | null = null;\n  let root: Element | Document | null = null;\n\n  /** Drops the observer and forgets every target. */\n  function teardown(): void {\n    observer?.disconnect();\n    observer = null;\n    observed.clear();\n  }\n\n  watchPostEffect(() => {\n    const opts = toValue(options);\n    const nextSignature = intersectionSignature(opts);\n    const nextRoot = opts?.root ?? null;\n\n    // Observer init is immutable once constructed, so an options change is the one thing that forces a rebuild.\n    if (nextSignature !== signature || nextRoot !== root) {\n      teardown();\n      signature = nextSignature;\n      root = nextRoot;\n    }\n\n    const next = new Set<Element>();\n    if (opts?.disabled !== true) {\n      for (const element of toValue(targets)) {\n        if (element) next.add(element);\n      }\n    }\n\n    if (next.size === 0) {\n      teardown();\n      return;\n    }\n    if (!supportsIntersectionObserver()) return;\n\n    const current =\n      observer ??\n      new IntersectionObserver((entries, self) => {\n        for (const entry of entries) callback(entry, self);\n      }, toIntersectionInit(opts));\n    observer = current;\n\n    // Snapshot before mutating — deleting from a Set mid-iteration is legal but reads as a trap.\n    for (const element of [...observed]) {\n      if (!next.has(element)) {\n        current.unobserve(element);\n        observed.delete(element);\n      }\n    }\n    for (const element of next) {\n      if (!observed.has(element)) {\n        current.observe(element);\n        observed.add(element);\n      }\n    }\n  });\n\n  onScopeDispose(teardown);\n}\n","// `useMutationObserver` — react to DOM changes made by code this component does not own: a third-party widget\n// that injects nodes, a portal target filling in, a `contenteditable` the user is typing into, an external\n// script toggling an attribute. Inside Vue you use reactive state; this is the escape hatch for everything\n// outside it.\n//\n// THE CALLBACK IS CALLED THROUGH THE CLOSURE, so consumers never have to memoize it. Mutation callbacks are\n// usually written inline and usually close over reactive state; a component's `setup` runs once, so the one the\n// consumer passes is the one and only, and the subscription itself is never churned by its identity.\n//\n// SUBSCRIPTION LIFECYCLE IS A PLAIN POST-FLUSH EFFECT. A template ref is reactive, so `watchPostEffect` re-runs\n// exactly when the node or the options change and never otherwise. `mutationSignature` stays exported from the\n// core for a non-Vue caller, but this file has no use for it.\n//\n// RECORDS ARRIVE AS A BATCH AND ARE PASSED THROUGH AS ONE. They are a transaction; see `ObserveMutation`.\n//\n// NO `once` KNOB. Unlike an intersection, \"the DOM changed once\" is almost never the interesting event — the\n// consumer wants the mutations for as long as the node is mounted. A caller that genuinely wants one shot\n// disconnects from inside the callback, which is why the observer is handed to it.\n\nimport { toValue, watchPostEffect, type MaybeRefOrGetter } from 'vue';\n\nimport { observeMutation, supportsMutationObserver, type MutationOptions } from '../ObserveMutation';\n\n/** The `MutationObserverInit` flags plus the one lifecycle knob. */\nexport interface UseMutationObserverOptions extends MutationOptions {\n  /** Suspend observation without tearing down. Flipping it back re-subscribes to the current node. */\n  readonly disabled?: boolean;\n}\n\n/**\n * Runs `callback` whenever the node behind `target` mutates.\n *\n * With no options, watches `childList` — additions and removals of direct children. Add `subtree: true` to\n * extend that (and every other flag) to descendants.\n *\n * Takes the node as a ref or getter rather than handing one back. Records describe what ALREADY happened; the\n * DOM is in its post-mutation state by the time the callback runs.\n *\n * @param target Points at the node to watch. Changing it re-subscribes.\n * @param callback Receives the batch of records plus the observer, so a caller can disconnect from inside.\n * @param options Which mutation kinds to report, plus `disabled`.\n */\nexport function useMutationObserver<T extends Node>(\n  target: MaybeRefOrGetter<T | null | undefined>,\n  callback: (records: ReadonlyArray<MutationRecord>, observer: MutationObserver) => void,\n  options?: MaybeRefOrGetter<UseMutationObserverOptions | undefined>,\n): void {\n  watchPostEffect((onCleanup) => {\n    const opts = toValue(options);\n    const node = opts?.disabled === true ? null : toValue(target);\n    if (!node || !supportsMutationObserver()) return;\n\n    const dispose = observeMutation(node, (records, observer) => callback(records, observer), opts);\n    onCleanup(dispose);\n  });\n}\n"],"names":["NoopDisposer"],"mappings":"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"}

package/dist/foundation/optionals/index.d.ts

@@ -0,0 +1 @@
+export { OptionalExtensions } from './OptionalExtensions';

package/dist/foundation/optionals/index.js

@@ -0,0 +1,5 @@
+import { O } from "../../chunks/OptionalExtensions-NiO6gV0W.js";
+export {
+  O as OptionalExtensions
+};
+//# sourceMappingURL=index.js.map

package/dist/foundation/optionals/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/foundation/primitives/accessibleIcon/AccessibleIcon.d.ts

@@ -1,7 +1,6 @@
-import { DefineComponent, ExtractPropTypes, VNode, RendererNode, RendererElement, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 export interface AccessibleIconProps {
     /** The accessible label for the icon. */
-    label: string;
+    readonly label: string;
 }
 /**
  * Wrap an icon-only element with an accessible label. The icon is hidden
@@ -12,16 +11,16 @@ export interface AccessibleIconProps {
  * rebuild someone else's vnode. `cloneVNode`'s prop merge is safe here — these
  * two attributes collide with neither class, style, nor a handler.
  */
-export declare const AccessibleIcon: DefineComponent<ExtractPropTypes<{
+export declare const AccessibleIcon: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     label: {
         type: StringConstructor;
         required: true;
     };
-}>, () => VNode<RendererNode, RendererElement, {
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
     [key: string]: any;
-}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     label: {
         type: StringConstructor;
         required: true;
     };
-}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/foundation/primitives/anchoredPositioner/AnchoredPositioner.vue.d.ts

@@ -1,23 +1,23 @@
 import { Placement } from '@floating-ui/vue';
-import { HTMLAttributes, DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { HTMLAttributes } from 'vue';
 export interface AnchoredPositionerProps extends /* @vue-ignore */ HTMLAttributes {
     /** The element the floating layer should be anchored to. */
-    anchor: HTMLElement | null;
+    readonly anchor: HTMLElement | null;
     /** The Floating UI placement. Default `bottom`. */
-    placement?: Placement;
+    readonly placement?: Placement;
     /** The distance between anchor and floating element in px. Default 8. */
-    offset?: number;
+    readonly offset?: number;
     /** The open flag — renders the floating element only when open. */
-    isOpen?: boolean;
+    readonly isOpen?: boolean;
 }
-declare const _default: __VLS_WithSlots< DefineComponent<{
+declare const _default: __VLS_WithSlots<import('vue').DefineComponent<{
     anchor: HTMLElement | null;
     placement?: Placement;
     offset?: number;
     isOpen?: boolean;
 }, {
-    el: Readonly< ShallowRef<HTMLDivElement | null>>;
-}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{
+    el: Readonly<import('vue').ShallowRef<HTMLDivElement | null>>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
     anchor: HTMLElement | null;
     placement?: Placement;
     offset?: number;
@@ -26,8 +26,9 @@ declare const _default: __VLS_WithSlots< DefineComponent<{
     offset: number;
     placement: Placement;
     isOpen: boolean;
-}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
-    default?: (props: {}) => any;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    /** The floating content positioned against the anchor. */
+    default(): unknown;
 }>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/foundation/primitives/anchoredPositioner/index.d.ts

@@ -1 +1 @@
-export { default as AnchoredPositioner, type AnchoredPositionerProps, } from './AnchoredPositioner.vue';
+export { default as AnchoredPositioner, type AnchoredPositionerProps } from './AnchoredPositioner.vue';

package/dist/foundation/primitives/announce/Announce.vue.d.ts

@@ -1,4 +1,4 @@
-import { HTMLAttributes, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { HTMLAttributes } from 'vue';
 /** Defines the urgency of an ARIA live-region announcement. */
 export declare const Politeness: {
     /** Refers to a non-urgent announcement — `role="status"`, waits for idle. */
@@ -9,16 +9,17 @@ export declare const Politeness: {
 export type Politeness = (typeof Politeness)[keyof typeof Politeness];
 export interface AnnounceProps extends /* @vue-ignore */ HTMLAttributes {
     /** The live-region urgency — `polite` → `role="status"`, `assertive` → `role="alert"`. Default `polite`. */
-    politeness?: Politeness;
+    readonly politeness?: Politeness;
 }
-declare const _default: __VLS_WithSlots< DefineComponent<{
+declare const _default: __VLS_WithSlots<import('vue').DefineComponent<{
     politeness?: Politeness;
-}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
     politeness?: Politeness;
 }> & Readonly<{}>, {
     politeness: Politeness;
-}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
-    default?: (props: {}) => any;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    /** The live-region content, announced whenever it changes. */
+    default(): unknown;
 }>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/foundation/primitives/colorModeProvider/ColorModeProvider.vue.d.ts

@@ -1,16 +1,16 @@
 import { ColorMode } from './ColorModeContext';
-import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 export interface ColorModeProviderProps {
     /** The mode used when nothing is persisted. `'system'` follows the OS preference. Default `'system'`. */
-    defaultMode?: ColorMode | 'system';
+    readonly defaultMode?: ColorMode | 'system';
     /** The `localStorage` key for persistence; pass `null` to disable. Default `'wow-color-mode'`. */
-    storageKey?: string | null;
+    readonly storageKey?: string | null;
 }
-declare const _default: __VLS_WithSlots< DefineComponent<ColorModeProviderProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ColorModeProviderProps> & Readonly<{}>, {
-    defaultMode: ColorMode | "system";
-    storageKey: string | null;
-}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
-    default?: (props: {}) => any;
+declare const _default: __VLS_WithSlots<import('vue').DefineComponent<ColorModeProviderProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ColorModeProviderProps> & Readonly<{}>, {
+    readonly defaultMode: ColorMode | "system";
+    readonly storageKey: string | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    /** The subtree that reads the active color mode. */
+    default(): unknown;
 }>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/foundation/primitives/colorModeProvider/index.d.ts

@@ -1,2 +1,2 @@
-export { default as ColorModeProvider, type ColorModeProviderProps, } from './ColorModeProvider.vue';
-export { useColorMode, ColorMode, ColorModeKey, type ColorModeContextValue, } from './ColorModeContext';
+export { default as ColorModeProvider, type ColorModeProviderProps } from './ColorModeProvider.vue';
+export { useColorMode, ColorMode, ColorModeKey, type ColorModeContextValue } from './ColorModeContext';

package/dist/foundation/primitives/directionProvider/DirectionProvider.vue.d.ts

@@ -1,10 +1,10 @@
 import { Direction } from './DirectionContext';
-import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 export interface DirectionProviderProps {
-    dir: Direction;
+    readonly dir: Direction;
 }
-declare const _default: __VLS_WithSlots< DefineComponent<DirectionProviderProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<DirectionProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
-    default?: (props: {}) => any;
+declare const _default: __VLS_WithSlots<import('vue').DefineComponent<DirectionProviderProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<DirectionProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    /** The subtree that reads the provided reading direction. */
+    default(): unknown;
 }>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/foundation/primitives/dismissableLayer/DismissableLayer.vue.d.ts

@@ -1,18 +1,18 @@
-import { HTMLAttributes, DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { HTMLAttributes } from 'vue';
 export interface DismissableLayerProps extends /* @vue-ignore */ HTMLAttributes {
     /** Fires when Escape is pressed and this is the topmost layer. */
-    onEscape?: (event: KeyboardEvent) => void;
-    /** Fires when a pointerdown lands outside this layer's DOM and this is topmost. */
-    onOutsidePointerDown?: (event: PointerEvent) => void;
-    /** The Escape-listener disable flag for this layer. */
-    isEscapeDisabled?: boolean;
-    /** The outside-pointer-down-listener disable flag for this layer. */
-    isOutsideClickDisabled?: boolean;
+    readonly onEscape?: (event: KeyboardEvent) => void;
+    /** Fires when a pointerdown lands outside the topmost layer. */
+    readonly onOutsidePointerDown?: (event: PointerEvent) => void;
+    /** Suppress Escape for this layer without activating an underlying layer. */
+    readonly isEscapeDisabled?: boolean;
+    /** Suppress outside dismissal without activating an underlying layer. */
+    readonly isOutsideClickDisabled?: boolean;
 }
-declare const _default: __VLS_WithSlots< DefineComponent<DismissableLayerProps, {
-    el: Readonly< ShallowRef<HTMLDivElement | null>>;
-}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<DismissableLayerProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
-    default?: (props: {}) => any;
+declare const _default: __VLS_WithSlots<import('vue').DefineComponent<DismissableLayerProps, {
+    el: Readonly<import('vue').ShallowRef<HTMLDivElement | null>>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<DismissableLayerProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default(): unknown;
 }>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {