@vizejs/composable 0.345.0 → 0.347.7

package/dist/index.mjs

@@ -1,751 +1,19 @@
-import { computed, getCurrentScope, onScopeDispose, readonly, ref, shallowRef, toValue, watch, watchEffect } from "vue";
-//#region src/scope.ts
-/**
-* Register cleanup in the active reactive scope when one exists.
-*
-* This is the shared lifecycle primitive of the package: composables hand
-* their teardown here so owned resources are released when the surrounding
-* scope stops.
-*
-* Never throws and is safe during server rendering; no browser globals are
-* read. When no scope is active the cleanup is not registered and disposal
-* ownership stays with the caller.
-*
-* @param cleanup Cleanup invoked exactly once when the scope is disposed.
-* @returns Whether the cleanup was registered.
-*/
-function tryOnScopeDispose(cleanup) {
-	if (!getCurrentScope()) return false;
-	onScopeDispose(cleanup);
-	return true;
-}
-//#endregion
-//#region src/async-resource.ts
-/**
-* Create a scoped, abortable asynchronous resource with latest-result-wins
-* state. Every execution returns a discriminated result, so cancellation,
-* supersession, loader failure, and successful `undefined` data stay distinct.
-*
-* When created inside an active reactive scope (and `scope` is enabled), the
-* active execution is aborted when that scope stops; outside a scope,
-* cancellation ownership stays with the caller. The execute promise never
-* rejects — synchronous and asynchronous loader failures both settle into
-* the `"error"` result. Safe during server rendering: no browser globals are
-* read and abort reasons use the runtime-native `DOMException`.
-*
-* @param loader Asynchronous loader receiving the abort context first.
-* @param options Data retention, supersession, and scope behavior.
-* @default options {}
-* @returns Reactive state and controls for the loader.
-*/
-function useAsyncResource(loader, options = {}) {
-	const data = shallowRef(options.initialData);
-	const error = shallowRef(void 0);
-	const status = shallowRef("idle");
-	const pending = computed(() => status.value === "pending");
-	let generation = 0;
-	let active;
-	const cancel = (reason = createAbortReason("The execution was cancelled.")) => {
-		if (active === void 0) return false;
-		generation += 1;
-		active.controller.abort(reason);
-		active = void 0;
-		status.value = "cancelled";
-		return true;
-	};
-	const execute = async (...arguments_) => {
-		if ((options.cancelPrevious ?? true) && active !== void 0) {
-			active.superseded = true;
-			active.controller.abort(createAbortReason("A newer execution started."));
-		}
-		const record = {
-			generation: ++generation,
-			controller: new AbortController(),
-			superseded: false
-		};
-		active = record;
-		error.value = void 0;
-		status.value = "pending";
-		if (!(options.keepData ?? true)) data.value = void 0;
-		try {
-			const result = await loader({ signal: record.controller.signal }, ...arguments_);
-			if (record.generation !== generation) return executionAfterInvalidation(record);
-			data.value = result;
-			status.value = "success";
-			return {
-				status: "success",
-				data: result
-			};
-		} catch (cause) {
-			if (record.generation !== generation || record.controller.signal.aborted) return executionAfterInvalidation(record);
-			error.value = cause;
-			status.value = "error";
-			return {
-				status: "error",
-				error: cause
-			};
-		} finally {
-			if (active === record) active = void 0;
-		}
-	};
-	const reset = () => {
-		cancel(createAbortReason("The resource was reset."));
-		data.value = options.initialData;
-		error.value = void 0;
-		status.value = "idle";
-	};
-	if (options.scope ?? true) tryOnScopeDispose(() => cancel(createAbortReason("The reactive scope was disposed.")));
-	return {
-		data,
-		error,
-		status,
-		pending,
-		execute,
-		cancel,
-		reset
-	};
-}
-function executionAfterInvalidation(execution) {
-	if (execution.superseded || !execution.controller.signal.aborted) return { status: "superseded" };
-	return {
-		status: "cancelled",
-		reason: execution.controller.signal.reason
-	};
-}
-function createAbortReason(message) {
-	return new DOMException(message, "AbortError");
-}
-//#endregion
-//#region src/event-listener.ts
-function useEventListener(target, event, listener, options = {}) {
-	const { capture = false, once = false, passive = false, signal, immediate = true, flush = "pre" } = options;
-	const isListening = ref(false);
-	const eventOptions = {
-		capture,
-		passive,
-		...signal ? { signal } : {}
-	};
-	let disposed = false;
-	let stopWatch;
-	const stop = () => {
-		stopWatch?.stop();
-		stopWatch = void 0;
-		isListening.value = false;
-	};
-	const start = () => {
-		if (disposed || stopWatch || signal?.aborted) return false;
-		stopWatch = watch(() => toValue(target), (next, _previous, onCleanup) => {
-			isListening.value = false;
-			if (!next || signal?.aborted) return;
-			const invoke = (nativeEvent) => {
-				if (once) stop();
-				listener(nativeEvent);
-			};
-			const onAbort = () => stop();
-			next.addEventListener(event, invoke, eventOptions);
-			signal?.addEventListener("abort", onAbort, { once: true });
-			isListening.value = true;
-			onCleanup(() => {
-				next.removeEventListener(event, invoke, capture);
-				signal?.removeEventListener("abort", onAbort);
-				isListening.value = false;
-			});
-		}, {
-			flush,
-			immediate: true
-		});
-		return true;
-	};
-	tryOnScopeDispose(() => {
-		disposed = true;
-		stop();
-	});
-	if (immediate) start();
-	return {
-		isListening: readonly(isListening),
-		start,
-		stop
-	};
-}
-//#endregion
-//#region src/locale.ts
-const FORMATTER_CACHE_LIMIT = 32;
-/**
-* Create reactive locale metadata and platform-native formatter factories.
-*
-* Equivalent formatter options reuse instances. The bounded cache follows the
-* active locale automatically and prevents repeated constructor overhead in
-* reactive render paths.
-*
-* Detection is lazy and guarded: the default detector reads
-* `navigator.language` behind a `typeof` check at call time, so importing and
-* calling this during server rendering is safe, and runtimes without a
-* `navigator` resolve to the fallback locale. The composable owns no timers
-* or listeners, so no scope cleanup is required.
-*
-* @param source Reactive locale source. Empty values defer to the detector.
-* @param options Detection and fallback behavior.
-* @default options {}
-* @throws `RangeError` on first read of the reactive values when the winning
-* candidate is not a structurally valid locale identifier.
-* @returns Reactive locale metadata and cached formatter factories.
-*/
-function useLocale(source, options = {}) {
-	const locale = computed(() => {
-		const candidate = (source === void 0 ? void 0 : toValue(source)) ?? (options.detect ?? detectBrowserLocale)() ?? options.fallback ?? "en";
-		return candidate instanceof Intl.Locale ? candidate.toString() : new Intl.Locale(candidate).toString();
-	});
-	const details = computed(() => new Intl.Locale(locale.value));
-	const direction = computed(() => details.value.getTextInfo().direction ?? "ltr");
-	const number = createFormatterCache((activeLocale, formatOptions) => new Intl.NumberFormat(activeLocale, formatOptions));
-	const dateTime = createFormatterCache((activeLocale, formatOptions) => new Intl.DateTimeFormat(activeLocale, formatOptions));
-	const list = createFormatterCache((activeLocale, formatOptions) => new Intl.ListFormat(activeLocale, formatOptions));
-	const relativeTime = createFormatterCache((activeLocale, formatOptions) => new Intl.RelativeTimeFormat(activeLocale, formatOptions));
-	return {
-		locale,
-		details,
-		direction,
-		number: (formatOptions) => number(locale.value, formatOptions),
-		dateTime: (formatOptions) => dateTime(locale.value, formatOptions),
-		list: (formatOptions) => list(locale.value, formatOptions),
-		relativeTime: (formatOptions) => relativeTime(locale.value, formatOptions)
-	};
-}
-function detectBrowserLocale() {
-	return typeof navigator === "undefined" ? void 0 : navigator.language;
-}
-function createFormatterCache(create) {
-	const cache = /* @__PURE__ */ new Map();
-	return (locale, options) => {
-		const key = `${locale}\u0000${serializeOptions(options)}`;
-		const cached = cache.get(key);
-		if (cached !== void 0) {
-			cache.delete(key);
-			cache.set(key, cached);
-			return cached;
-		}
-		const formatter = create(locale, options);
-		if (cache.size >= FORMATTER_CACHE_LIMIT) {
-			const oldest = cache.keys().next().value;
-			if (oldest !== void 0) cache.delete(oldest);
-		}
-		cache.set(key, formatter);
-		return formatter;
-	};
-}
-function serializeOptions(options) {
-	if (options === void 0) return "";
-	return JSON.stringify(Object.entries(options).sort(([left], [right]) => left.localeCompare(right)));
-}
-//#endregion
-//#region src/media-query.ts
-/**
-* Evaluate a reactive media query without requiring browser globals.
-*
-* During server rendering (or whenever no capability host resolves) the ref
-* holds the configured server value and no subscription is created. The
-* change subscription follows the reactive query and host: each
-* re-evaluation removes the previous listener, and the final listener is
-* removed when the owning reactive scope stops. Call inside an active scope
-* so the subscription is released. A host whose matcher throws propagates
-* the error to the active effect run; the browser default never throws.
-*
-* @param query Reactive media-query source.
-* @param options Runtime capability and server-rendered fallback.
-* @default options {}
-* @returns Readonly ref that is `true` while the query matches.
-*/
-function useMediaQuery(query, options = {}) {
-	const matches = ref(options.ssrValue ?? false);
-	watchEffect((onCleanup) => {
-		const host = options.host === void 0 ? browserMediaQueryHost() : toValue(options.host);
-		if (!host) {
-			matches.value = options.ssrValue ?? false;
-			return;
-		}
-		const media = host.matchMedia(toValue(query));
-		const update = () => {
-			matches.value = media.matches;
-		};
-		update();
-		media.addEventListener("change", update);
-		onCleanup(() => media.removeEventListener("change", update));
-	});
-	return readonly(matches);
-}
-/**
-* Return the reactive user motion preference.
-*
-* Shares {@link useMediaQuery} semantics: during server rendering the
-* preference is `"no-preference"` unless `ssrValue` is `true`, and the
-* underlying subscription is removed when the owning reactive scope stops.
-*
-* @param options Runtime capability and server-rendered fallback.
-* @default options {}
-* @returns Computed preference for `(prefers-reduced-motion: reduce)`.
-*/
-function useReducedMotion(options = {}) {
-	const reduced = useMediaQuery("(prefers-reduced-motion: reduce)", options);
-	return computed(() => reduced.value ? "reduce" : "no-preference");
-}
-function browserMediaQueryHost() {
-	return typeof window !== "undefined" && typeof window.matchMedia === "function" ? window : void 0;
-}
-//#endregion
-//#region src/use-counter.ts
-/**
-* Create a clamped counter whose every transition stays inside `[min, max]`.
-*
-* All operations clamp instead of failing, including the initial value, so
-* the count is inside the bounds at every observable moment. Only `NaN` is
-* rejected — silently corrupting the count is never an option. Purely
-* synchronous state: safe during server rendering (no browser globals, no
-* timers) and nothing to dispose, so it works inside and outside reactive
-* scopes alike. Bounds are fixed at creation and not reactive.
-*
-* @example
-* ```ts
-* const { count, increment, atMax } = useCounter(9, { min: 0, max: 10 });
-* increment(); // 10
-* increment(); // 10 (clamped)
-* atMax.value; // true
-* ```
-*
-* @param initial Count before any operation, clamped into the bounds.
-* @default initial 0
-* @param options Inclusive bounds for every value the counter takes.
-* @default options {}
-* @throws `RangeError` tagged `VIZE_COMPOSE_COUNTER_INVALID_RANGE` when a
-* bound is `NaN` or `min` exceeds `max`.
-* @throws `RangeError` tagged `VIZE_COMPOSE_COUNTER_INVALID_VALUE` when an
-* initial value, operand, or arithmetic result is `NaN` (for example
-* incrementing `-Infinity` by `Infinity`); the count is left unchanged.
-* @returns Reactive count, bound flags, and mutation controls.
-*/
-function useCounter(initial = 0, options = {}) {
-	const min = requireBound(options.min ?? Number.NEGATIVE_INFINITY, "min");
-	const max = requireBound(options.max ?? Number.POSITIVE_INFINITY, "max");
-	if (min > max) throw new RangeError(`[VIZE_COMPOSE_COUNTER_INVALID_RANGE] min must not exceed max; received min ${String(min)} and max ${String(max)}`);
-	const clamp = (value) => Math.min(max, Math.max(min, value));
-	const count = shallowRef(clamp(requireValue(initial)));
-	let baseline = count.value;
-	const setClamped = (next) => {
-		count.value = clamp(requireValue(next));
-		return count.value;
-	};
-	const reset = (value) => {
-		const applied = setClamped(value ?? baseline);
-		if (value !== void 0) baseline = applied;
-		return applied;
-	};
-	return {
-		count,
-		atMin: computed(() => count.value === min),
-		atMax: computed(() => count.value === max),
-		increment: (delta = 1) => setClamped(count.value + requireValue(delta)),
-		decrement: (delta = 1) => setClamped(count.value - requireValue(delta)),
-		set: setClamped,
-		reset
-	};
-}
-function requireBound(value, label) {
-	if (Number.isNaN(value)) throw new RangeError(`[VIZE_COMPOSE_COUNTER_INVALID_RANGE] ${label} must not be NaN`);
-	return value;
-}
-function requireValue(value) {
-	if (Number.isNaN(value)) throw new RangeError("[VIZE_COMPOSE_COUNTER_INVALID_VALUE] the value is NaN; counter state was left unchanged");
-	return value;
-}
-//#endregion
-//#region src/use-debounced.ts
-const defaultScheduler$1 = {
-	setTimeout: (callback, delayMs) => globalThis.setTimeout(callback, delayMs),
-	clearTimeout: (handle) => {
-		globalThis.clearTimeout(handle);
-	}
-};
-/**
-* Create a readonly debounced view of a reactive source.
-*
-* The view starts at the current source value. Each source change (observed
-* with `flush: "sync"`, so every synchronous write counts) restarts a
-* single-shot timer of `waitMs` milliseconds; when it fires, the view takes
-* the source value current at that moment. `waitMs` is reactive and is read
-* when a timer is scheduled; changing it does not restart an already-pending
-* timer. A wait of `0` still defers to the next scheduler tick.
-*
-* Server rendering is explicit: without a browser `window` (and with
-* {@link UseDebouncedOptions.runOnServer} disabled) no timer ever starts and
-* the view mirrors the source synchronously, so server-rendered output shows
-* current values and nothing leaks. `pending` stays `false` and the controls
-* report `false` in that mode.
-*
-* Cleanup rule: the watcher and any pending timer are released when the
-* owning reactive scope stops; call inside an active scope. Outside one, the
-* watcher lives as long as the source and `cancel()` only clears the pending
-* timer.
-*
-* @example
-* ```ts
-* const query = shallowRef("");
-* const { debounced, flush } = useDebounced(query, 300);
-* query.value = "vize"; // debounced.value still "" for 300ms
-* flush(); // debounced.value === "vize" immediately
-* ```
-*
-* @param source Reactive source to debounce.
-* @param waitMs Reactive delay in milliseconds; must be finite and at least
-* zero. Fractions are truncated.
-* @param options Runtime scheduling overrides.
-* @default options {}
-* @throws `RangeError` tagged `VIZE_COMPOSE_DEBOUNCE_INVALID_WAIT` when the
-* resolved wait is not finite or is negative, both synchronously at creation
-* (even in mirror mode) and again for every scheduled delay.
-* @returns Readonly debounced view, pending flag, and cancel/flush controls.
-*/
-function useDebounced(source, waitMs, options = {}) {
-	const scheduler = options.scheduler ?? defaultScheduler$1;
-	const debounced = shallowRef(toValue(source));
-	const pending = shallowRef(false);
-	let handle;
-	resolveWaitMs$1(toValue(waitMs));
-	const apply = () => {
-		handle = void 0;
-		pending.value = false;
-		debounced.value = toValue(source);
-	};
-	const cancel = () => {
-		if (!pending.value) return false;
-		scheduler.clearTimeout(handle);
-		handle = void 0;
-		pending.value = false;
-		return true;
-	};
-	const flush = () => {
-		if (!pending.value) return false;
-		scheduler.clearTimeout(handle);
-		apply();
-		return true;
-	};
-	watch(() => toValue(source), (next) => {
-		if (typeof window === "undefined" && !(options.runOnServer ?? false)) {
-			debounced.value = next;
-			return;
-		}
-		const delayMs = resolveWaitMs$1(toValue(waitMs));
-		if (pending.value) scheduler.clearTimeout(handle);
-		pending.value = true;
-		handle = scheduler.setTimeout(apply, delayMs);
-	}, { flush: "sync" });
-	tryOnScopeDispose(() => {
-		cancel();
-	});
-	return {
-		debounced,
-		pending,
-		cancel,
-		flush
-	};
-}
-function resolveWaitMs$1(value) {
-	if (!Number.isFinite(value) || value < 0) throw new RangeError(`[VIZE_COMPOSE_DEBOUNCE_INVALID_WAIT] waitMs must be finite and at least zero; received ${String(value)}`);
-	return Math.trunc(value);
-}
-//#endregion
-//#region src/use-history.ts
-/**
-* Record bounded undo/redo history over the writes of a ref.
-*
-* Recording is shallow and identity-based, matching Vue's own change
-* detection: assignments to `source.value` are recorded (observed with
-* `flush: "sync"`, so every synchronous write counts), writes that are
-* `Object.is`-equal to the current value are not changes, and in-place
-* mutations of object values are invisible — pair mutable values with
-* {@link UseHistoryOptions.clone} and reassign. Undoing and redoing restore
-* values through `clone` as well, so snapshots never share identity with the
-* live value unless the default identity clone is kept. When a
-* user-provided `clone` throws, the failed operation leaves history
-* unchanged and the error propagates.
-*
-* Safe during server rendering: no browser globals are read and no timers
-* start. Cleanup rule: when the owning reactive scope stops, recording stops
-* and every retained snapshot is released, so `undo`/`redo` return `false`
-* afterwards; call inside an active scope, or the watcher lives as long as
-* the source.
-*
-* @example
-* ```ts
-* const text = shallowRef("");
-* const { undo, redo, batch } = useHistory(text);
-* text.value = "a";
-* batch(() => {
-*   text.value = "ab";
-*   text.value = "abc";
-* });
-* undo(); // text.value === "a" (the batch is one step)
-* redo(); // text.value === "abc"
-* ```
-*
-* @param source Ref whose writes are recorded.
-* @param options Retention bound and snapshot cloning.
-* @default options {}
-* @throws `RangeError` tagged `VIZE_COMPOSE_HISTORY_INVALID_CAPACITY` when
-* the capacity is not an integer greater than zero.
-* @throws `Error` tagged `VIZE_COMPOSE_HISTORY_IN_BATCH` when `undo`,
-* `redo`, or `clear` is called inside {@link HistoryControls.batch}, where
-* stack movement would corrupt the pending group.
-* @returns Reactive undo/redo state and controls.
-*/
-function useHistory(source, options = {}) {
-	const capacity = options.capacity ?? 100;
-	if (!Number.isInteger(capacity) || capacity < 1) throw new RangeError(`[VIZE_COMPOSE_HISTORY_INVALID_CAPACITY] capacity must be an integer greater than zero; received ${String(capacity)}`);
-	const clone = options.clone ?? ((value) => value);
-	const undoStack = shallowRef([]);
-	const redoStack = shallowRef([]);
-	let restoring = false;
-	let batchDepth = 0;
-	let activeBatch;
-	const pushUndo = (entry) => {
-		const next = [...undoStack.value, entry];
-		undoStack.value = next.length > capacity ? next.slice(next.length - capacity) : next;
-		redoStack.value = [];
-	};
-	const writeSilently = (value) => {
-		restoring = true;
-		try {
-			source.value = value;
-		} finally {
-			restoring = false;
-		}
-	};
-	const requireOutsideBatch = (operation) => {
-		if (batchDepth > 0) throw new Error(`[VIZE_COMPOSE_HISTORY_IN_BATCH] ${operation}() is not available inside batch()`);
-	};
-	const undo = () => {
-		requireOutsideBatch("undo");
-		const entry = undoStack.value.at(-1);
-		if (entry === void 0) return false;
-		const restored = clone(entry.value);
-		const recorded = { value: clone(source.value) };
-		undoStack.value = undoStack.value.slice(0, -1);
-		redoStack.value = [...redoStack.value, recorded];
-		writeSilently(restored);
-		return true;
-	};
-	const redo = () => {
-		requireOutsideBatch("redo");
-		const entry = redoStack.value.at(-1);
-		if (entry === void 0) return false;
-		const restored = clone(entry.value);
-		const recorded = { value: clone(source.value) };
-		redoStack.value = redoStack.value.slice(0, -1);
-		undoStack.value = [...undoStack.value, recorded];
-		writeSilently(restored);
-		return true;
-	};
-	const batch = (run) => {
-		if (batchDepth === 0) activeBatch = {
-			raw: source.value,
-			entry: { value: clone(source.value) }
-		};
-		batchDepth += 1;
-		try {
-			return run();
-		} finally {
-			batchDepth -= 1;
-			if (batchDepth === 0 && activeBatch !== void 0) {
-				const finished = activeBatch;
-				activeBatch = void 0;
-				if (!Object.is(finished.raw, source.value)) pushUndo(finished.entry);
-			}
-		}
-	};
-	const clear = () => {
-		requireOutsideBatch("clear");
-		undoStack.value = [];
-		redoStack.value = [];
-	};
-	const handle = watch(source, (_next, replaced) => {
-		if (restoring || batchDepth > 0) return;
-		pushUndo({ value: clone(replaced) });
-	}, { flush: "sync" });
-	tryOnScopeDispose(() => {
-		handle.stop();
-		undoStack.value = [];
-		redoStack.value = [];
-	});
-	return {
-		canUndo: computed(() => undoStack.value.length > 0),
-		canRedo: computed(() => redoStack.value.length > 0),
-		undoCount: computed(() => undoStack.value.length),
-		redoCount: computed(() => redoStack.value.length),
-		undo,
-		redo,
-		batch,
-		clear
-	};
-}
-//#endregion
-//#region src/use-previous.ts
-function usePrevious(source, ...initial) {
-	const previous = shallowRef(initial.length === 1 ? initial[0] : void 0);
-	watch(() => toValue(source), (_next, replaced) => {
-		previous.value = replaced;
-	}, { flush: "sync" });
-	return previous;
-}
-//#endregion
-//#region src/use-throttled.ts
-const defaultScheduler = {
-	setTimeout: (callback, delayMs) => globalThis.setTimeout(callback, delayMs),
-	clearTimeout: (handle) => {
-		globalThis.clearTimeout(handle);
-	}
-};
-/**
-* Create a readonly throttled view of a reactive source.
-*
-* Changes are observed with `flush: "sync"`, so every synchronous write
-* counts. Outside a cooldown window, a change applies immediately when
-* {@link UseThrottledOptions.leading} is enabled (otherwise it waits as a
-* trailing update) and opens a window of `waitMs` milliseconds. Changes
-* inside a window are collected as the trailing candidate; when the window
-* ends with a candidate waiting, the source value current at that moment is
-* applied and the next window opens back to back, keeping applications
-* spaced by `waitMs`. A window that ends without a candidate closes silently.
-* `waitMs` is reactive and is read each time a window opens; changing it
-* never disturbs an already-open window. A wait of `0` still defers trailing
-* updates to the next scheduler tick.
-*
-* Server rendering is explicit: without a browser `window` (and with
-* {@link UseThrottledOptions.runOnServer} disabled) no timer ever starts and
-* the view mirrors the source synchronously, so server-rendered output shows
-* current values and nothing leaks. `pending` stays `false` and the controls
-* report `false` in that mode.
-*
-* Cleanup rule: the watcher and any open window timer are released when the
-* owning reactive scope stops; call inside an active scope. Outside one, the
-* watcher lives as long as the source and `cancel()` only clears the window.
-*
-* @example
-* ```ts
-* const scrollY = shallowRef(0);
-* const { throttled } = useThrottled(scrollY, 100);
-* scrollY.value = 40; // applied immediately (leading edge)
-* scrollY.value = 80; // applied when the 100ms window ends
-* ```
-*
-* @param source Reactive source to throttle.
-* @param waitMs Reactive cooldown in milliseconds; must be finite and at
-* least zero. Fractions are truncated.
-* @param options Edge policy and runtime scheduling overrides.
-* @default options {}
-* @throws `RangeError` tagged `VIZE_COMPOSE_THROTTLE_INVALID_WAIT` when the
-* resolved wait is not finite or is negative, both synchronously at creation
-* (even in mirror mode) and again each time a window opens.
-* @throws `TypeError` tagged `VIZE_COMPOSE_THROTTLE_INVALID_EDGES` when both
-* `leading` and `trailing` are disabled, because updates could then never
-* propagate.
-* @returns Readonly throttled view, pending flag, and cancel/flush controls.
-*/
-function useThrottled(source, waitMs, options = {}) {
-	const leading = options.leading ?? true;
-	const trailing = options.trailing ?? true;
-	if (!leading && !trailing) throw new TypeError("[VIZE_COMPOSE_THROTTLE_INVALID_EDGES] at least one of leading or trailing must be enabled");
-	const scheduler = options.scheduler ?? defaultScheduler;
-	const throttled = shallowRef(toValue(source));
-	const pending = shallowRef(false);
-	let windowHandle;
-	let windowOpen = false;
-	resolveWaitMs(toValue(waitMs));
-	const openWindow = () => {
-		windowOpen = true;
-		windowHandle = scheduler.setTimeout(() => {
-			windowHandle = void 0;
-			if (!pending.value) {
-				windowOpen = false;
-				return;
-			}
-			pending.value = false;
-			throttled.value = toValue(source);
-			openWindow();
-		}, resolveWaitMs(toValue(waitMs)));
-	};
-	const closeWindow = () => {
-		if (windowOpen) scheduler.clearTimeout(windowHandle);
-		windowHandle = void 0;
-		windowOpen = false;
-		pending.value = false;
-	};
-	const cancel = () => {
-		const hadTrailing = pending.value;
-		closeWindow();
-		return hadTrailing;
-	};
-	const flush = () => {
-		if (!pending.value) return false;
-		closeWindow();
-		throttled.value = toValue(source);
-		return true;
-	};
-	watch(() => toValue(source), (next) => {
-		if (typeof window === "undefined" && !(options.runOnServer ?? false)) {
-			throttled.value = next;
-			return;
-		}
-		if (windowOpen) {
-			if (trailing) pending.value = true;
-			return;
-		}
-		if (leading) throttled.value = next;
-		else pending.value = true;
-		openWindow();
-	}, { flush: "sync" });
-	tryOnScopeDispose(() => {
-		cancel();
-	});
-	return {
-		throttled,
-		pending,
-		cancel,
-		flush
-	};
-}
-function resolveWaitMs(value) {
-	if (!Number.isFinite(value) || value < 0) throw new RangeError(`[VIZE_COMPOSE_THROTTLE_INVALID_WAIT] waitMs must be finite and at least zero; received ${String(value)}`);
-	return Math.trunc(value);
-}
-//#endregion
-//#region src/use-toggle.ts
-/**
-* Create owned boolean state with an inverting control.
-*
-* Purely synchronous state: safe during server rendering (no browser
-* globals, no timers) and nothing to dispose, so it works inside and
-* outside reactive scopes alike.
-*
-* @example
-* ```ts
-* const { state: open, toggle } = useToggle();
-* toggle(); // true
-* toggle(false); // false
-* open.value; // false
-* ```
-*
-* @param initial State before the first toggle.
-* @default initial false
-* @returns The writable state and its toggle control.
-*/
-function useToggle(initial = false) {
-	const state = shallowRef(initial);
-	const toggle = (force) => {
-		state.value = force ?? !state.value;
-		return state.value;
-	};
-	return {
-		state,
-		toggle
-	};
-}
-//#endregion
-export { tryOnScopeDispose, useAsyncResource, useCounter, useDebounced, useEventListener, useHistory, useLocale, useMediaQuery, usePrevious, useReducedMotion, useThrottled, useToggle };
+import { anyAbortSignal, deadlineAbortSignal, timeoutAbortSignal } from "./abort-signal.mjs";
+import { tryOnScopeDispose } from "./scope.mjs";
+import { useAsyncResource } from "./async-resource.mjs";
+import { availableCapability, isCapabilityAvailable, isCapabilityUnavailable, unavailableCapability } from "./capability.mjs";
+import { t as COMPOSABLE_CATALOG } from "./catalog-DOXTbk4r.mjs";
+import { DISPOSAL_ERROR_CODE, DisposalError, createDisposalScope } from "./disposal-scope.mjs";
+import { useEventListener } from "./event-listener.mjs";
+import { useLocale } from "./locale.mjs";
+import { useMediaQuery, useReducedMotion } from "./media-query.mjs";
+import { calculateRetryDelay } from "./retry-delay.mjs";
+import { retryAsync } from "./retry-async.mjs";
+import "./timeout-scheduler.mjs";
+import { useCounter } from "./use-counter.mjs";
+import { useDebounced } from "./use-debounced.mjs";
+import { useHistory } from "./use-history.mjs";
+import { usePrevious } from "./use-previous.mjs";
+import { useThrottled } from "./use-throttled.mjs";
+import { useToggle } from "./use-toggle.mjs";
+export { COMPOSABLE_CATALOG, DISPOSAL_ERROR_CODE, DisposalError, anyAbortSignal, availableCapability, calculateRetryDelay, createDisposalScope, deadlineAbortSignal, isCapabilityAvailable, isCapabilityUnavailable, retryAsync, timeoutAbortSignal, tryOnScopeDispose, unavailableCapability, useAsyncResource, useCounter, useDebounced, useEventListener, useHistory, useLocale, useMediaQuery, usePrevious, useReducedMotion, useThrottled, useToggle };