@vizejs/composable 0.426.2 → 0.427.0

package/dist/catalog.d.mts

@@ -1,2 +1,2 @@
-import { a as ComposableEntryMetadata, c as ComposableRootEntryMetadata, d as ComposableUtilityMetadata, i as ComposableCleanupOwner, l as ComposableSsrBehavior, n as ComposableCatalog, o as ComposableHydrationBehavior, r as ComposableCategory, s as ComposableInstallationAvailability, t as COMPOSABLE_CATALOG, u as ComposableStability } from "./catalog-D2AL3xYl.mjs";
+import { a as ComposableEntryMetadata, c as ComposableRootEntryMetadata, d as ComposableUtilityMetadata, i as ComposableCleanupOwner, l as ComposableSsrBehavior, n as ComposableCatalog, o as ComposableHydrationBehavior, r as ComposableCategory, s as ComposableInstallationAvailability, t as COMPOSABLE_CATALOG, u as ComposableStability } from "./catalog-BeTXFKxF.mjs";
 export { COMPOSABLE_CATALOG, type ComposableCatalog, type ComposableCategory, type ComposableCleanupOwner, type ComposableEntryMetadata, type ComposableHydrationBehavior, type ComposableInstallationAvailability, type ComposableRootEntryMetadata, type ComposableSsrBehavior, type ComposableStability, type ComposableUtilityMetadata };

package/dist/catalog.mjs

@@ -1,2 +1,2 @@
-import { t as COMPOSABLE_CATALOG } from "./catalog-D5SYCsgW.mjs";
+import { t as COMPOSABLE_CATALOG } from "./catalog-r4Z5nptX.mjs";
 export { COMPOSABLE_CATALOG };

package/dist/color-mode.d.mts

@@ -0,0 +1,131 @@
+import { n as MaybeElementTarget } from "./element-target-Crpxl4D9.mjs";
+import { MediaQueryHost } from "./media-query.mjs";
+import { StorageLike } from "./use-storage.mjs";
+import { ComputedRef, MaybeRefOrGetter, WritableComputedRef } from "vue";
+
+//#region src/color-mode.d.ts
+/** Built-in color modes. */
+type BasicColorMode = "light" | "dark";
+/** Selectable mode: a built-in mode, a custom mode, or `"auto"` (follow the system). */
+type ColorModeValue<Custom extends string = never> = BasicColorMode | Custom | "auto";
+/**
+ * Synchronous key-value persistence used by {@link useColorMode}.
+ *
+ * The read/write subset of `StorageLike` from `./use-storage`, so
+ * `localStorage`, `sessionStorage`, and the same adapters work for both. For
+ * hydration-stable SSR pass a cookie-backed adapter that reads the request
+ * cookie on the server and `document.cookie` on the client.
+ */
+type ColorModeStorage = Pick<StorageLike, "getItem" | "setItem">;
+/** Options for {@link useColorMode}. */
+interface UseColorModeOptions<Custom extends string = never> {
+  /**
+   * Class name (or attribute value) written for each mode. Custom modes must
+   * be listed here.
+   *
+   * @default { light: "light", dark: "dark" }
+   */
+  readonly modes?: Readonly<Partial<Record<BasicColorMode, string>> & Record<Custom, string>>;
+  /**
+   * `"class"` toggles class names; any other value is used as an attribute
+   * name (e.g. `"data-theme"`).
+   *
+   * @default "class"
+   */
+  readonly attribute?: string;
+  /**
+   * Element that receives the class/attribute.
+   *
+   * @default document.documentElement when available
+   */
+  readonly target?: MaybeElementTarget;
+  /**
+   * Mode used when nothing is stored.
+   *
+   * @default "auto"
+   */
+  readonly initialValue?: ColorModeValue<Custom>;
+  /**
+   * Storage key. `null` disables persistence.
+   *
+   * @default "vize-color-mode"
+   */
+  readonly storageKey?: string | null;
+  /**
+   * Persistence adapter. `null` disables persistence.
+   *
+   * @default globalThis.window.localStorage when available
+   */
+  readonly storage?: ColorModeStorage | null;
+  /**
+   * System preference assumed while no media capability exists (server rendering).
+   *
+   * @default "light"
+   */
+  readonly ssrSystem?: BasicColorMode;
+  /**
+   * Suppress CSS transitions for one frame while switching modes.
+   *
+   * @default true
+   */
+  readonly disableTransition?: boolean;
+  /**
+   * Media capability used to read `prefers-color-scheme`.
+   *
+   * @default globalThis.window when available
+   */
+  readonly host?: MaybeRefOrGetter<MediaQueryHost | null | undefined>;
+}
+/** Reactive color mode returned by {@link useColorMode}. */
+interface ColorModeControls<Custom extends string> {
+  /** Selected mode, including `"auto"`. Assigning persists and applies it. */
+  readonly mode: WritableComputedRef<ColorModeValue<Custom>>;
+  /** System preference from `prefers-color-scheme`. */
+  readonly system: ComputedRef<BasicColorMode>;
+  /** Resolved mode (`"auto"` replaced by the system preference). */
+  readonly state: ComputedRef<BasicColorMode | Custom>;
+  /** Value read from storage at creation (or the initial value). */
+  readonly stored: ComputedRef<ColorModeValue<Custom>>;
+}
+/**
+ * Reactive color mode with persistence and DOM application.
+ *
+ * The stored mode is read synchronously during setup through the injected
+ * storage, so a cookie adapter yields identical server and client renders.
+ * On the client the resolved mode is written to the target's class list (or
+ * attribute) after each change, optionally with transitions suppressed.
+ * Nothing touches the DOM during server rendering.
+ *
+ * @param options Modes, target, persistence, SSR fallback, and capabilities.
+ * @default options {}
+ * @returns Writable mode plus system and resolved state.
+ */
+declare function useColorMode<const Custom extends string = never>(options?: UseColorModeOptions<Custom>): ColorModeControls<Custom>;
+/** Options for {@link useDark}. */
+interface UseDarkOptions extends Omit<UseColorModeOptions, "modes"> {
+  /**
+   * Class/attribute value applied in dark mode.
+   *
+   * @default "dark"
+   */
+  readonly valueDark?: string;
+  /**
+   * Class/attribute value applied in light mode.
+   *
+   * @default ""
+   */
+  readonly valueLight?: string;
+}
+/**
+ * Boolean dark-mode switch built on {@link useColorMode}.
+ *
+ * Setting the ref to the current system preference stores `"auto"`, so the
+ * page keeps following the system until the user picks the opposite mode.
+ *
+ * @param options Dark/light values plus {@link useColorMode} options.
+ * @default options {}
+ * @returns Writable dark flag.
+ */
+declare function useDark(options?: UseDarkOptions): WritableComputedRef<boolean>;
+//#endregion
+export { BasicColorMode, ColorModeControls, ColorModeStorage, ColorModeValue, UseColorModeOptions, UseDarkOptions, useColorMode, useDark };

package/dist/color-mode.mjs

@@ -0,0 +1,133 @@
+import { tryOnScopeDispose } from "./scope.mjs";
+import { resolveElement } from "./element-target.mjs";
+import { useMediaQuery } from "./media-query.mjs";
+import { computed, hasInjectionContext, onMounted, shallowRef, watch } from "vue";
+//#region src/color-mode.ts
+/**
+* Reactive color mode with persistence and DOM application.
+*
+* The stored mode is read synchronously during setup through the injected
+* storage, so a cookie adapter yields identical server and client renders.
+* On the client the resolved mode is written to the target's class list (or
+* attribute) after each change, optionally with transitions suppressed.
+* Nothing touches the DOM during server rendering.
+*
+* @param options Modes, target, persistence, SSR fallback, and capabilities.
+* @default options {}
+* @returns Writable mode plus system and resolved state.
+*/
+function useColorMode(options = {}) {
+	const modes = {
+		light: "light",
+		dark: "dark",
+		...options.modes
+	};
+	const attribute = options.attribute ?? "class";
+	const storageKey = options.storageKey === void 0 ? "vize-color-mode" : options.storageKey;
+	const storage = options.storage === void 0 ? browserStorage() : options.storage;
+	const initial = options.initialValue ?? "auto";
+	const isMode = (value) => value === "auto" || value !== null && Object.hasOwn(modes, value);
+	const read = () => {
+		if (!storage || storageKey === null) return initial;
+		try {
+			const value = storage.getItem(storageKey);
+			return isMode(value) ? value : initial;
+		} catch {
+			return initial;
+		}
+	};
+	const deferRead = hasInjectionContext();
+	const storedValue = shallowRef(deferRead ? initial : read());
+	const selectedRaw = shallowRef(storedValue.value);
+	if (deferRead) onMounted(() => {
+		const value = read();
+		storedValue.value = value;
+		if (selectedRaw.value === initial) selectedRaw.value = value;
+	});
+	const selected = computed(() => isMode(selectedRaw.value) ? selectedRaw.value : initial);
+	const prefersDark = useMediaQuery("(prefers-color-scheme: dark)", options.host === void 0 ? { ssrValue: options.ssrSystem === "dark" } : {
+		ssrValue: options.ssrSystem === "dark",
+		host: options.host
+	});
+	const system = computed(() => prefersDark.value ? "dark" : "light");
+	const state = computed(() => selected.value === "auto" ? system.value : selected.value);
+	const target = () => options.target === void 0 ? typeof document !== "undefined" ? document.documentElement : null : resolveElement(options.target);
+	const stop = watch([state, target], ([resolved, element]) => {
+		if (!element) return;
+		const restore = options.disableTransition === false ? void 0 : suppressTransitions(element);
+		const value = modes[resolved] ?? resolved;
+		if (attribute === "class") {
+			for (const name of Object.values(modes)) for (const token of name.split(/\s+/)) if (token) element.classList.remove(token);
+			for (const token of value.split(/\s+/)) if (token) element.classList.add(token);
+		} else element.setAttribute(attribute, value);
+		restore?.();
+	}, {
+		immediate: true,
+		flush: "post"
+	});
+	tryOnScopeDispose(() => stop.stop());
+	return {
+		mode: computed({
+			get: () => selected.value,
+			set: (next) => {
+				selectedRaw.value = next;
+				if (!storage || storageKey === null) return;
+				try {
+					storage.setItem(storageKey, next);
+				} catch {}
+			}
+		}),
+		system,
+		state,
+		stored: computed(() => storedValue.value)
+	};
+}
+/**
+* Boolean dark-mode switch built on {@link useColorMode}.
+*
+* Setting the ref to the current system preference stores `"auto"`, so the
+* page keeps following the system until the user picks the opposite mode.
+*
+* @param options Dark/light values plus {@link useColorMode} options.
+* @default options {}
+* @returns Writable dark flag.
+*/
+function useDark(options = {}) {
+	const { valueDark = "dark", valueLight = "", ...rest } = options;
+	const colorMode = useColorMode({
+		...rest,
+		modes: {
+			dark: valueDark,
+			light: valueLight
+		}
+	});
+	return computed({
+		get: () => colorMode.state.value === "dark",
+		set: (dark) => {
+			const preferred = dark ? "dark" : "light";
+			colorMode.mode.value = preferred === colorMode.system.value ? "auto" : preferred;
+		}
+	});
+}
+function suppressTransitions(element) {
+	const document = element.ownerDocument;
+	const head = document?.head;
+	if (!head || typeof document.createElement !== "function") return void 0;
+	const style = document.createElement("style");
+	style.textContent = "*,*::before,*::after{transition:none!important}";
+	head.appendChild(style);
+	return () => {
+		document.defaultView?.getComputedStyle(style).opacity;
+		style.remove();
+	};
+}
+function browserStorage() {
+	if (typeof window === "undefined") return null;
+	try {
+		return window.localStorage;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { useColorMode, useDark };

package/dist/computed-async.d.mts

@@ -0,0 +1,63 @@
+import { Ref } from "vue";
+
+//#region src/computed-async.d.ts
+/** Registers a callback run when the current evaluation becomes stale. */
+type ComputedAsyncCancel = (onCancel: () => void) => void;
+/** Context handed to a {@link computedAsync} evaluator. */
+interface ComputedAsyncContext {
+  /** Aborted as soon as a newer evaluation starts or the scope stops. */
+  readonly signal: AbortSignal;
+  /** Register a callback for when this evaluation becomes stale. */
+  readonly onCancel: ComputedAsyncCancel;
+}
+/** Options for {@link computedAsync}. */
+interface ComputedAsyncOptions {
+  /**
+   * Defer the first evaluation until the value is read.
+   *
+   * @default false
+   */
+  readonly lazy?: boolean;
+  /**
+   * Ref that is `true` while an evaluation is in flight.
+   *
+   * @default an internal ref
+   */
+  readonly evaluating?: Ref<boolean>;
+  /**
+   * Receives evaluator failures; the previous value is kept.
+   *
+   * @default undefined (failures are dropped)
+   */
+  readonly onError?: (error: unknown) => void;
+}
+/**
+ * Computed value backed by an async evaluator.
+ *
+ * Reactive dependencies read synchronously in the evaluator (before its
+ * first `await`) are tracked; when one changes, the previous evaluation is
+ * cancelled (its `signal` aborts and `onCancel` callbacks run) and a new one
+ * starts. Only the newest evaluation may write the result, so out-of-order
+ * responses can never win. The value holds `initial` until the first
+ * evaluation settles, which also keeps server and client markup identical
+ * during hydration (the server never waits for the promise). Results are
+ * stored shallowly: replace the value instead of mutating it.
+ *
+ * @example
+ * ```ts
+ * const user = computedAsync(
+ *   async ({ signal }) => (await fetch(`/users/${id.value}`, { signal })).json(),
+ *   null,
+ * );
+ * ```
+ *
+ * @param evaluator Async (or sync) producer of the value.
+ * @param initial Value before the first evaluation settles.
+ * @param options Laziness, evaluating flag, and error hook.
+ * @default options {}
+ * @returns Readonly ref holding the newest settled value.
+ */
+declare function computedAsync<Value>(evaluator: (context: ComputedAsyncContext) => Value | Promise<Value>, initial: Value, options?: ComputedAsyncOptions): Readonly<Ref<Value>>;
+declare function computedAsync<Value>(evaluator: (context: ComputedAsyncContext) => Value | Promise<Value>, initial?: undefined, options?: ComputedAsyncOptions): Readonly<Ref<Value | undefined>>;
+//#endregion
+export { ComputedAsyncCancel, ComputedAsyncContext, ComputedAsyncOptions, computedAsync };

package/dist/computed-async.mjs

@@ -0,0 +1,43 @@
+import { computed, shallowRef, watchEffect } from "vue";
+//#region src/computed-async.ts
+function computedAsync(evaluator, initial, options = {}) {
+	const started = shallowRef(!(options.lazy ?? false));
+	const current = shallowRef(initial);
+	const evaluating = options.evaluating ?? shallowRef(false);
+	let generation = 0;
+	watchEffect(async (onCleanup) => {
+		if (!started.value) return;
+		generation += 1;
+		const own = generation;
+		const controller = new AbortController();
+		const cancelCallbacks = [];
+		let settled = false;
+		onCleanup(() => {
+			if (settled) return;
+			controller.abort();
+			for (const callback of cancelCallbacks) callback();
+		});
+		evaluating.value = true;
+		try {
+			const result = await evaluator({
+				signal: controller.signal,
+				onCancel: (callback) => {
+					cancelCallbacks.push(callback);
+				}
+			});
+			if (own === generation) current.value = result;
+		} catch (error) {
+			if (own === generation) options.onError?.(error);
+		} finally {
+			settled = true;
+			if (own === generation) evaluating.value = false;
+		}
+	});
+	if (options.lazy ?? false) return computed(() => {
+		started.value = true;
+		return current.value;
+	});
+	return current;
+}
+//#endregion
+export { computedAsync };

package/dist/computed-with-control.d.mts

@@ -0,0 +1,44 @@
+import { Ref, WatchSource } from "vue";
+
+//#region src/computed-with-control.d.ts
+/** Readonly cached value plus a manual invalidation trigger. */
+interface ComputedWithControl<Value> extends Readonly<Ref<Value>> {
+  /** Mark the cached value stale; the next read recomputes it. */
+  readonly trigger: () => void;
+}
+/** Explicit dependency accepted by {@link computedWithControl}: anything Vue's `watch` accepts. */
+type ComputedWithControlSource = WatchSource<unknown> | object | readonly (WatchSource<unknown> | object)[];
+/** Options for {@link computedWithControl}. */
+interface ComputedWithControlOptions {
+  /**
+   * Invalidate on nested changes of the explicit sources.
+   *
+   * @default false
+   */
+  readonly deep?: boolean;
+}
+/**
+ * Computed value whose dependencies are declared explicitly.
+ *
+ * Only changes of `source` (or a manual {@link ComputedWithControl.trigger})
+ * invalidate the cache; reactive reads inside `getter` do not. Useful when
+ * the getter reads non-reactive data or should ignore some reactive reads.
+ * The getter receives the previous value and runs lazily on the next read.
+ * Pure derived state: SSR-safe; the invalidation watcher follows the owning
+ * reactive scope.
+ *
+ * @example
+ * ```ts
+ * const snapshot = computedWithControl(version, () => expensiveRead(store));
+ * snapshot.trigger(); // force a refresh
+ * ```
+ *
+ * @param source Ref, getter, reactive object, or tuple of those.
+ * @param getter Produces the value from the previous one.
+ * @param options Depth of the source watch.
+ * @default options {}
+ * @returns The controlled computed ref.
+ */
+declare function computedWithControl<Value>(source: ComputedWithControlSource, getter: (previous: Value | undefined) => Value, options?: ComputedWithControlOptions): ComputedWithControl<Value>;
+//#endregion
+export { ComputedWithControl, ComputedWithControlOptions, ComputedWithControlSource, computedWithControl };

package/dist/computed-with-control.mjs

@@ -0,0 +1,54 @@
+import { customRef, watch } from "vue";
+//#region src/computed-with-control.ts
+/**
+* Computed value whose dependencies are declared explicitly.
+*
+* Only changes of `source` (or a manual {@link ComputedWithControl.trigger})
+* invalidate the cache; reactive reads inside `getter` do not. Useful when
+* the getter reads non-reactive data or should ignore some reactive reads.
+* The getter receives the previous value and runs lazily on the next read.
+* Pure derived state: SSR-safe; the invalidation watcher follows the owning
+* reactive scope.
+*
+* @example
+* ```ts
+* const snapshot = computedWithControl(version, () => expensiveRead(store));
+* snapshot.trigger(); // force a refresh
+* ```
+*
+* @param source Ref, getter, reactive object, or tuple of those.
+* @param getter Produces the value from the previous one.
+* @param options Depth of the source watch.
+* @default options {}
+* @returns The controlled computed ref.
+*/
+function computedWithControl(source, getter, options = {}) {
+	let dirty = true;
+	let cached;
+	let notify = () => void 0;
+	const invalidate = () => {
+		dirty = true;
+		notify();
+	};
+	watch(source, invalidate, {
+		flush: "sync",
+		deep: options.deep ?? false
+	});
+	const value = customRef((track, trigger) => {
+		notify = trigger;
+		return {
+			get: () => {
+				track();
+				if (dirty || cached === void 0) {
+					cached = { value: getter(cached?.value) };
+					dirty = false;
+				}
+				return cached.value;
+			},
+			set: () => void 0
+		};
+	});
+	return Object.assign(value, { trigger: invalidate });
+}
+//#endregion
+export { computedWithControl };

package/dist/create-event-hook.d.mts

@@ -0,0 +1,77 @@
+//#region src/create-event-hook.d.ts
+/** Listener registered on an {@link EventHook}. */
+type EventHookListener<Arguments extends readonly unknown[]> = (...args: Arguments) => unknown;
+/** Registration handle returned by {@link EventHook.on}. */
+interface EventHookSubscription {
+  /** Remove the listener. Idempotent. */
+  readonly off: () => void;
+}
+/** Options for {@link createEventHook}. */
+interface CreateEventHookOptions {
+  /**
+   * What `on()` does when a hook created outside any component (a
+   * module-level hook shared by every request) is subscribed to from a
+   * component `setup` during server rendering. Vue never disposes server
+   * component scopes, so such listeners would accumulate across requests
+   * and keep every rendered component alive.
+   *
+   * - `"ignore"`: skip the registration (the returned `off` is a no-op) and
+   *   warn once in development.
+   * - `"register"`: register anyway; the caller must call `off()`.
+   *
+   * Hooks created inside a component (request-local hooks) are unaffected.
+   *
+   * @default "ignore"
+   */
+  readonly serverListeners?: "ignore" | "register";
+}
+/** Typed event emitter created by {@link createEventHook}. */
+interface EventHook<Arguments extends readonly unknown[] = []> {
+  /**
+   * Add a listener. Inside an effect scope it is removed automatically when
+   * the scope stops. Adding the same function twice registers it once.
+   */
+  readonly on: (listener: EventHookListener<Arguments>) => EventHookSubscription;
+  /** Remove a listener. */
+  readonly off: (listener: EventHookListener<Arguments>) => void;
+  /**
+   * Call every listener with `args`, in registration order.
+   *
+   * @returns Settles with every listener's (awaited) result.
+   */
+  readonly trigger: (...args: Arguments) => Promise<unknown[]>;
+  /** Remove every listener. */
+  readonly clear: () => void;
+  /** Number of registered listeners. */
+  readonly size: () => number;
+}
+/**
+ * Create a small, strongly typed event emitter.
+ *
+ * The payload is a tuple type, so events can carry several named arguments
+ * (`createEventHook<[id: string, value: number]>()`) and `trigger` checks
+ * them. Listeners registered inside an effect scope unsubscribe themselves
+ * when it stops. Synchronous listener errors propagate from `trigger`;
+ * async rejections reject the returned promise.
+ *
+ * SSR: Vue does not dispose component scopes after a server render, so a
+ * listener that a server `setup` adds to a module-level hook would never be
+ * removed and would pile up once per request. By default such registrations
+ * are therefore skipped (with a one-time development warning); see
+ * {@link CreateEventHookOptions.serverListeners}. Hooks created inside a
+ * component, and every registration in the browser, behave normally.
+ *
+ * @example
+ * ```ts
+ * const saved = createEventHook<[id: string]>();
+ * saved.on((id) => toast(`Saved ${id}`));
+ * await saved.trigger("doc-1");
+ * ```
+ *
+ * @param options Server-side registration policy.
+ * @default options {}
+ * @returns The event hook.
+ */
+declare function createEventHook<Arguments extends readonly unknown[] = []>(options?: CreateEventHookOptions): EventHook<Arguments>;
+//#endregion
+export { CreateEventHookOptions, EventHook, EventHookListener, EventHookSubscription, createEventHook };

package/dist/create-event-hook.mjs

@@ -0,0 +1,66 @@
+import { tryOnScopeDispose } from "./scope.mjs";
+import { hasInjectionContext } from "vue";
+//#region src/create-event-hook.ts
+/**
+* Create a small, strongly typed event emitter.
+*
+* The payload is a tuple type, so events can carry several named arguments
+* (`createEventHook<[id: string, value: number]>()`) and `trigger` checks
+* them. Listeners registered inside an effect scope unsubscribe themselves
+* when it stops. Synchronous listener errors propagate from `trigger`;
+* async rejections reject the returned promise.
+*
+* SSR: Vue does not dispose component scopes after a server render, so a
+* listener that a server `setup` adds to a module-level hook would never be
+* removed and would pile up once per request. By default such registrations
+* are therefore skipped (with a one-time development warning); see
+* {@link CreateEventHookOptions.serverListeners}. Hooks created inside a
+* component, and every registration in the browser, behave normally.
+*
+* @example
+* ```ts
+* const saved = createEventHook<[id: string]>();
+* saved.on((id) => toast(`Saved ${id}`));
+* await saved.trigger("doc-1");
+* ```
+*
+* @param options Server-side registration policy.
+* @default options {}
+* @returns The event hook.
+*/
+function createEventHook(options = {}) {
+	const listeners = /* @__PURE__ */ new Set();
+	const shared = !hasInjectionContext();
+	let warned = false;
+	const off = (listener) => {
+		listeners.delete(listener);
+	};
+	const on = (listener) => {
+		if (shared && (options.serverListeners ?? "ignore") === "ignore" && typeof window === "undefined" && hasInjectionContext()) {
+			if (!warned && isDevelopment()) {
+				warned = true;
+				console.warn("[VIZE_COMPOSE_EVENT_HOOK_SERVER_LISTENER] a module-level event hook was subscribed to during server rendering; the listener was skipped because server component scopes are never disposed. Create the hook inside the component tree, or pass { serverListeners: \"register\" } and call off() yourself.");
+			}
+			return { off: () => void 0 };
+		}
+		listeners.add(listener);
+		const subscription = { off: () => off(listener) };
+		tryOnScopeDispose(subscription.off);
+		return subscription;
+	};
+	const trigger = (...args) => Promise.all([...listeners].map((listener) => listener(...args)));
+	return {
+		on,
+		off,
+		trigger,
+		clear: () => {
+			listeners.clear();
+		},
+		size: () => listeners.size
+	};
+}
+function isDevelopment() {
+	return typeof process === "undefined" || process.env["NODE_ENV"] !== "production";
+}
+//#endregion
+export { createEventHook };

package/dist/create-global-state.d.mts

@@ -0,0 +1,24 @@
+//#region src/create-global-state.d.ts
+/**
+ * Lift a state factory into application-wide state shared by every caller.
+ *
+ * The factory runs once, lazily on the first call, inside a detached effect
+ * scope so its watchers and computeds outlive any component; every later
+ * call returns the same state. Because the state is module-level, it is
+ * shared across all server requests: on the server, keep per-request state
+ * in `provide`/`createInjectionState` instead, or reset it per request.
+ *
+ * @example
+ * ```ts
+ * const useSession = createGlobalState(() => ({ user: shallowRef<User | null>(null) }));
+ * useSession().user.value = currentUser;
+ * ```
+ *
+ * @param factory Creates the state; may use any composable.
+ * @throws `Error` tagged `VIZE_COMPOSE_GLOBAL_STATE_INACTIVE_SCOPE` if the
+ * private scope cannot run (never expected in practice).
+ * @returns Accessor returning the shared state.
+ */
+declare function createGlobalState<State>(factory: () => State): () => State;
+//#endregion
+export { createGlobalState };