usewagen 0.1.0 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # usewagen
 
-Reactive state for URL and storage in Vue. Type-safe, with the value in exactly one place.
+Reactive state for URL and storage in Vue. Type-safe, with the source always in charge.
 
 Documentation lives at [usewagen.dev](https://usewagen.dev).
 

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { C as parseAsStringLiteral, S as parseAsStringEnum, T as unwrapDefault, _ as parseAsIndex, a as InferParserValue, b as parseAsNumberLiteral, c as DefaultValue, d as ParserWithDefault, f as defineParser, g as parseAsFloat, h as parseAsDate, i as InferInputWritable, l as Parser, m as parseAsBoolean, n as CustomParsers, o as KnownParsers, p as parseAsArrayOf, r as InferInputValue, s as ParserInput, t as BuiltinParsers, u as ParserOptions, v as parseAsInteger, w as tryParse, x as parseAsString, y as parseAsJson } from "./types-CNt2lcP1.mjs";
-import { i as RouteStateSource, t as HistoryMode } from "./types-CuwASQTi.mjs";
+import { C as parseAsString, D as unwrapDefault, E as tryParse, M as StateMode, O as Missing, S as parseAsNumberLiteral, T as parseAsStringLiteral, _ as parseAsDate, a as InferParserValue, b as parseAsInteger, c as UnwrapOption, d as Parser, f as ParserOptions, g as parseAsBoolean, h as parseAsArrayOf, i as InferInputWritable, j as Register, l as WithParser, m as defineParser, n as CustomParsers, o as KnownParsers, p as ParserWithDefault, r as InferInputValue, s as ParserInput, t as BuiltinParsers, u as DefaultValue, v as parseAsFloat, w as parseAsStringEnum, x as parseAsJson, y as parseAsIndex } from "./types-DFspmU7A.mjs";
+import { i as RouteStateSource, t as HistoryMode } from "./types-Bv0pKeGI.mjs";
 import { a as StorageInstance, t as ErrorHandler } from "./create-storage-DESmB4bY.mjs";
 import { App } from "vue";
 //#region src/wagen.d.ts
@@ -10,34 +10,43 @@ interface WagenStorageOptions {
   local?: StorageInstance;
   session?: StorageInstance;
   default?: 'local' | 'session';
+  mode?: StateMode;
 }
 interface WagenRouterOptions {
   history?: HistoryMode;
   source?: RouteStateSource;
   clearOnDefault?: boolean;
+  mode?: StateMode;
 }
 type WagenParsers = Record<string, Parser<any>>;
-interface WagenConfig {
+type MissingConfig = 'missing' extends keyof Register ? {
+  missing: Missing;
+} : {
+  missing?: Missing;
+};
+type WagenConfig = {
   parsers?: WagenParsers;
   storage?: WagenStorageOptions;
   router?: WagenRouterOptions;
-}
+} & MissingConfig;
 interface WagenStorage {
   readonly local: StorageInstance;
   readonly session: StorageInstance;
   readonly default: StorageInstance;
+  readonly mode: StateMode;
 }
 type ResolvedWagenRouterOptions = Required<WagenRouterOptions>;
 interface Wagen {
   readonly parsers: WagenParsers;
+  readonly missing: Missing;
   readonly storage: WagenStorage;
   readonly router: ResolvedWagenRouterOptions;
   install: (app: App) => void;
   destroy: () => void;
 }
-declare function defineWagenConfig(config: WagenConfig): WagenConfig;
-declare function createWagen(config?: WagenConfig): Wagen;
-declare function getActiveWagen(): Wagen;
-declare function useWagen(): Wagen;
+export declare function defineWagenConfig(config: WagenConfig): WagenConfig;
+export declare function createWagen(config?: WagenConfig): Wagen;
+export declare function getActiveWagen(): Wagen;
+export declare function useWagen(): Wagen;
 //#endregion
-export { type BuiltinParsers, type CustomParsers, DefaultValue, type InferInputValue, type InferInputWritable, type InferParserValue, type KnownParsers, Parser, type ParserInput, ParserOptions, ParserWithDefault, type ResolvedWagenRouterOptions, type Wagen, type WagenConfig, type WagenParsers, type WagenRouterOptions, type WagenStorage, type WagenStorageOptions, createWagen, defineParser, defineWagenConfig, getActiveWagen, parseAsArrayOf, parseAsBoolean, parseAsDate, parseAsFloat, parseAsIndex, parseAsInteger, parseAsJson, parseAsNumberLiteral, parseAsString, parseAsStringEnum, parseAsStringLiteral, tryParse, unwrapDefault, useWagen };
+export { type BuiltinParsers, type CustomParsers, DefaultValue, type InferInputValue, type InferInputWritable, type InferParserValue, type KnownParsers, type Missing, Parser, type ParserInput, ParserOptions, ParserWithDefault, type Register, type ResolvedWagenRouterOptions, type StateMode, type UnwrapOption, type Wagen, type WagenConfig, type WagenParsers, type WagenRouterOptions, type WagenStorage, type WagenStorageOptions, type WithParser, defineParser, parseAsArrayOf, parseAsBoolean, parseAsDate, parseAsFloat, parseAsIndex, parseAsInteger, parseAsJson, parseAsNumberLiteral, parseAsString, parseAsStringEnum, parseAsStringLiteral, tryParse, unwrapDefault };

package/dist/index.mjs

@@ -1,4 +1,4 @@
 import { a as parseAsFloat, c as parseAsJson, d as parseAsStringEnum, f as parseAsStringLiteral, i as parseAsDate, l as parseAsNumberLiteral, m as unwrapDefault, n as parseAsArrayOf, o as parseAsIndex, p as tryParse, r as parseAsBoolean, s as parseAsInteger, t as defineParser, u as parseAsString } from "./parsers-CA8aZuF-.mjs";
 import "./parser-B6hfbAwA.mjs";
-import { i as useWagen, n as defineWagenConfig, r as getActiveWagen, t as createWagen } from "./wagen-C9_CPUdF.mjs";
+import { i as useWagen, n as defineWagenConfig, r as getActiveWagen, t as createWagen } from "./wagen-FM0F79xP.mjs";
 export { createWagen, defineParser, defineWagenConfig, getActiveWagen, parseAsArrayOf, parseAsBoolean, parseAsDate, parseAsFloat, parseAsIndex, parseAsInteger, parseAsJson, parseAsNumberLiteral, parseAsString, parseAsStringEnum, parseAsStringLiteral, tryParse, unwrapDefault, useWagen };

package/dist/router/index.d.mts

@@ -1,40 +1,44 @@
-import { i as InferInputWritable, r as InferInputValue, s as ParserInput } from "../types-CNt2lcP1.mjs";
-import { i as RouteStateSource, n as ResolvedRouteStateOptions, r as RouteStateOptions, t as HistoryMode } from "../types-CuwASQTi.mjs";
-import { n as ReactiveOptions, t as ReactiveFields } from "../options-BKybciek.mjs";
+import { A as ReactiveOptions, M as StateMode, O as Missing, c as UnwrapOption, i as InferInputWritable, k as ReactiveFields, l as WithParser, r as InferInputValue, s as ParserInput } from "../types-DFspmU7A.mjs";
+import { i as RouteStateSource, n as ResolvedRouteStateOptions, r as RouteStateOptions, t as HistoryMode } from "../types-Bv0pKeGI.mjs";
 import { Ref } from "vue";
 //#region src/router/use-route-hash.d.ts
 interface RouteHashOptions {
   parser?: ParserInput;
+  missing?: unknown;
   history?: HistoryMode;
   clearOnDefault?: boolean;
+  mode?: StateMode;
 }
-type UseRouteHashOptions<P extends ParserInput | undefined = ParserInput | undefined> = ReactiveOptions<Omit<RouteHashOptions, 'parser'> & {
-  parser?: P;
-}, 'parser'>;
-declare function useRouteHash<P extends ParserInput | undefined = undefined>(options?: UseRouteHashOptions<P>): Ref<InferInputValue<P>, InferInputWritable<P>>;
-//#endregion
-//#region src/router/use-route-state.d.ts
-type UseRouteStateOptions<P extends ParserInput | undefined = ParserInput | undefined> = ReactiveOptions<Omit<RouteStateOptions, 'parser'> & {
-  parser?: P;
-}, 'parser'>;
-declare function useRouteState<P extends ParserInput | undefined = undefined>(options: UseRouteStateOptions<P>): Ref<InferInputValue<P>, InferInputWritable<P>>;
+type UseRouteHashOptions<P extends ParserInput | undefined = ParserInput | undefined, M = unknown> = ReactiveOptions<WithParser<RouteHashOptions, P, M>, 'missing'>;
+type RouteHashConfig = ReactiveFields<RouteHashOptions, 'missing'>;
+export declare function useRouteHash<P extends ParserInput | undefined = undefined, const M = Missing>(options?: UseRouteHashOptions<P, M>): Ref<InferInputValue<P, UnwrapOption<M>>, InferInputWritable<P, UnwrapOption<M>>>;
 //#endregion
 //#region src/router/use-route-states.d.ts
-type RouteStateConfig<P extends ParserInput | undefined = ParserInput | undefined> = ReactiveFields<Omit<RouteStateOptions, 'parser'> & {
-  parser?: P;
-}, 'key' | 'parser'>;
+type RouteStateConfig<P extends ParserInput | undefined = ParserInput | undefined, M = unknown> = ReactiveFields<WithParser<RouteStateOptions, P, M>, 'key' | 'missing'>;
 interface BatchOptions {
   history?: HistoryMode;
 }
-type Refs<TOptions extends readonly RouteStateConfig[]> = { [TOption in TOptions[number] as TOption['key']]: Ref<InferInputValue<TOption['parser']>, InferInputWritable<TOption['parser']>>; };
-type StatePatch<TOptions extends readonly RouteStateConfig[]> = Partial<{ [TOption in TOptions[number] as TOption['key']]: InferInputWritable<TOption['parser']>; }>;
-type StateSnapshot<TOptions extends readonly RouteStateConfig[]> = { [TOption in TOptions[number] as TOption['key']]: InferInputValue<TOption['parser']>; };
+type ConfigMissing<TConfig> = 'missing' extends keyof TConfig ? UnwrapOption<TConfig['missing']> : Missing;
+type Refs<TOptions extends readonly RouteStateConfig[]> = { [TOption in TOptions[number] as TOption['key']]: Ref<InferInputValue<TOption['parser'], ConfigMissing<TOption>>, InferInputWritable<TOption['parser'], ConfigMissing<TOption>>>; };
+type StatePatch<TOptions extends readonly RouteStateConfig[]> = Partial<{ [TOption in TOptions[number] as TOption['key']]: InferInputWritable<TOption['parser'], ConfigMissing<TOption>>; }>;
+type StateSnapshot<TOptions extends readonly RouteStateConfig[]> = { [TOption in TOptions[number] as TOption['key']]: InferInputValue<TOption['parser'], ConfigMissing<TOption>>; };
 interface UseRouteStatesApi<TOptions extends readonly RouteStateConfig[]> {
   set: (patch: StatePatch<TOptions>, options?: BatchOptions) => void;
   reset: (options?: BatchOptions) => void;
   toObject: () => StateSnapshot<TOptions>;
 }
 type UseRouteStatesReturn<TOptions extends readonly RouteStateConfig[]> = Refs<TOptions> & UseRouteStatesApi<TOptions>;
-declare function useRouteStates<const TOptions extends readonly RouteStateConfig[]>(configs: TOptions): UseRouteStatesReturn<TOptions>;
+export declare function useRouteStates<const TOptions extends readonly RouteStateConfig[]>(configs: TOptions): UseRouteStatesReturn<TOptions>;
+//#endregion
+//#region src/router/options.d.ts
+type Exact<T, TShape> = T & Record<Exclude<keyof T, keyof TShape>, never>;
+export declare function routeStateOptions<const T extends RouteStateConfig>(options: Exact<T, RouteStateConfig>): T;
+export declare function routeStateOptions<const T extends RouteStateConfig>(options: () => Exact<T, RouteStateConfig>): () => T;
+export declare function routeHashOptions<const T extends RouteHashConfig>(options: Exact<T, RouteHashConfig>): T;
+export declare function routeHashOptions<const T extends RouteHashConfig>(options: () => Exact<T, RouteHashConfig>): () => T;
+//#endregion
+//#region src/router/use-route-state.d.ts
+type UseRouteStateOptions<P extends ParserInput | undefined = ParserInput | undefined, M = unknown> = ReactiveOptions<WithParser<RouteStateOptions, P, M>, 'missing'>;
+export declare function useRouteState<P extends ParserInput | undefined = undefined, const M = Missing>(options: UseRouteStateOptions<P, M>): Ref<InferInputValue<P, UnwrapOption<M>>, InferInputWritable<P, UnwrapOption<M>>>;
 //#endregion
-export { type BatchOptions, type HistoryMode, type ResolvedRouteStateOptions, type RouteHashOptions, type RouteStateConfig, type RouteStateOptions, type RouteStateSource, type UseRouteHashOptions, type UseRouteStateOptions, type UseRouteStatesApi, type UseRouteStatesReturn, useRouteHash, useRouteState, useRouteStates };
+export type { BatchOptions, HistoryMode, ResolvedRouteStateOptions, RouteHashConfig, RouteHashOptions, RouteStateConfig, RouteStateOptions, RouteStateSource, StateMode, UseRouteHashOptions, UseRouteStateOptions, UseRouteStatesApi, UseRouteStatesReturn };

package/dist/router/index.mjs

@@ -1,105 +1,245 @@
 import { _ as warnDev, h as ErrorCodes, m as unwrapDefault } from "../parsers-CA8aZuF-.mjs";
 import "../parser-B6hfbAwA.mjs";
-import { r as getActiveWagen } from "../wagen-C9_CPUdF.mjs";
-import { i as toValueDeep, n as serializeValue, r as resolveParser, t as parseValue } from "../utils-B-885gDp.mjs";
+import { l as resolveMissing, r as getActiveWagen, u as toValueDeep } from "../wagen-FM0F79xP.mjs";
+import { i as resolveParser, n as parseValue, r as serializeValue, t as normalizeRaw } from "../utils-B_xKZZeR.mjs";
 import { computed, customRef, getCurrentScope, nextTick, toValue } from "vue";
 import { useRoute, useRouter } from "vue-router";
+//#region src/router/options.ts
+function routeStateOptions(options) {
+	return options;
+}
+function routeHashOptions(options) {
+	return options;
+}
+//#endregion
+//#region src/router/queue.ts
+const queues = /* @__PURE__ */ new WeakMap();
+function getRouteQueue(router) {
+	let queue = queues.get(router);
+	if (!queue) {
+		queue = createRouteQueue(router);
+		queues.set(router, queue);
+	}
+	return queue;
+}
+function resolveBatchHistory(candidates, override) {
+	if (override) return override;
+	return candidates.includes("push") ? "push" : "replace";
+}
+function applyChanges(base, changes, hash) {
+	const params = { ...base.params };
+	const query = { ...base.query };
+	let changed = false;
+	for (const change of changes) {
+		const target = change.source === "params" ? params : query;
+		const current = target[change.urlKey];
+		if (Array.isArray(current)) changed = true;
+		else if (change.serialized === null) changed ||= current !== void 0;
+		else changed ||= current !== change.serialized;
+		target[change.urlKey] = change.serialized === null ? void 0 : change.serialized;
+	}
+	const nextHash = hash === void 0 ? base.hash : hash ?? "";
+	changed ||= nextHash !== base.hash;
+	return {
+		target: {
+			params,
+			query,
+			hash: nextHash
+		},
+		changed
+	};
+}
+function createRouteQueue(router) {
+	let batch = null;
+	let pending = null;
+	function open() {
+		const created = {
+			changes: [],
+			histories: [],
+			hash: void 0,
+			settled: nextTick().then(() => flush(created))
+		};
+		return created;
+	}
+	function flush(current) {
+		if (batch === current) batch = null;
+		const route = router.currentRoute.value;
+		const ahead = pending && pending.from === route ? pending : null;
+		const { target, changed } = applyChanges(ahead ?? route, current.changes, current.hash);
+		if (!changed) return ahead ? ahead.settled : Promise.resolve();
+		const history = resolveBatchHistory(ahead ? [ahead.history, ...current.histories] : current.histories);
+		const navigation = {
+			...target,
+			from: route,
+			history,
+			successor: null,
+			settled: router[history]({
+				params: target.params,
+				query: target.query,
+				hash: target.hash === "" ? void 0 : target.hash
+			}).then(settle, settle)
+		};
+		if (ahead) ahead.successor = navigation;
+		pending = navigation;
+		return navigation.settled;
+		function settle() {
+			if (pending === navigation) pending = null;
+			return navigation.successor?.settled;
+		}
+	}
+	function enqueue(write) {
+		batch ??= open();
+		if (write.changes) batch.changes.push(...write.changes);
+		if (write.hash !== void 0) batch.hash = write.hash;
+		batch.histories.push(write.history);
+		return batch.settled;
+	}
+	return { enqueue };
+}
+//#endregion
 //#region src/router/use-route-hash.ts
-function toResolvedHashOptions(options, defaults) {
+function toResolvedHashOptions(options, defaults, missing) {
 	return {
 		parser: resolveParser(options.parser),
+		missing: resolveMissing(options, missing),
 		history: options.history ?? defaults.history,
-		clearOnDefault: options.clearOnDefault ?? defaults.clearOnDefault
+		clearOnDefault: options.clearOnDefault ?? defaults.clearOnDefault,
+		mode: options.mode ?? defaults.mode
 	};
 }
 function useRouteHash(options = {}) {
 	if (!getCurrentScope()) warnDev(ErrorCodes.NO_EFFECT_SCOPE, "useRouteHash");
 	const route = useRoute();
-	const router = useRouter();
-	const defaults = getActiveWagen().router;
-	const resolvedOptions = computed(() => toResolvedHashOptions(toValueDeep(options), defaults));
-	return customRef((track) => ({
-		get: () => {
-			track();
-			const raw = route.hash === "" ? void 0 : route.hash;
-			return parseValue(resolvedOptions.value.parser, raw);
-		},
-		set: (next) => {
-			const { parser, history, clearOnDefault } = resolvedOptions.value;
-			const serialized = serializeValue(parser, clearOnDefault, next);
-			nextTick(() => {
-				if ((route.hash === "" ? null : route.hash) === serialized) return;
-				router[history]({
-					query: route.query,
-					params: route.params,
-					hash: serialized === null ? void 0 : serialized
+	const queue = getRouteQueue(useRouter());
+	const { router: defaults, missing } = getActiveWagen();
+	const resolvedOptions = computed(() => toResolvedHashOptions(toValueDeep(options), defaults, missing));
+	let cache = null;
+	let generation = 0;
+	let trigger;
+	function currentHash() {
+		return route.hash === "" ? null : route.hash;
+	}
+	return customRef((track, triggerRef) => {
+		trigger = triggerRef;
+		return {
+			get: () => {
+				track();
+				const resolved = resolvedOptions.value;
+				const current = currentHash();
+				if (resolved.mode === "source") {
+					cache = null;
+					return parseValue(resolved, current);
+				}
+				if (cache && cache.seen === current) return parseValue(resolved, cache.raw);
+				cache = {
+					seen: current,
+					raw: current
+				};
+				return parseValue(resolved, current);
+			},
+			set: (next) => {
+				const resolved = resolvedOptions.value;
+				const { history, mode } = resolved;
+				const serialized = serializeValue(resolved, next);
+				const optimistic = mode === "optimistic";
+				const own = ++generation;
+				if (optimistic) {
+					cache = {
+						seen: currentHash(),
+						raw: serialized
+					};
+					trigger();
+				}
+				queue.enqueue({
+					history,
+					hash: serialized
+				}).then(() => {
+					if (!optimistic || generation !== own) return;
+					cache = null;
+					trigger();
 				});
-			});
-		}
-	}));
+			}
+		};
+	});
 }
 //#endregion
 //#region src/router/use-base-route-state.ts
 function useBaseRouteState() {
 	const route = useRoute();
-	const router = useRouter();
-	function hasChanged(change) {
-		const current = change.source === "params" ? route.params[change.urlKey] : route.query[change.urlKey];
-		if (Array.isArray(current)) return true;
-		if (change.serialized === null) return current !== void 0;
-		return current !== change.serialized;
-	}
-	function navigate(changes, history) {
-		const changed = changes.filter(hasChanged);
-		if (changed.length === 0) return;
-		const params = { ...route.params };
-		const query = { ...route.query };
-		for (const change of changed) {
-			const target = change.source === "params" ? params : query;
-			target[change.urlKey] = change.serialized === null ? void 0 : change.serialized;
+	const queue = getRouteQueue(useRouter());
+	function createRouteStateRef(options) {
+		let cache = null;
+		let generation = 0;
+		let trigger;
+		function rawValue(urlKey, source) {
+			return source === "params" ? route.params[urlKey] : route.query[urlKey];
 		}
-		router[history]({
-			params,
-			query,
-			hash: route.hash
+		const state = customRef((track, triggerRef) => {
+			trigger = triggerRef;
+			return {
+				get: () => {
+					track();
+					const resolved = toValue(options);
+					const current = normalizeRaw(rawValue(resolved.urlKey, resolved.source));
+					if (resolved.mode === "source") {
+						cache = null;
+						return parseValue(resolved, current);
+					}
+					if (cache && cache.seen === current) return parseValue(resolved, cache.raw);
+					cache = {
+						seen: current,
+						raw: current
+					};
+					return parseValue(resolved, current);
+				},
+				set: (next) => {
+					write(serializeValue(toValue(options), next));
+				}
+			};
 		});
-	}
-	function createRouteStateRef(options) {
-		return customRef((track) => ({
-			get: () => {
-				track();
-				const { urlKey, source, parser } = toValue(options);
-				const raw = source === "params" ? route.params[urlKey] : route.query[urlKey];
-				return parseValue(parser, raw);
-			},
-			set: (next) => {
-				const { urlKey, source, parser, history, clearOnDefault } = toValue(options);
-				const serialized = serializeValue(parser, clearOnDefault, next);
-				nextTick(() => {
-					navigate([{
-						urlKey,
-						source,
-						serialized
-					}], history);
-				});
+		async function write(serialized, history) {
+			const resolved = toValue(options);
+			const optimistic = resolved.mode === "optimistic";
+			const current = ++generation;
+			if (optimistic) {
+				cache = {
+					seen: normalizeRaw(rawValue(resolved.urlKey, resolved.source)),
+					raw: serialized
+				};
+				trigger();
 			}
-		}));
+			return queue.enqueue({
+				history: history ?? resolved.history,
+				changes: [{
+					urlKey: resolved.urlKey,
+					source: resolved.source,
+					serialized
+				}]
+			}).then(() => {
+				if (!optimistic || generation !== current) return;
+				cache = null;
+				trigger();
+			});
+		}
+		return {
+			state,
+			write
+		};
 	}
-	return {
-		createRouteStateRef,
-		navigate
-	};
+	return { createRouteStateRef };
 }
 //#endregion
 //#region src/router/utils.ts
-function toResolvedOptions(input, defaults) {
+function toResolvedOptions(input, defaults, missing) {
 	return {
 		key: input.key,
 		parser: resolveParser(input.parser),
+		missing: resolveMissing(input, missing),
 		urlKey: input.urlKey ?? input.key,
 		source: input.source ?? defaults.source,
 		history: input.history ?? defaults.history,
-		clearOnDefault: input.clearOnDefault ?? defaults.clearOnDefault
+		clearOnDefault: input.clearOnDefault ?? defaults.clearOnDefault,
+		mode: input.mode ?? defaults.mode
 	};
 }
 //#endregion
@@ -107,59 +247,52 @@ function toResolvedOptions(input, defaults) {
 function useRouteState(options) {
 	if (!getCurrentScope()) warnDev(ErrorCodes.NO_EFFECT_SCOPE, "useRouteState");
 	const { createRouteStateRef } = useBaseRouteState();
-	const defaults = getActiveWagen().router;
-	return createRouteStateRef(computed(() => toResolvedOptions(toValueDeep(options), defaults)));
+	const { router: defaults, missing } = getActiveWagen();
+	return createRouteStateRef(computed(() => toResolvedOptions(toValueDeep(options), defaults, missing))).state;
 }
 //#endregion
 //#region src/router/use-route-states.ts
-function resolveBatchHistory(candidates, override) {
-	if (override) return override;
-	return candidates.includes("push") ? "push" : "replace";
-}
 function useRouteStates(configs) {
 	if (!getCurrentScope()) warnDev(ErrorCodes.NO_EFFECT_SCOPE, "useRouteStates");
-	const { createRouteStateRef, navigate } = useBaseRouteState();
-	const defaults = getActiveWagen().router;
-	const resolvedList = configs.map((config) => computed(() => toResolvedOptions(toValueDeep(config), defaults)));
-	const refs = Object.fromEntries(resolvedList.map((resolved) => [resolved.value.key, createRouteStateRef(resolved)]));
+	const { createRouteStateRef } = useBaseRouteState();
+	const { router: defaults, missing } = getActiveWagen();
+	const resolvedList = configs.map((config) => computed(() => toResolvedOptions(toValueDeep(config), defaults, missing)));
+	const handles = resolvedList.map((resolved) => createRouteStateRef(resolved));
+	const refs = Object.fromEntries(resolvedList.map((resolved, index) => [resolved.value.key, handles[index].state]));
+	function commit(writes, candidates, override) {
+		if (writes.length === 0) return;
+		const history = resolveBatchHistory(candidates, override);
+		for (const { handle, serialized } of writes) handle.write(serialized, history);
+	}
 	const api = {
 		set(patch, options) {
-			const changes = [];
-			const historyCandidates = [];
-			for (const resolved of resolvedList) {
-				const { key, urlKey, source, parser, clearOnDefault, history } = resolved.value;
-				if (!(key in patch)) continue;
+			const writes = [];
+			const candidates = [];
+			resolvedList.forEach((resolved, index) => {
+				const { key, history } = resolved.value;
+				if (!(key in patch)) return;
 				const next = patch[key];
-				changes.push({
-					urlKey,
-					source,
-					serialized: serializeValue(parser, clearOnDefault, next)
+				writes.push({
+					handle: handles[index],
+					serialized: serializeValue(resolved.value, next)
 				});
-				historyCandidates.push(history);
-			}
-			if (changes.length === 0) return;
-			const history = resolveBatchHistory(historyCandidates, options?.history);
-			nextTick(() => {
-				navigate(changes, history);
+				candidates.push(history);
 			});
+			commit(writes, candidates, options?.history);
 		},
 		reset(options) {
-			const changes = [];
-			const historyCandidates = [];
-			for (const resolved of resolvedList) {
-				const { urlKey, source, parser, clearOnDefault, history } = resolved.value;
+			const writes = [];
+			const candidates = [];
+			resolvedList.forEach((resolved, index) => {
+				const { parser, history } = resolved.value;
 				const next = parser.defaultValue !== void 0 ? unwrapDefault(parser.defaultValue) : null;
-				changes.push({
-					urlKey,
-					source,
-					serialized: serializeValue(parser, clearOnDefault, next)
+				writes.push({
+					handle: handles[index],
+					serialized: serializeValue(resolved.value, next)
 				});
-				historyCandidates.push(history);
-			}
-			const history = resolveBatchHistory(historyCandidates, options?.history);
-			nextTick(() => {
-				navigate(changes, history);
+				candidates.push(history);
 			});
+			commit(writes, candidates, options?.history);
 		},
 		toObject() {
 			const snapshot = {};
@@ -176,4 +309,4 @@ function useRouteStates(configs) {
 	};
 }
 //#endregion
-export { useRouteHash, useRouteState, useRouteStates };
+export { routeHashOptions, routeStateOptions, useRouteHash, useRouteState, useRouteStates };

package/dist/storage/index.d.mts

@@ -1,6 +1,5 @@
-import { i as InferInputWritable, r as InferInputValue, s as ParserInput } from "../types-CNt2lcP1.mjs";
+import { A as ReactiveOptions, M as StateMode, O as Missing, c as UnwrapOption, i as InferInputWritable, l as WithParser, r as InferInputValue, s as ParserInput } from "../types-DFspmU7A.mjs";
 import { a as StorageInstance, c as Unsubscribe, i as StorageConfig, l as createStorage, n as KeyListener, o as StorageListener, r as StorageAdapter, s as StorageOptions, t as ErrorHandler } from "../create-storage-DESmB4bY.mjs";
-import { n as ReactiveOptions } from "../options-BKybciek.mjs";
 import { Ref } from "vue";
 //#region src/storage/define-storage-state.d.ts
 type StorageSource = StorageInstance | 'local' | 'session';
@@ -8,9 +7,11 @@ interface StorageStateOptions {
   key: string;
   storage?: StorageSource;
   parser?: ParserInput;
+  missing?: unknown;
   clearOnDefault?: boolean;
+  mode?: StateMode;
 }
-interface StorageState<T = string | null, W = T | null | undefined> {
+interface StorageState<T = string | Missing, W = T | Missing | undefined> {
   readonly key: string;
   readonly storage: StorageInstance;
   get: () => T;
@@ -18,26 +19,23 @@ interface StorageState<T = string | null, W = T | null | undefined> {
   remove: () => void;
   subscribe: (listener: () => void) => Unsubscribe;
 }
-declare function defineStorageState<P extends ParserInput | undefined = undefined>(options: Omit<StorageStateOptions, 'parser'> & {
-  parser?: P;
-}): StorageState<InferInputValue<P>, InferInputWritable<P>>;
+export declare function defineStorageState<P extends ParserInput | undefined = undefined, const M = Missing>(options: WithParser<StorageStateOptions, P, M>): StorageState<InferInputValue<P, M>, InferInputWritable<P, M>>;
 //#endregion
 //#region src/storage/presets.d.ts
-declare function createMemoryStorage(config?: StorageConfig): StorageInstance;
-declare function createLocalStorage(config?: StorageConfig): StorageInstance;
-declare function createSessionStorage(config?: StorageConfig): StorageInstance;
+export declare function createMemoryStorage(config?: StorageConfig): StorageInstance;
+export declare function createLocalStorage(config?: StorageConfig): StorageInstance;
+export declare function createSessionStorage(config?: StorageConfig): StorageInstance;
 //#endregion
 //#region src/storage/use-storage.d.ts
-type UseStorageOptions<P extends ParserInput | undefined = ParserInput | undefined> = ReactiveOptions<Omit<StorageStateOptions, 'parser'> & {
-  parser?: P;
-}, 'parser'>;
-type UseLocalStorageOptions<P extends ParserInput | undefined = ParserInput | undefined> = ReactiveOptions<Omit<StorageStateOptions, 'parser' | 'storage'> & {
-  parser?: P;
-}, 'parser'>;
-type UseSessionStorageOptions<P extends ParserInput | undefined = ParserInput | undefined> = UseLocalStorageOptions<P>;
-declare function useStorage<T, W>(state: StorageState<T, W>): Ref<T, W>;
-declare function useStorage<P extends ParserInput | undefined = undefined>(options: UseStorageOptions<P>): Ref<InferInputValue<P>, InferInputWritable<P>>;
-declare function useLocalStorage<P extends ParserInput | undefined = undefined>(options: UseLocalStorageOptions<P>): Ref<InferInputValue<P>, InferInputWritable<P>>;
-declare function useSessionStorage<P extends ParserInput | undefined = undefined>(options: UseSessionStorageOptions<P>): Ref<InferInputValue<P>, InferInputWritable<P>>;
+type UseStorageOptions<P extends ParserInput | undefined = ParserInput | undefined, M = unknown> = ReactiveOptions<WithParser<StorageStateOptions, P, M>, 'missing'>;
+type UseLocalStorageOptions<P extends ParserInput | undefined = ParserInput | undefined, M = unknown> = ReactiveOptions<WithParser<Omit<StorageStateOptions, 'storage'>, P, M>, 'missing'>;
+type UseSessionStorageOptions<P extends ParserInput | undefined = ParserInput | undefined, M = unknown> = UseLocalStorageOptions<P, M>;
+type NotStorageState = {
+  get?: never;
+};
+export declare function useStorage<P extends ParserInput | undefined = undefined, const M = Missing>(options: UseStorageOptions<P, M> & NotStorageState): Ref<InferInputValue<P, UnwrapOption<M>>, InferInputWritable<P, UnwrapOption<M>>>;
+export declare function useStorage<T, W>(state: StorageState<T, W>): Ref<T, W>;
+export declare function useLocalStorage<P extends ParserInput | undefined = undefined, const M = Missing>(options: UseLocalStorageOptions<P, M>): Ref<InferInputValue<P, UnwrapOption<M>>, InferInputWritable<P, UnwrapOption<M>>>;
+export declare function useSessionStorage<P extends ParserInput | undefined = undefined, const M = Missing>(options: UseSessionStorageOptions<P, M>): Ref<InferInputValue<P, UnwrapOption<M>>, InferInputWritable<P, UnwrapOption<M>>>;
 //#endregion
-export { type ErrorHandler, type KeyListener, type StorageAdapter, type StorageConfig, type StorageInstance, type StorageListener, type StorageOptions, type StorageSource, type StorageState, type StorageStateOptions, type Unsubscribe, type UseLocalStorageOptions, type UseSessionStorageOptions, type UseStorageOptions, createLocalStorage, createMemoryStorage, createSessionStorage, createStorage, defineStorageState, useLocalStorage, useSessionStorage, useStorage };
+export { type ErrorHandler, type KeyListener, type StateMode, type StorageAdapter, type StorageConfig, type StorageInstance, type StorageListener, type StorageOptions, type StorageSource, type StorageState, type StorageStateOptions, type Unsubscribe, type UseLocalStorageOptions, type UseSessionStorageOptions, type UseStorageOptions, createStorage };

package/dist/storage/index.mjs

@@ -1,31 +1,68 @@
 import { _ as warnDev, h as ErrorCodes } from "../parsers-CA8aZuF-.mjs";
-import { a as createLocalStorage, c as createStorage, o as createMemoryStorage, r as getActiveWagen, s as createSessionStorage } from "../wagen-C9_CPUdF.mjs";
-import { i as toValueDeep, n as serializeValue, r as resolveParser, t as parseValue } from "../utils-B-885gDp.mjs";
+import { a as createLocalStorage, c as createStorage, l as resolveMissing, o as createMemoryStorage, r as getActiveWagen, s as createSessionStorage, u as toValueDeep } from "../wagen-FM0F79xP.mjs";
+import { i as resolveParser, n as parseValue, r as serializeValue } from "../utils-B_xKZZeR.mjs";
 import { computed, customRef, getCurrentScope, onWatcherCleanup, toValue, watch } from "vue";
 //#region src/storage/define-storage-state.ts
 function defineStorageState(options) {
 	const { key } = options;
 	const clearOnDefault = options.clearOnDefault ?? true;
 	const parser = resolveParser(options.parser);
-	function storage() {
+	let cache = null;
+	function resolved() {
+		const wagen = getActiveWagen();
 		const source = options.storage;
-		if (source && typeof source !== "string") return source;
-		const { storage } = getActiveWagen();
-		return source ? storage[source] : storage.default;
+		return {
+			instance: source === void 0 ? wagen.storage.default : typeof source === "string" ? wagen.storage[source] : source,
+			optimistic: (options.mode ?? wagen.storage.mode) === "optimistic",
+			missing: resolveMissing(options, wagen.missing)
+		};
+	}
+	function write(target, serialized) {
+		const { instance, optimistic } = target;
+		if (optimistic) cache = {
+			seen: instance.getItem(key),
+			raw: serialized
+		};
+		if (serialized === null) instance.removeItem(key);
+		else instance.setItem(key, serialized);
+		if (optimistic) cache = {
+			seen: instance.getItem(key),
+			raw: serialized
+		};
 	}
 	return {
 		key,
 		get storage() {
-			return storage();
+			return resolved().instance;
+		},
+		get: () => {
+			const { instance, optimistic, missing } = resolved();
+			const current = instance.getItem(key);
+			const state = {
+				parser,
+				missing
+			};
+			if (!optimistic) {
+				cache = null;
+				return parseValue(state, current);
+			}
+			if (cache && cache.seen === current) return parseValue(state, cache.raw);
+			cache = {
+				seen: current,
+				raw: current
+			};
+			return parseValue(state, current);
 		},
-		get: () => parseValue(parser, storage().getItem(key)),
 		set: (next) => {
-			const serialized = serializeValue(parser, clearOnDefault, next);
-			if (serialized === null) storage().removeItem(key);
-			else storage().setItem(key, serialized);
+			const target = resolved();
+			write(target, serializeValue({
+				parser,
+				clearOnDefault,
+				missing: target.missing
+			}, next));
 		},
-		remove: () => storage().removeItem(key),
-		subscribe: (listener) => storage().subscribe(key, listener)
+		remove: () => write(resolved(), null),
+		subscribe: (listener) => resolved().instance.subscribe(key, listener)
 	};
 }
 //#endregion
@@ -33,18 +70,20 @@ function defineStorageState(options) {
 function isStorageState(input) {
 	return typeof input === "object" && input !== null && typeof input.get === "function";
 }
-function withResolvedStorage(options, wagen) {
+function withDefaults(options, defaults, missing) {
 	const source = options.storage;
-	if (source && typeof source !== "string") return options;
+	const storage = source === void 0 ? defaults.default : typeof source === "string" ? defaults[source] : source;
 	return {
 		...options,
-		storage: source ? wagen.storage[source] : wagen.storage.default
+		storage,
+		mode: options.mode ?? defaults.mode,
+		missing: resolveMissing(options, missing)
 	};
 }
 function useStorageState(input) {
 	if (isStorageState(input)) return computed(() => input);
-	const wagen = getActiveWagen();
-	return computed(() => defineStorageState(withResolvedStorage(toValueDeep(input), wagen)));
+	const { storage, missing } = getActiveWagen();
+	return computed(() => defineStorageState(withDefaults(toValueDeep(input), storage, missing)));
 }
 function useStorage(input) {
 	if (!getCurrentScope()) warnDev(ErrorCodes.NO_EFFECT_SCOPE, "useStorage");

package/dist/{types-CuwASQTi.d.mts → types-Bv0pKeGI.d.mts}

@@ -1,4 +1,4 @@
-import { c as DefaultValue, s as ParserInput } from "./types-CNt2lcP1.mjs";
+import { M as StateMode, s as ParserInput, u as DefaultValue } from "./types-DFspmU7A.mjs";
 //#region src/parser/resolve.d.ts
 type ResolvedParser<T> = {
   parse: (raw: string) => T | null;
@@ -12,10 +12,12 @@ type HistoryMode = 'push' | 'replace';
 interface RouteStateOptions {
   key: string;
   parser?: ParserInput;
+  missing?: unknown;
   urlKey?: string;
   source?: RouteStateSource;
   history?: HistoryMode;
   clearOnDefault?: boolean;
+  mode?: StateMode;
 }
 type ResolvedRouteStateOptions = Omit<Required<RouteStateOptions>, 'parser'> & {
   parser: ResolvedParser<any>;

package/dist/{types-CNt2lcP1.d.mts → types-DFspmU7A.d.mts}

@@ -1,3 +1,13 @@
+import { ComputedRef, MaybeRef, MaybeRefOrGetter, Ref } from "vue";
+//#region src/types.d.ts
+type StateMode = 'optimistic' | 'source';
+interface Register {}
+type Registered<K extends string, TFallback> = K extends keyof Register ? Register[K] : TFallback;
+type Missing = Registered<'missing', null>;
+type MaybeRefOrComputed<T> = MaybeRef<T> | ComputedRef<T>;
+type ReactiveFields<T, TRaw extends keyof T = never> = { [K in keyof T]: K extends TRaw ? T[K] : K extends 'parser' ? MaybeRefOrComputed<T[K]> : MaybeRefOrGetter<T[K]>; };
+type ReactiveOptions<T, TRaw extends keyof T = never> = MaybeRefOrGetter<ReactiveFields<T, TRaw>>;
+//#endregion
 //#region src/parser/parsers.d.ts
 type ParserOptions<T> = {
   parse: (raw: string) => T | null;
@@ -49,12 +59,18 @@ type NamedParserRef = { [K in keyof KnownParsers]: {
 type ParserInput = (Parser<any> & {
   name?: never;
 }) | NamedParserRef;
-type InferInputValue<P> = [P] extends [undefined] ? string | null : P extends ParserWithDefault<infer T> ? T : P extends Parser<infer T> ? T | null : P extends {
+type UnwrapOption<T> = T extends Ref<infer U> ? U : T extends (() => infer U) ? U : T;
+type WithParser<T, P extends ParserInput | undefined, M = unknown> = Omit<T, 'parser' | 'missing'> & {
+  parser?: P;
+  missing?: M;
+};
+type InferInputValue<P, M = Missing> = ResolveInputValue<UnwrapOption<P>, M>;
+type ResolveInputValue<P, M> = [P] extends [undefined] ? string | M : P extends ParserWithDefault<infer T> ? T : P extends Parser<infer T> ? T | M : P extends {
   name: infer K;
   defaultValue: any;
 } ? K extends keyof KnownParsers ? InferParserValue<KnownParsers[K]> : string : P extends {
   name: infer K;
-} ? K extends keyof KnownParsers ? InferParserValue<KnownParsers[K]> | null : string | null : string | null;
-type InferInputWritable<P> = InferInputValue<P> | null | undefined;
+} ? K extends keyof KnownParsers ? InferParserValue<KnownParsers[K]> | M : string | M : string | M;
+type InferInputWritable<P, M = Missing> = InferInputValue<P, M> | M | null | undefined;
 //#endregion
-export { parseAsStringLiteral as C, parseAsStringEnum as S, unwrapDefault as T, parseAsIndex as _, InferParserValue as a, parseAsNumberLiteral as b, DefaultValue as c, ParserWithDefault as d, defineParser as f, parseAsFloat as g, parseAsDate as h, InferInputWritable as i, Parser as l, parseAsBoolean as m, CustomParsers as n, KnownParsers as o, parseAsArrayOf as p, InferInputValue as r, ParserInput as s, BuiltinParsers as t, ParserOptions as u, parseAsInteger as v, tryParse as w, parseAsString as x, parseAsJson as y };
+export { ReactiveOptions as A, parseAsString as C, unwrapDefault as D, tryParse as E, StateMode as M, Missing as O, parseAsNumberLiteral as S, parseAsStringLiteral as T, parseAsDate as _, InferParserValue as a, parseAsInteger as b, UnwrapOption as c, Parser as d, ParserOptions as f, parseAsBoolean as g, parseAsArrayOf as h, InferInputWritable as i, Register as j, ReactiveFields as k, WithParser as l, defineParser as m, CustomParsers as n, KnownParsers as o, ParserWithDefault as p, InferInputValue as r, ParserInput as s, BuiltinParsers as t, DefaultValue as u, parseAsFloat as v, parseAsStringEnum as w, parseAsJson as x, parseAsIndex as y };

package/dist/{utils-B-885gDp.mjs → utils-B_xKZZeR.mjs}

@@ -1,15 +1,6 @@
 import { g as warn, h as ErrorCodes, m as unwrapDefault, u as parseAsString } from "./parsers-CA8aZuF-.mjs";
-import { r as getActiveWagen } from "./wagen-C9_CPUdF.mjs";
+import { r as getActiveWagen } from "./wagen-FM0F79xP.mjs";
 import { n as isBuiltinParserName, t as builtinParsers } from "./builtins-DiCjLgsG.mjs";
-import { toValue } from "vue";
-//#region src/options.ts
-function toValueDeep(input) {
-	const source = toValue(input);
-	const result = {};
-	for (const key in source) result[key] = toValue(source[key]);
-	return result;
-}
-//#endregion
 //#region src/parser/resolve.ts
 function getParser(name) {
 	if (isBuiltinParserName(name)) return builtinParsers[name];
@@ -35,17 +26,11 @@ function fromName(name, override) {
 		}
 		return parseAsString;
 	}
-	const base = {
-		parse: (raw) => get().parse(raw),
-		serialize: (value) => get().serialize(value)
-	};
-	if (override) return {
-		...base,
-		defaultValue: override.defaultValue
-	};
 	return {
-		...base,
+		parse: (raw) => get().parse(raw),
+		serialize: (value) => get().serialize(value),
 		get defaultValue() {
+			if (override) return override.defaultValue;
 			return get().defaultValue;
 		}
 	};
@@ -57,15 +42,19 @@ function resolveParser(input = { name: "parseAsString" }) {
 }
 //#endregion
 //#region src/parser/utils.ts
-function parseValue(parser, raw) {
-	const value = Array.isArray(raw) ? raw.find((v) => v != null) : raw;
-	if (value == null) return parser.defaultValue !== void 0 ? unwrapDefault(parser.defaultValue) : null;
-	const parsed = parser.parse(value);
+function normalizeRaw(raw) {
+	return (Array.isArray(raw) ? raw.find((v) => v != null) : raw) ?? null;
+}
+function parseValue(options, raw) {
+	const { parser, missing } = options;
+	const value = normalizeRaw(raw);
+	const parsed = value === null ? null : parser.parse(value);
 	if (parsed !== null) return parsed;
-	return parser.defaultValue !== void 0 ? unwrapDefault(parser.defaultValue) : null;
+	return parser.defaultValue !== void 0 ? unwrapDefault(parser.defaultValue) : missing;
 }
-function serializeValue(parser, clearOnDefault, next) {
-	if (next == null) return null;
+function serializeValue(options, next) {
+	const { parser, clearOnDefault, missing } = options;
+	if (next == null || Object.is(next, missing)) return null;
 	const serialized = parser.serialize(next);
 	if (clearOnDefault && parser.defaultValue !== void 0) {
 		if (serialized === parser.serialize(unwrapDefault(parser.defaultValue))) return null;
@@ -73,4 +62,4 @@ function serializeValue(parser, clearOnDefault, next) {
 	return serialized;
 }
 //#endregion
-export { toValueDeep as i, serializeValue as n, resolveParser as r, parseValue as t };
+export { resolveParser as i, parseValue as n, serializeValue as r, normalizeRaw as t };

package/dist/vite/index.d.mts

@@ -1,8 +1,8 @@
 import { Plugin } from "vite";
 //#region src/vite/index.d.ts
-declare const PARSERS_ID = "virtual:usewagen/parsers";
-declare const RESOLVED_PARSERS_ID = "\0virtual:usewagen/parsers";
-interface WagenPluginOptions {
+export declare const PARSERS_ID = "virtual:usewagen/parsers";
+export declare const RESOLVED_PARSERS_ID = "\0virtual:usewagen/parsers";
+export interface WagenPluginOptions {
   /**
    * Directory or directories to scan for parser files.
    * @default 'src/parsers'
@@ -14,6 +14,6 @@ interface WagenPluginOptions {
    */
   dts?: string | false;
 }
-declare function usewagen(options?: WagenPluginOptions): Plugin;
+export declare function usewagen(options?: WagenPluginOptions): Plugin;
 //#endregion
-export { PARSERS_ID, RESOLVED_PARSERS_ID, WagenPluginOptions, usewagen as default, usewagen };
+export { usewagen as default };

package/dist/{wagen-C9_CPUdF.mjs → wagen-FM0F79xP.mjs}

@@ -1,5 +1,16 @@
 import { _ as warnDev, g as warn, h as ErrorCodes } from "./parsers-CA8aZuF-.mjs";
-import { hasInjectionContext, inject, markRaw } from "vue";
+import { hasInjectionContext, inject, markRaw, toValue } from "vue";
+//#region src/options.ts
+function toValueDeep(input) {
+	const source = toValue(input);
+	const result = {};
+	for (const key in source) result[key] = toValue(source[key]);
+	return result;
+}
+function resolveMissing(options, fallback) {
+	return "missing" in options ? options.missing : fallback;
+}
+//#endregion
 //#region src/storage/create-storage.ts
 const ALL_KEYS = Symbol("all-keys");
 function createStorage$1(name, options) {
@@ -197,7 +208,8 @@ const WAGEN_KEY = Symbol.for("usewagen");
 const ROUTER_DEFAULTS = {
 	history: "replace",
 	source: "query",
-	clearOnDefault: true
+	clearOnDefault: true,
+	mode: "optimistic"
 };
 let activeWagen = null;
 function createStorage(options) {
@@ -228,7 +240,8 @@ function createStorage(options) {
 		},
 		get default() {
 			return options.default === "session" ? storage.session : storage.local;
-		}
+		},
+		mode: options.mode ?? "optimistic"
 	};
 	function destroy() {
 		for (const instance of created) instance.destroy();
@@ -246,6 +259,7 @@ function createWagen(config = {}) {
 	const { storage, destroy } = createStorage(config.storage ?? {});
 	const wagen = markRaw({
 		parsers: { ...config.parsers },
+		missing: resolveMissing(config, null),
 		storage,
 		router: {
 			...ROUTER_DEFAULTS,
@@ -273,4 +287,4 @@ function useWagen() {
 	return getActiveWagen();
 }
 //#endregion
-export { createLocalStorage as a, createStorage$1 as c, useWagen as i, defineWagenConfig as n, createMemoryStorage as o, getActiveWagen as r, createSessionStorage as s, createWagen as t };
+export { createLocalStorage as a, createStorage$1 as c, useWagen as i, resolveMissing as l, defineWagenConfig as n, createMemoryStorage as o, getActiveWagen as r, createSessionStorage as s, createWagen as t, toValueDeep as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "usewagen",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Reactive state for URL and storage in Vue.",
   "keywords": [
     "composables",
@@ -64,7 +64,7 @@
   "devEngines": {
     "packageManager": {
       "name": "pnpm",
-      "version": "11.24.0",
+      "version": "11.25.0",
       "onFail": "download"
     }
   },

package/dist/options-BKybciek.d.mts

@@ -1,7 +0,0 @@
-import { MaybeRefOrGetter } from "vue";
-//#region src/options.d.ts
-type MaybeRefsOrGetters<T> = { [K in keyof T]: MaybeRefOrGetter<T[K]>; };
-type ReactiveFields<T, TStatic extends keyof T = never> = MaybeRefsOrGetters<Omit<T, TStatic>> & Pick<T, TStatic>;
-type ReactiveOptions<T, TStatic extends keyof T = never> = MaybeRefOrGetter<ReactiveFields<T, TStatic>>;
-//#endregion
-export { ReactiveOptions as n, ReactiveFields as t };