usewagen 0.2.0 → 0.3.0

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { A as unwrapDefault, C as parseAsInteger, D as parseAsStringEnum, E as parseAsString, O as parseAsStringLiteral, S as parseAsIndex, T as parseAsNumberLiteral, _ as defineParser, a as CustomParsers, b as parseAsDate, c as InferParserValue, d as UnwrapParser, f as WithParser, g as ParserWithDefault, h as ParserOptions, i as BuiltinParsers, k as tryParse, l as KnownParsers, m as Parser, o as InferInputValue, p as DefaultValue, r as StateMode, s as InferInputWritable, u as ParserInput, v as parseAsArrayOf, w as parseAsJson, x as parseAsFloat, y as parseAsBoolean } from "./types-JtRmT3qo.mjs";
-import { i as RouteStateSource, t as HistoryMode } from "./types-fVW6rBJ3.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
@@ -19,11 +19,16 @@ interface WagenRouterOptions {
   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;
@@ -33,6 +38,7 @@ interface WagenStorage {
 type ResolvedWagenRouterOptions = Required<WagenRouterOptions>;
 interface Wagen {
   readonly parsers: WagenParsers;
+  readonly missing: Missing;
   readonly storage: WagenStorage;
   readonly router: ResolvedWagenRouterOptions;
   install: (app: App) => void;
@@ -43,4 +49,4 @@ 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 StateMode, type UnwrapParser, 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 };
+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-C2p8oQgu.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,25 +1,27 @@
-import { f as WithParser, n as ReactiveOptions, o as InferInputValue, r as StateMode, s as InferInputWritable, t as ReactiveFields, u as ParserInput } from "../types-JtRmT3qo.mjs";
-import { i as RouteStateSource, n as ResolvedRouteStateOptions, r as RouteStateOptions, t as HistoryMode } from "../types-fVW6rBJ3.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<WithParser<RouteHashOptions, P>>;
-type RouteHashConfig = ReactiveFields<RouteHashOptions>;
-export declare function useRouteHash<P extends ParserInput | undefined = undefined>(options?: UseRouteHashOptions<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<WithParser<RouteStateOptions, P>, 'key'>;
+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;
@@ -36,7 +38,7 @@ export declare function routeHashOptions<const T extends RouteHashConfig>(option
 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> = ReactiveOptions<WithParser<RouteStateOptions, P>>;
-export declare function useRouteState<P extends ParserInput | undefined = undefined>(options: UseRouteStateOptions<P>): Ref<InferInputValue<P>, InferInputWritable<P>>;
+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, HistoryMode, ResolvedRouteStateOptions, RouteHashConfig, RouteHashOptions, RouteStateConfig, RouteStateOptions, RouteStateSource, StateMode, UseRouteHashOptions, UseRouteStateOptions, UseRouteStatesApi, UseRouteStatesReturn };

package/dist/router/index.mjs

@@ -1,7 +1,7 @@
 import { _ as warnDev, h as ErrorCodes, m as unwrapDefault } from "../parsers-CA8aZuF-.mjs";
 import "../parser-B6hfbAwA.mjs";
-import { r as getActiveWagen } from "../wagen-C2p8oQgu.mjs";
-import { a as toValueDeep, i as resolveParser, n as parseValue, r as serializeValue, t as normalizeRaw } from "../utils-EL2EiRpH.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
@@ -13,36 +13,24 @@ function routeHashOptions(options) {
 }
 //#endregion
 //#region src/router/queue.ts
-const batches = /* @__PURE__ */ new WeakMap();
+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 enqueue(router, write) {
-	let batch = batches.get(router);
-	if (!batch) {
-		const created = {
-			changes: [],
-			histories: [],
-			hash: void 0,
-			settled: Promise.resolve()
-		};
-		created.settled = nextTick().then(() => flush(router, created));
-		batches.set(router, created);
-		batch = created;
-	}
-	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;
-}
-function flush(router, batch) {
-	if (batches.get(router) === batch) batches.delete(router);
-	const route = router.currentRoute.value;
-	const params = { ...route.params };
-	const query = { ...route.query };
+function applyChanges(base, changes, hash) {
+	const params = { ...base.params };
+	const query = { ...base.query };
 	let changed = false;
-	for (const change of batch.changes) {
+	for (const change of changes) {
 		const target = change.source === "params" ? params : query;
 		const current = target[change.urlKey];
 		if (Array.isArray(current)) changed = true;
@@ -50,20 +38,70 @@ function flush(router, batch) {
 		else changed ||= current !== change.serialized;
 		target[change.urlKey] = change.serialized === null ? void 0 : change.serialized;
 	}
-	const hash = batch.hash === void 0 ? route.hash : batch.hash ?? "";
-	changed ||= hash !== route.hash;
-	if (!changed) return Promise.resolve();
-	return router[resolveBatchHistory(batch.histories)]({
-		params,
-		query,
-		hash: hash === "" ? void 0 : hash
-	}).then(() => {}, () => {});
+	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,
 		mode: options.mode ?? defaults.mode
@@ -72,9 +110,9 @@ function toResolvedHashOptions(options, defaults) {
 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));
+	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;
@@ -86,22 +124,23 @@ function useRouteHash(options = {}) {
 		return {
 			get: () => {
 				track();
-				const { parser, mode } = resolvedOptions.value;
+				const resolved = resolvedOptions.value;
 				const current = currentHash();
-				if (mode === "source") {
+				if (resolved.mode === "source") {
 					cache = null;
-					return parseValue(parser, current);
+					return parseValue(resolved, current);
 				}
-				if (cache && cache.seen === current) return parseValue(parser, cache.raw);
+				if (cache && cache.seen === current) return parseValue(resolved, cache.raw);
 				cache = {
 					seen: current,
 					raw: current
 				};
-				return parseValue(parser, current);
+				return parseValue(resolved, current);
 			},
 			set: (next) => {
-				const { parser, clearOnDefault, history, mode } = resolvedOptions.value;
-				const serialized = serializeValue(parser, clearOnDefault, next);
+				const resolved = resolvedOptions.value;
+				const { history, mode } = resolved;
+				const serialized = serializeValue(resolved, next);
 				const optimistic = mode === "optimistic";
 				const own = ++generation;
 				if (optimistic) {
@@ -111,7 +150,7 @@ function useRouteHash(options = {}) {
 					};
 					trigger();
 				}
-				enqueue(router, {
+				queue.enqueue({
 					history,
 					hash: serialized
 				}).then(() => {
@@ -127,7 +166,7 @@ function useRouteHash(options = {}) {
 //#region src/router/use-base-route-state.ts
 function useBaseRouteState() {
 	const route = useRoute();
-	const router = useRouter();
+	const queue = getRouteQueue(useRouter());
 	function createRouteStateRef(options) {
 		let cache = null;
 		let generation = 0;
@@ -140,26 +179,25 @@ function useBaseRouteState() {
 			return {
 				get: () => {
 					track();
-					const { urlKey, source, parser, mode } = toValue(options);
-					const current = normalizeRaw(rawValue(urlKey, source));
-					if (mode === "source") {
+					const resolved = toValue(options);
+					const current = normalizeRaw(rawValue(resolved.urlKey, resolved.source));
+					if (resolved.mode === "source") {
 						cache = null;
-						return parseValue(parser, current);
+						return parseValue(resolved, current);
 					}
-					if (cache && cache.seen === current) return parseValue(parser, cache.raw);
+					if (cache && cache.seen === current) return parseValue(resolved, cache.raw);
 					cache = {
 						seen: current,
 						raw: current
 					};
-					return parseValue(parser, current);
+					return parseValue(resolved, current);
 				},
 				set: (next) => {
-					const { parser, clearOnDefault } = toValue(options);
-					write(serializeValue(parser, clearOnDefault, next));
+					write(serializeValue(toValue(options), next));
 				}
 			};
 		});
-		function write(serialized, history) {
+		async function write(serialized, history) {
 			const resolved = toValue(options);
 			const optimistic = resolved.mode === "optimistic";
 			const current = ++generation;
@@ -170,7 +208,7 @@ function useBaseRouteState() {
 				};
 				trigger();
 			}
-			return enqueue(router, {
+			return queue.enqueue({
 				history: history ?? resolved.history,
 				changes: [{
 					urlKey: resolved.urlKey,
@@ -192,10 +230,11 @@ function useBaseRouteState() {
 }
 //#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,
@@ -208,16 +247,16 @@ 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))).state;
+	const { router: defaults, missing } = getActiveWagen();
+	return createRouteStateRef(computed(() => toResolvedOptions(toValueDeep(options), defaults, missing))).state;
 }
 //#endregion
 //#region src/router/use-route-states.ts
 function useRouteStates(configs) {
 	if (!getCurrentScope()) warnDev(ErrorCodes.NO_EFFECT_SCOPE, "useRouteStates");
 	const { createRouteStateRef } = useBaseRouteState();
-	const defaults = getActiveWagen().router;
-	const resolvedList = configs.map((config) => computed(() => toResolvedOptions(toValueDeep(config), defaults)));
+	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) {
@@ -230,12 +269,12 @@ function useRouteStates(configs) {
 			const writes = [];
 			const candidates = [];
 			resolvedList.forEach((resolved, index) => {
-				const { key, parser, clearOnDefault, history } = resolved.value;
+				const { key, history } = resolved.value;
 				if (!(key in patch)) return;
 				const next = patch[key];
 				writes.push({
 					handle: handles[index],
-					serialized: serializeValue(parser, clearOnDefault, next)
+					serialized: serializeValue(resolved.value, next)
 				});
 				candidates.push(history);
 			});
@@ -245,11 +284,11 @@ function useRouteStates(configs) {
 			const writes = [];
 			const candidates = [];
 			resolvedList.forEach((resolved, index) => {
-				const { parser, clearOnDefault, history } = resolved.value;
+				const { parser, history } = resolved.value;
 				const next = parser.defaultValue !== void 0 ? unwrapDefault(parser.defaultValue) : null;
 				writes.push({
 					handle: handles[index],
-					serialized: serializeValue(parser, clearOnDefault, next)
+					serialized: serializeValue(resolved.value, next)
 				});
 				candidates.push(history);
 			});

package/dist/storage/index.d.mts

@@ -1,4 +1,4 @@
-import { f as WithParser, n as ReactiveOptions, o as InferInputValue, r as StateMode, s as InferInputWritable, u as ParserInput } from "../types-JtRmT3qo.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 { Ref } from "vue";
 //#region src/storage/define-storage-state.d.ts
@@ -7,10 +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,7 +19,7 @@ interface StorageState<T = string | null, W = T | null | undefined> {
   remove: () => void;
   subscribe: (listener: () => void) => Unsubscribe;
 }
-export declare function defineStorageState<P extends ParserInput | undefined = undefined>(options: WithParser<StorageStateOptions, 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
 export declare function createMemoryStorage(config?: StorageConfig): StorageInstance;
@@ -26,12 +27,15 @@ export declare function createLocalStorage(config?: StorageConfig): StorageInsta
 export declare function createSessionStorage(config?: StorageConfig): StorageInstance;
 //#endregion
 //#region src/storage/use-storage.d.ts
-type UseStorageOptions<P extends ParserInput | undefined = ParserInput | undefined> = ReactiveOptions<WithParser<StorageStateOptions, P>>;
-type UseLocalStorageOptions<P extends ParserInput | undefined = ParserInput | undefined> = ReactiveOptions<WithParser<Omit<StorageStateOptions, 'storage'>, P>>;
-type UseSessionStorageOptions<P extends ParserInput | undefined = ParserInput | undefined> = UseLocalStorageOptions<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 useStorage<P extends ParserInput | undefined = undefined>(options: UseStorageOptions<P>): Ref<InferInputValue<P>, InferInputWritable<P>>;
-export declare function useLocalStorage<P extends ParserInput | undefined = undefined>(options: UseLocalStorageOptions<P>): Ref<InferInputValue<P>, InferInputWritable<P>>;
-export declare function useSessionStorage<P extends ParserInput | undefined = undefined>(options: UseSessionStorageOptions<P>): Ref<InferInputValue<P>, InferInputWritable<P>>;
+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 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,6 +1,6 @@
 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-C2p8oQgu.mjs";
-import { a as toValueDeep, i as resolveParser, n as parseValue, r as serializeValue } from "../utils-EL2EiRpH.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) {
@@ -9,20 +9,16 @@ function defineStorageState(options) {
 	const parser = resolveParser(options.parser);
 	let cache = null;
 	function resolved() {
-		const source = options.storage;
-		const mode = options.mode;
-		if (mode !== void 0 && source !== void 0 && typeof source !== "string") return {
-			instance: source,
-			optimistic: mode === "optimistic"
-		};
 		const wagen = getActiveWagen();
+		const source = options.storage;
 		return {
 			instance: source === void 0 ? wagen.storage.default : typeof source === "string" ? wagen.storage[source] : source,
-			optimistic: (mode ?? wagen.storage.mode) === "optimistic"
+			optimistic: (options.mode ?? wagen.storage.mode) === "optimistic",
+			missing: resolveMissing(options, wagen.missing)
 		};
 	}
-	function write(serialized) {
-		const { instance, optimistic } = resolved();
+	function write(target, serialized) {
+		const { instance, optimistic } = target;
 		if (optimistic) cache = {
 			seen: instance.getItem(key),
 			raw: serialized
@@ -40,21 +36,32 @@ function defineStorageState(options) {
 			return resolved().instance;
 		},
 		get: () => {
-			const { instance, optimistic } = resolved();
+			const { instance, optimistic, missing } = resolved();
 			const current = instance.getItem(key);
+			const state = {
+				parser,
+				missing
+			};
 			if (!optimistic) {
 				cache = null;
-				return parseValue(parser, current);
+				return parseValue(state, current);
 			}
-			if (cache && cache.seen === current) return parseValue(parser, cache.raw);
+			if (cache && cache.seen === current) return parseValue(state, cache.raw);
 			cache = {
 				seen: current,
 				raw: current
 			};
-			return parseValue(parser, current);
+			return parseValue(state, current);
+		},
+		set: (next) => {
+			const target = resolved();
+			write(target, serializeValue({
+				parser,
+				clearOnDefault,
+				missing: target.missing
+			}, next));
 		},
-		set: (next) => write(serializeValue(parser, clearOnDefault, next)),
-		remove: () => write(null),
+		remove: () => write(resolved(), null),
 		subscribe: (listener) => resolved().instance.subscribe(key, listener)
 	};
 }
@@ -63,19 +70,20 @@ function defineStorageState(options) {
 function isStorageState(input) {
 	return typeof input === "object" && input !== null && typeof input.get === "function";
 }
-function withWagenDefaults(options, wagen) {
+function withDefaults(options, defaults, missing) {
 	const source = options.storage;
-	const storage = source === void 0 ? wagen.storage.default : typeof source === "string" ? wagen.storage[source] : source;
+	const storage = source === void 0 ? defaults.default : typeof source === "string" ? defaults[source] : source;
 	return {
 		...options,
 		storage,
-		mode: options.mode ?? wagen.storage.mode
+		mode: options.mode ?? defaults.mode,
+		missing: resolveMissing(options, missing)
 	};
 }
 function useStorageState(input) {
 	if (isStorageState(input)) return computed(() => input);
-	const wagen = getActiveWagen();
-	return computed(() => defineStorageState(withWagenDefaults(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-fVW6rBJ3.d.mts → types-Bv0pKeGI.d.mts}

@@ -1,4 +1,4 @@
-import { p as DefaultValue, r as StateMode, u as ParserInput } from "./types-JtRmT3qo.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,6 +12,7 @@ type HistoryMode = 'push' | 'replace';
 interface RouteStateOptions {
   key: string;
   parser?: ParserInput;
+  missing?: unknown;
   urlKey?: string;
   source?: RouteStateSource;
   history?: HistoryMode;

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

@@ -1,4 +1,13 @@
-import { MaybeRefOrGetter, Ref } from "vue";
+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;
@@ -50,23 +59,18 @@ type NamedParserRef = { [K in keyof KnownParsers]: {
 type ParserInput = (Parser<any> & {
   name?: never;
 }) | NamedParserRef;
-type UnwrapParser<P> = P extends Ref<infer U> ? U : P extends (() => infer U) ? U : P;
-type WithParser<T, P extends ParserInput | undefined> = Omit<T, 'parser'> & {
+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> = ResolveInputValue<UnwrapParser<P>>;
-type ResolveInputValue<P> = [P] extends [undefined] ? string | null : P extends ParserWithDefault<infer T> ? T : P extends Parser<infer T> ? T | null : P extends {
+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;
-//#endregion
-//#region src/types.d.ts
-type StateMode = 'optimistic' | 'source';
-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>>;
+} ? 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 { unwrapDefault as A, parseAsInteger as C, parseAsStringEnum as D, parseAsString as E, parseAsStringLiteral as O, parseAsIndex as S, parseAsNumberLiteral as T, defineParser as _, CustomParsers as a, parseAsDate as b, InferParserValue as c, UnwrapParser as d, WithParser as f, ParserWithDefault as g, ParserOptions as h, BuiltinParsers as i, tryParse as k, KnownParsers as l, Parser as m, ReactiveOptions as n, InferInputValue as o, DefaultValue as p, StateMode as r, InferInputWritable as s, ReactiveFields as t, ParserInput as u, parseAsArrayOf as v, parseAsJson as w, parseAsFloat as x, parseAsBoolean 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-EL2EiRpH.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-C2p8oQgu.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;
 		}
 	};
@@ -60,15 +45,16 @@ function resolveParser(input = { name: "parseAsString" }) {
 function normalizeRaw(raw) {
 	return (Array.isArray(raw) ? raw.find((v) => v != null) : raw) ?? null;
 }
-function parseValue(parser, raw) {
+function parseValue(options, raw) {
+	const { parser, missing } = options;
 	const value = normalizeRaw(raw);
-	if (value === null) return parser.defaultValue !== void 0 ? unwrapDefault(parser.defaultValue) : null;
-	const parsed = parser.parse(value);
+	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;
@@ -76,4 +62,4 @@ function serializeValue(parser, clearOnDefault, next) {
 	return serialized;
 }
 //#endregion
-export { toValueDeep as a, resolveParser as i, parseValue as n, serializeValue as r, normalizeRaw as t };
+export { resolveParser as i, parseValue as n, serializeValue as r, normalizeRaw as t };

package/dist/{wagen-C2p8oQgu.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) {
@@ -248,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,
@@ -275,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.2.0",
+  "version": "0.3.0",
   "description": "Reactive state for URL and storage in Vue.",
   "keywords": [
     "composables",