@vizejs/composable 0.426.3 → 0.427.0

package/dist/use-indexed-db.mjs

@@ -0,0 +1,251 @@
+import { tryOnScopeDispose } from "./scope.mjs";
+import { readonly, ref, shallowRef, toRaw, toValue, watch } from "vue";
+//#region src/use-indexed-db.ts
+function browserFactory() {
+	try {
+		return typeof window !== "undefined" ? window.indexedDB ?? void 0 : void 0;
+	} catch {
+		return;
+	}
+}
+function request(pending) {
+	return new Promise((resolve, reject) => {
+		pending.addEventListener("success", () => resolve(pending.result));
+		pending.addEventListener("error", () => reject(pending.error));
+	});
+}
+function committed(transaction) {
+	return new Promise((resolve, reject) => {
+		transaction.addEventListener("complete", () => resolve());
+		transaction.addEventListener("error", () => reject(transaction.error));
+		transaction.addEventListener("abort", () => reject(transaction.error));
+	});
+}
+function openDatabase(factory, name, store, version) {
+	const opening = factory.open(name, version);
+	opening.addEventListener("upgradeneeded", () => {
+		const database = opening.result;
+		if (!database.objectStoreNames.contains(store)) database.createObjectStore(store);
+	});
+	return request(opening).then((database) => {
+		if (database.objectStoreNames.contains(store)) return database;
+		const next = database.version + 1;
+		database.close();
+		return openDatabase(factory, name, store, next);
+	});
+}
+/**
+* Create a small promise-based key-value store on one IndexedDB object
+* store. The connection opens lazily on the first operation, the store is
+* created on demand, and writes resolve once their transaction commits.
+* Without IndexedDB (server rendering, privacy modes) every operation
+* rejects with a tagged `[VIZE_COMPOSE_INDEXED_DB_UNAVAILABLE]` error.
+*
+* @param options Database, store, and implementation.
+* @default options {}
+* @returns Key-value operations.
+*/
+function createIndexedDBKeyval(options = {}) {
+	const name = options.database ?? "vize-keyval";
+	const store = options.store ?? "keyval";
+	let connection;
+	const database = () => {
+		if (connection !== void 0) return connection;
+		const factory = options.factory === void 0 ? browserFactory() : options.factory;
+		if (!factory) return Promise.reject(/* @__PURE__ */ new Error("[VIZE_COMPOSE_INDEXED_DB_UNAVAILABLE] IndexedDB is not available"));
+		const opened = openDatabase(factory, name, store);
+		connection = opened;
+		opened.catch(() => {
+			if (connection === opened) connection = void 0;
+		});
+		return opened;
+	};
+	const read = async (operation) => {
+		return request(operation((await database()).transaction(store, "readonly").objectStore(store)));
+	};
+	const write = async (operation) => {
+		const transaction = (await database()).transaction(store, "readwrite");
+		const done = committed(transaction);
+		operation(transaction.objectStore(store));
+		await done;
+	};
+	return {
+		get: (key) => read((objects) => objects.get(key)),
+		set: (key, value) => write((objects) => objects.put(value, key)),
+		delete: (key) => write((objects) => objects.delete(key)),
+		keys: () => read((objects) => objects.getAllKeys()),
+		clear: () => write((objects) => objects.clear()),
+		close: () => {
+			const current = connection;
+			connection = void 0;
+			current?.then((db) => db.close(), () => void 0);
+		}
+	};
+}
+function sameKind(defaults, candidate) {
+	if (defaults === null || defaults === void 0) return true;
+	if (defaults instanceof Map) return candidate instanceof Map;
+	if (defaults instanceof Set) return candidate instanceof Set;
+	if (defaults instanceof Date) return candidate instanceof Date;
+	if (Array.isArray(defaults)) return Array.isArray(candidate);
+	if (typeof defaults === "object") return typeof candidate === "object" && candidate !== null && !Array.isArray(candidate);
+	return typeof candidate === typeof defaults;
+}
+/**
+* Synchronize a reactive value with one IndexedDB key.
+*
+* Values are stored by structured clone, so objects, arrays, `Map`, `Set`,
+* `Date`, typed arrays, and `Blob`s round-trip without a serializer. The
+* value is loaded asynchronously: `state` holds the default until `ready`
+* becomes `true`. Loaded values pass `validate` before they are accepted.
+* Assignments and nested mutations are written back; changing the reactive
+* `key` loads the new key (stale loads are discarded).
+*
+* Server rendering: without a browser `window` nothing is opened, `state`
+* is the default, and `ready` stays `false`, so server and client first
+* render identically. The connection closes and watchers stop with the
+* owning reactive scope. Failures never reject; they are exposed through
+* `error` and `onError`.
+*
+* @example
+* ```ts
+* const { state: draft, ready } = useIndexedDB("draft", { title: "", body: "" });
+* ```
+*
+* @typeParam Value Stored value type, inferred from `defaultValue`.
+* @param key Reactive IndexedDB key.
+* @param defaultValue Value used until loaded, and when absent or invalid.
+* @param options Database, store, implementation, and validation.
+* @default options {}
+* @returns The synchronized value and its controls.
+*/
+function useIndexedDB(key, defaultValue, options = {}) {
+	const state = ref(defaultValue);
+	const supported = ref(false);
+	const ready = ref(false);
+	const error = shallowRef(void 0);
+	const validate = options.validate ?? ((candidate) => sameKind(defaultValue, candidate));
+	let keyval;
+	let generation = 0;
+	let applying = false;
+	let dirty = false;
+	const fail = (code, cause) => {
+		const failure = {
+			code,
+			key: toValue(key),
+			cause
+		};
+		error.value = failure;
+		options.onError?.(failure);
+	};
+	const assign = (value) => {
+		applying = true;
+		try {
+			state.value = value;
+		} finally {
+			applying = false;
+		}
+	};
+	const persist = async (value) => {
+		if (keyval === void 0) return;
+		try {
+			await keyval.set(toValue(key), toRaw(value));
+			error.value = void 0;
+		} catch (cause) {
+			fail("write-failed", cause);
+		}
+	};
+	const refresh = async () => {
+		const current = ++generation;
+		if (keyval === void 0) return;
+		const store = keyval;
+		let stored;
+		try {
+			stored = await store.get(toValue(key));
+		} catch (cause) {
+			if (current === generation) fail("read-failed", cause);
+			return;
+		}
+		if (current !== generation) return;
+		if (stored === void 0) {
+			assign(defaultValue);
+			ready.value = true;
+			if (options.writeDefaults ?? true) await persist(defaultValue);
+			return;
+		}
+		if (!validate(stored)) {
+			fail("invalid-value", stored);
+			assign(defaultValue);
+		} else {
+			error.value = void 0;
+			assign(stored);
+		}
+		ready.value = true;
+	};
+	const remove = async () => {
+		generation += 1;
+		assign(defaultValue);
+		if (keyval === void 0) return;
+		try {
+			await keyval.delete(toValue(key));
+			error.value = void 0;
+		} catch (cause) {
+			fail("write-failed", cause);
+		}
+	};
+	let currentFactory;
+	const stopSource = watch([() => (options.factory === void 0 ? browserFactory() : toValue(options.factory)) ?? void 0, () => toValue(key)], ([factory]) => {
+		ready.value = false;
+		supported.value = factory !== void 0;
+		if (factory !== currentFactory) {
+			keyval?.close();
+			currentFactory = factory;
+			keyval = factory === void 0 ? void 0 : createIndexedDBKeyval({
+				factory,
+				...options.database === void 0 ? {} : { database: options.database },
+				...options.store === void 0 ? {} : { store: options.store }
+			});
+		}
+		if (keyval === void 0) {
+			generation += 1;
+			assign(defaultValue);
+			return;
+		}
+		refresh();
+	}, {
+		immediate: true,
+		flush: "sync"
+	});
+	const stopDirty = watch(state, () => {
+		if (!applying) dirty = true;
+	}, {
+		deep: options.deep ?? true,
+		flush: "sync"
+	});
+	const stopWrite = watch(state, (value) => {
+		if (!dirty) return;
+		dirty = false;
+		persist(value);
+	}, {
+		deep: options.deep ?? true,
+		flush: options.flush ?? "pre"
+	});
+	tryOnScopeDispose(() => {
+		generation += 1;
+		stopSource();
+		stopDirty();
+		stopWrite();
+		keyval?.close();
+		keyval = void 0;
+	});
+	return {
+		state,
+		supported: readonly(supported),
+		ready: readonly(ready),
+		error,
+		refresh,
+		remove
+	};
+}
+//#endregion
+export { createIndexedDBKeyval, useIndexedDB };

package/dist/use-interval-BA55gTHT.d.mts

@@ -0,0 +1,140 @@
+import { MaybeRefOrGetter, ShallowRef } from "vue";
+
+//#region src/use-interval.d.ts
+/**
+ * Repeating timer host used by {@link useIntervalFn} and the clocks built
+ * on it.
+ *
+ * Implement this interface to integrate a deterministic test clock, a native
+ * runtime timer, or an application-owned scheduler. Handles are opaque: they
+ * are only handed back to {@link IntervalScheduler.clearInterval}.
+ */
+interface IntervalScheduler {
+  /** Starts a repeating callback and returns its opaque cancellation handle. */
+  readonly setInterval: (callback: () => void, intervalMs: number) => unknown;
+  /** Cancels a handle previously returned by {@link IntervalScheduler.setInterval}. */
+  readonly clearInterval: (handle: unknown) => void;
+}
+/** Pause/resume controls shared by the repeating timing composables. */
+interface PausableControls {
+  /**
+   * Whether the timer is logically running.
+   *
+   * On the server (without `runOnServer`) this reflects the requested state
+   * without starting a host timer, so server and client render the same
+   * initial value.
+   */
+  readonly isActive: Readonly<ShallowRef<boolean>>;
+  /** Stop ticking. Idempotent. */
+  readonly pause: () => void;
+  /** Start (or keep) ticking. Idempotent. */
+  readonly resume: () => void;
+}
+/** Options for {@link useIntervalFn}. */
+interface UseIntervalFnOptions {
+  /**
+   * Start ticking as soon as the composable is created.
+   *
+   * @default true
+   */
+  readonly immediate?: boolean;
+  /**
+   * Invoke the callback synchronously whenever the timer (re)starts, in
+   * addition to every tick.
+   *
+   * @default false
+   */
+  readonly immediateCallback?: boolean;
+  /**
+   * Starts host timers when no browser `window` is available.
+   *
+   * Keep this disabled during server rendering: the controls then track the
+   * requested state but never schedule work. Enable it for native, desktop,
+   * worker, and test runtimes whose scheduler is lifecycle-bound.
+   *
+   * @default false
+   */
+  readonly runOnServer?: boolean;
+  /**
+   * Owns the repeating timer.
+   *
+   * @default globalThis timer functions
+   */
+  readonly scheduler?: IntervalScheduler;
+}
+/** Options for {@link useInterval}. */
+interface UseIntervalOptions<Controls extends boolean = false> extends UseIntervalFnOptions {
+  /**
+   * Return the full control object instead of the bare counter ref.
+   *
+   * @default false
+   */
+  readonly controls?: Controls;
+  /**
+   * Invoked after every increment with the new count.
+   *
+   * @default undefined
+   */
+  readonly callback?: (count: number) => void;
+}
+/** Counter and controls returned by `useInterval(ms, { controls: true })`. */
+interface IntervalControls extends PausableControls {
+  /** Number of ticks since creation or the last {@link IntervalControls.reset}. */
+  readonly counter: Readonly<ShallowRef<number>>;
+  /** Reset the counter to zero without touching the timer. */
+  readonly reset: () => void;
+}
+/**
+ * Call a function on a fixed, pausable interval.
+ *
+ * `intervalMs` is reactive: while active, a change replaces the running timer
+ * with one using the new period. The timer is cleared when the owning
+ * reactive scope stops; call inside an active scope, or call `pause()`
+ * yourself.
+ *
+ * Server rendering is hydration-stable: without a browser `window` (and
+ * with {@link UseIntervalFnOptions.runOnServer} disabled) `isActive` reports
+ * the requested state but no host timer is created, so nothing leaks and
+ * the server snapshot matches the client's initial render.
+ *
+ * @example
+ * ```ts
+ * const { pause, resume, isActive } = useIntervalFn(() => poll(), 5_000);
+ * ```
+ *
+ * @param callback Invoked on every tick.
+ * @param intervalMs Reactive period in milliseconds; must be finite and
+ * greater than zero. Fractions are truncated.
+ * @param options Start, server, and scheduler policy.
+ * @default options {}
+ * @throws `RangeError` tagged `VIZE_COMPOSE_INTERVAL_INVALID_DELAY` when the
+ * resolved period is invalid, synchronously at creation and whenever a timer
+ * would start.
+ * @returns Pause/resume controls.
+ */
+declare function useIntervalFn(callback: () => void, intervalMs: MaybeRefOrGetter<number>, options?: UseIntervalFnOptions): PausableControls;
+/**
+ * Count interval ticks reactively.
+ *
+ * A thin wrapper over {@link useIntervalFn} whose state is a counter. Pass
+ * `{ controls: true }` to receive pause/resume/reset alongside the counter;
+ * the return type follows the literal flag.
+ *
+ * @example
+ * ```ts
+ * const ticks = useInterval(1_000); // Readonly<ShallowRef<number>>
+ * const { counter, pause, reset } = useInterval(1_000, { controls: true });
+ * ```
+ *
+ * @param intervalMs Reactive period in milliseconds.
+ * @param options Interval options plus the `controls` flag.
+ * @default intervalMs 1000
+ * @default options {}
+ * @throws `RangeError` tagged `VIZE_COMPOSE_INTERVAL_INVALID_DELAY` for
+ * invalid periods (see {@link useIntervalFn}).
+ * @returns The counter ref, or the full controls when `controls` is `true`.
+ */
+declare function useInterval(intervalMs?: MaybeRefOrGetter<number>, options?: UseIntervalOptions<false>): Readonly<ShallowRef<number>>;
+declare function useInterval(intervalMs: MaybeRefOrGetter<number>, options: UseIntervalOptions<true>): IntervalControls;
+//#endregion
+export { UseIntervalOptions as a, UseIntervalFnOptions as i, IntervalScheduler as n, useInterval as o, PausableControls as r, useIntervalFn as s, IntervalControls as t };

package/dist/use-interval.d.mts

@@ -0,0 +1,2 @@
+import { a as UseIntervalOptions, i as UseIntervalFnOptions, n as IntervalScheduler, o as useInterval, r as PausableControls, s as useIntervalFn, t as IntervalControls } from "./use-interval-BA55gTHT.mjs";
+export { IntervalControls, IntervalScheduler, PausableControls, UseIntervalFnOptions, UseIntervalOptions, useInterval, useIntervalFn };

package/dist/use-interval.mjs

@@ -0,0 +1,100 @@
+import { tryOnScopeDispose } from "./scope.mjs";
+import { shallowRef, toValue, watch } from "vue";
+//#region src/use-interval.ts
+const defaultScheduler = {
+	setInterval: (callback, intervalMs) => globalThis.setInterval(callback, intervalMs),
+	clearInterval: (handle) => {
+		globalThis.clearInterval(handle);
+	}
+};
+function resolveIntervalMs(value) {
+	if (!Number.isFinite(value) || value <= 0) throw new RangeError(`[VIZE_COMPOSE_INTERVAL_INVALID_DELAY] intervalMs must be finite and greater than zero; received ${String(value)}`);
+	return Math.max(1, Math.trunc(value));
+}
+/**
+* Call a function on a fixed, pausable interval.
+*
+* `intervalMs` is reactive: while active, a change replaces the running timer
+* with one using the new period. The timer is cleared when the owning
+* reactive scope stops; call inside an active scope, or call `pause()`
+* yourself.
+*
+* Server rendering is hydration-stable: without a browser `window` (and
+* with {@link UseIntervalFnOptions.runOnServer} disabled) `isActive` reports
+* the requested state but no host timer is created, so nothing leaks and
+* the server snapshot matches the client's initial render.
+*
+* @example
+* ```ts
+* const { pause, resume, isActive } = useIntervalFn(() => poll(), 5_000);
+* ```
+*
+* @param callback Invoked on every tick.
+* @param intervalMs Reactive period in milliseconds; must be finite and
+* greater than zero. Fractions are truncated.
+* @param options Start, server, and scheduler policy.
+* @default options {}
+* @throws `RangeError` tagged `VIZE_COMPOSE_INTERVAL_INVALID_DELAY` when the
+* resolved period is invalid, synchronously at creation and whenever a timer
+* would start.
+* @returns Pause/resume controls.
+*/
+function useIntervalFn(callback, intervalMs, options = {}) {
+	const scheduler = options.scheduler ?? defaultScheduler;
+	const isActive = shallowRef(false);
+	let handle;
+	let running = false;
+	resolveIntervalMs(toValue(intervalMs));
+	const canSchedule = () => typeof window !== "undefined" || (options.runOnServer ?? false);
+	const clear = () => {
+		if (!running) return;
+		running = false;
+		scheduler.clearInterval(handle);
+		handle = void 0;
+	};
+	const start = () => {
+		const period = resolveIntervalMs(toValue(intervalMs));
+		clear();
+		if (!canSchedule()) return;
+		if (options.immediateCallback ?? false) callback();
+		if (!isActive.value) return;
+		running = true;
+		handle = scheduler.setInterval(callback, period);
+	};
+	const pause = () => {
+		isActive.value = false;
+		clear();
+	};
+	const resume = () => {
+		if (isActive.value) return;
+		isActive.value = true;
+		start();
+	};
+	watch(() => toValue(intervalMs), () => {
+		if (isActive.value) start();
+	});
+	if (options.immediate ?? true) resume();
+	tryOnScopeDispose(pause);
+	return {
+		isActive,
+		pause,
+		resume
+	};
+}
+function useInterval(intervalMs = 1e3, options = {}) {
+	const counter = shallowRef(0);
+	const controls = useIntervalFn(() => {
+		counter.value += 1;
+		options.callback?.(counter.value);
+	}, intervalMs, options);
+	if (options.controls !== true) return counter;
+	return {
+		...controls,
+		counter,
+		reset: () => {
+			counter.value = 0;
+		}
+	};
+}
+//#endregion
+export { useInterval, useIntervalFn };

package/dist/use-list-format.d.mts

@@ -0,0 +1,60 @@
+import { ComputedRef, MaybeRefOrGetter } from "vue";
+
+//#region src/use-list-format.d.ts
+/** Options for {@link useListFormat}. */
+interface UseListFormatOptions extends Intl.ListFormatOptions {
+  /**
+   * Locale used for formatting. Pass it explicitly for hydration-stable
+   * server rendering.
+   *
+   * @default the browser language, otherwise "en"
+   */
+  readonly locale?: string | Intl.Locale;
+}
+/** Reactive list formatting returned by {@link useListFormat}. */
+interface ListFormatControls {
+  /** Canonical locale in use. */
+  readonly locale: ComputedRef<string>;
+  /** Cached formatter for the current locale and options. */
+  readonly formatter: ComputedRef<Intl.ListFormat>;
+  /** Formatted list, for example `"apples, pears, and plums"`. */
+  readonly formatted: ComputedRef<string>;
+  /**
+   * Format any list with the current formatter.
+   *
+   * @param items Items to join.
+   * @returns The formatted list.
+   */
+  readonly format: (items: Iterable<string>) => string;
+  /**
+   * Format any list into element and literal parts (for rich rendering).
+   *
+   * @param items Items to join.
+   * @returns The formatted parts.
+   */
+  readonly formatToParts: (items: Iterable<string>) => {
+    type: "element" | "literal";
+    value: string;
+  }[];
+}
+/**
+ * Join strings into a locale-aware list with `Intl.ListFormat`
+ * (`"a, b, and c"`, `"a、b、c"`, `"a, b or c"`).
+ *
+ * Follows reactive items and options; formatters are cached per locale and
+ * option set through {@link useLocale}. Invalid options surface as the
+ * platform's `RangeError`. No listeners or timers are created.
+ *
+ * @example
+ * ```ts
+ * const { formatted } = useListFormat(names, { locale: "en", type: "disjunction" });
+ * ```
+ *
+ * @param items Reactive list of strings.
+ * @param options Reactive locale and `Intl.ListFormat` options.
+ * @default options {}
+ * @returns Reactive formatted output and formatting helpers.
+ */
+declare function useListFormat(items: MaybeRefOrGetter<readonly string[]>, options?: MaybeRefOrGetter<UseListFormatOptions>): ListFormatControls;
+//#endregion
+export { ListFormatControls, UseListFormatOptions, useListFormat };

package/dist/use-list-format.mjs

@@ -0,0 +1,40 @@
+import { useLocale } from "./locale.mjs";
+import { computed, toValue } from "vue";
+//#region src/use-list-format.ts
+function browserLanguage() {
+	return typeof window === "undefined" ? void 0 : window.navigator.language;
+}
+/**
+* Join strings into a locale-aware list with `Intl.ListFormat`
+* (`"a, b, and c"`, `"a、b、c"`, `"a, b or c"`).
+*
+* Follows reactive items and options; formatters are cached per locale and
+* option set through {@link useLocale}. Invalid options surface as the
+* platform's `RangeError`. No listeners or timers are created.
+*
+* @example
+* ```ts
+* const { formatted } = useListFormat(names, { locale: "en", type: "disjunction" });
+* ```
+*
+* @param items Reactive list of strings.
+* @param options Reactive locale and `Intl.ListFormat` options.
+* @default options {}
+* @returns Reactive formatted output and formatting helpers.
+*/
+function useListFormat(items, options = {}) {
+	const localeControls = useLocale(() => toValue(options).locale, { detect: browserLanguage });
+	const formatter = computed(() => {
+		const { locale: _locale, ...formatOptions } = toValue(options);
+		return localeControls.list(formatOptions);
+	});
+	return {
+		locale: localeControls.locale,
+		formatter,
+		formatted: computed(() => formatter.value.format(toValue(items))),
+		format: (list) => formatter.value.format(list),
+		formatToParts: (list) => formatter.value.formatToParts(list)
+	};
+}
+//#endregion
+export { useListFormat };

package/dist/use-machine.d.mts

@@ -0,0 +1,90 @@
+import { ComputedRef, ShallowRef } from "vue";
+
+//#region src/use-machine.d.ts
+/** Guarded, effectful transition to `target`. */
+interface MachineTransition<State extends string, Context> {
+  /** State entered when the transition is taken. */
+  readonly target: State;
+  /** Take the transition only when this returns `true`. */
+  readonly guard?: (context: Context) => boolean;
+  /** Produce the next context while transitioning. */
+  readonly action?: (context: Context) => Context;
+}
+/** One state of a {@link MachineConfig}. */
+interface MachineStateNode<State extends string, Event extends string, Context> {
+  /**
+   * Transitions keyed by event: a target state name, one transition object,
+   * or a list of guarded transitions where the first passing guard wins.
+   */
+  readonly on?: { readonly [Name in Event]?: State | MachineTransition<State, Context> | readonly MachineTransition<State, Context>[] };
+  /** Called with the context after the machine enters this state. */
+  readonly entry?: (context: Context) => void;
+  /** Called with the context before the machine leaves this state. */
+  readonly exit?: (context: Context) => void;
+}
+/** Definition consumed by {@link useMachine}. */
+interface MachineConfig<State extends string, Event extends string, Context> {
+  /** State the machine starts (and resets) in. */
+  readonly initial: NoInfer<State>;
+  /** Initial extended state. */
+  readonly context: Context;
+  /** Every state, keyed by name. */
+  readonly states: { readonly [Name in State]: MachineStateNode<NoInfer<State>, Event, Context> };
+}
+/** Reactive machine returned by {@link useMachine}. */
+interface Machine<State extends string, Event extends string, Context> {
+  /** Current state name. */
+  readonly state: Readonly<ShallowRef<State>>;
+  /** Current extended state. */
+  readonly context: Readonly<ShallowRef<Context>>;
+  /** Events that would cause a transition from the current state right now. */
+  readonly nextEvents: ComputedRef<Event[]>;
+  /**
+   * Deliver an event.
+   *
+   * @returns Whether a transition was taken.
+   */
+  readonly send: (event: Event) => boolean;
+  /** Whether `event` would cause a transition right now (guards included). */
+  readonly can: (event: Event) => boolean;
+  /** Whether the current state is one of `states`. */
+  readonly matches: (...states: readonly State[]) => boolean;
+  /** Return to the initial state and context without running hooks. */
+  readonly reset: () => void;
+}
+/**
+ * Finite state machine with typed states, events, and targets.
+ *
+ * State names are inferred from the keys of `states`, event names from the
+ * keys of every `on` map, and every `target` (and `initial`) must name a
+ * declared state, so typos fail to compile. Transitions may carry guards
+ * (first passing guard wins) and actions that return the next context;
+ * `exit` runs on the old state before `entry` runs on the new one, and a
+ * self-transition runs both. Synchronous and free of globals: identical on
+ * server and client, nothing to dispose.
+ *
+ * @example
+ * ```ts
+ * const fetcher = useMachine({
+ *   initial: "idle",
+ *   context: { retries: 0 },
+ *   states: {
+ *     idle: { on: { FETCH: "loading" } },
+ *     loading: { on: { RESOLVE: "success", REJECT: "failure" } },
+ *     failure: {
+ *       on: {
+ *         RETRY: { target: "loading", guard: (c) => c.retries < 3, action: (c) => ({ retries: c.retries + 1 }) },
+ *       },
+ *     },
+ *     success: {},
+ *   },
+ * });
+ * fetcher.send("FETCH");
+ * ```
+ *
+ * @param config States, events, context, and hooks.
+ * @returns The reactive machine.
+ */
+declare function useMachine<State extends string, Event extends string = never, Context = undefined>(config: MachineConfig<State, Event, Context>): Machine<State, Event, Context>;
+//#endregion
+export { Machine, MachineConfig, MachineStateNode, MachineTransition, useMachine };