usewagen 0.0.0 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ahmet Tinastepe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+# usewagen
+
+Reactive state for URL and storage in Vue. Type-safe, with the value in exactly one place.
+
+Documentation lives at [usewagen.dev](https://usewagen.dev).
+
+## Install
+
+```sh
+pnpm add usewagen
+```
+
+`vue` is a peer dependency. `vue-router` is only needed if you use the router composables.
+
+## Usage
+
+```ts
+import { parseAsInteger } from 'usewagen'
+import { useRouteState } from 'usewagen/router'
+import { useLocalStorage } from 'usewagen/storage'
+
+const page = useRouteState({ key: 'page', parser: parseAsInteger.withDefault(1) })
+const theme = useLocalStorage({ key: 'theme' })
+```
+
+`page` is a `Ref<number>` over `?page=` and `theme` a `Ref<string | null>` over the `theme`
+entry in `localStorage`.
+
+## License
+
+[MIT](./LICENSE)

package/client.d.ts

@@ -0,0 +1,5 @@
+declare module 'virtual:usewagen/parsers' {
+  import type { Parser } from 'usewagen'
+
+  export const parsers: Record<string, Parser<any>>
+}

package/dist/builtins-DiCjLgsG.mjs

@@ -0,0 +1,15 @@
+import { a as parseAsFloat, i as parseAsDate, o as parseAsIndex, r as parseAsBoolean, s as parseAsInteger, u as parseAsString } from "./parsers-CA8aZuF-.mjs";
+//#region src/parser/builtins.ts
+const builtinParsers = {
+	parseAsString,
+	parseAsInteger,
+	parseAsFloat,
+	parseAsIndex,
+	parseAsBoolean,
+	parseAsDate
+};
+function isBuiltinParserName(name) {
+	return Object.hasOwn(builtinParsers, name);
+}
+//#endregion
+export { isBuiltinParserName as n, builtinParsers as t };

package/dist/create-storage-DESmB4bY.d.mts

@@ -0,0 +1,38 @@
+//#region src/storage/create-storage.d.ts
+type ErrorHandler = (error: unknown) => void;
+type Unsubscribe = () => void;
+type KeyListener = () => void;
+type StorageListener = (key: string | null) => void;
+interface StorageAdapter {
+  getItem: (key: string) => string | null;
+  setItem: (key: string, value: string) => void;
+  removeItem: (key: string) => void;
+  keys: () => string[];
+  watch?: (onChange: (key: string | null) => void) => Unsubscribe;
+}
+interface StorageConfig {
+  prefix?: string;
+  crossTab?: boolean;
+  onError?: ErrorHandler;
+}
+type StorageOptions = StorageAdapter & StorageConfig;
+interface StorageInstance {
+  readonly name: string;
+  readonly prefix: string;
+  getItem: (key: string) => string | null;
+  setItem: (key: string, value: string) => void;
+  removeItem: (key: string) => void;
+  has: (key: string) => boolean;
+  keys: () => string[];
+  clear: (options?: {
+    except?: string[];
+  }) => void;
+  subscribe: {
+    (key: string, listener: KeyListener): Unsubscribe;
+    (listener: StorageListener): Unsubscribe;
+  };
+  destroy: () => void;
+}
+declare function createStorage(name: string, options: StorageOptions): StorageInstance;
+//#endregion
+export { StorageInstance as a, Unsubscribe as c, StorageConfig as i, createStorage as l, KeyListener as n, StorageListener as o, StorageAdapter as r, StorageOptions as s, ErrorHandler as t };

package/dist/index.d.mts

@@ -0,0 +1,43 @@
+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 { a as StorageInstance, t as ErrorHandler } from "./create-storage-DESmB4bY.mjs";
+import { App } from "vue";
+//#region src/wagen.d.ts
+interface WagenStorageOptions {
+  prefix?: string;
+  crossTab?: boolean;
+  onError?: ErrorHandler;
+  local?: StorageInstance;
+  session?: StorageInstance;
+  default?: 'local' | 'session';
+}
+interface WagenRouterOptions {
+  history?: HistoryMode;
+  source?: RouteStateSource;
+  clearOnDefault?: boolean;
+}
+type WagenParsers = Record<string, Parser<any>>;
+interface WagenConfig {
+  parsers?: WagenParsers;
+  storage?: WagenStorageOptions;
+  router?: WagenRouterOptions;
+}
+interface WagenStorage {
+  readonly local: StorageInstance;
+  readonly session: StorageInstance;
+  readonly default: StorageInstance;
+}
+type ResolvedWagenRouterOptions = Required<WagenRouterOptions>;
+interface Wagen {
+  readonly parsers: WagenParsers;
+  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;
+//#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 };

package/dist/index.mjs

@@ -0,0 +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";
+export { createWagen, defineParser, defineWagenConfig, getActiveWagen, parseAsArrayOf, parseAsBoolean, parseAsDate, parseAsFloat, parseAsIndex, parseAsInteger, parseAsJson, parseAsNumberLiteral, parseAsString, parseAsStringEnum, parseAsStringLiteral, tryParse, unwrapDefault, useWagen };

package/dist/options-BKybciek.d.mts

@@ -0,0 +1,7 @@
+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 };

package/dist/parser-B6hfbAwA.mjs

@@ -0,0 +1,2 @@
+import "./parsers-CA8aZuF-.mjs";
+export {};

package/dist/parsers-CA8aZuF-.mjs

@@ -0,0 +1,156 @@
+//#region src/messages.ts
+const PREFIX = "[usewagen]";
+const ErrorCodes = {
+	PARSE_FAILED: 0,
+	UNKNOWN_PARSER_NAME: 1,
+	WEB_STORAGE_UNAVAILABLE: 2,
+	RESERVED_PARSER_NAME: 3,
+	DUPLICATE_PARSER_NAME: 4,
+	NO_INJECTION_CONTEXT: 5,
+	NO_EFFECT_SCOPE: 6
+};
+const errorMessages = {
+	[ErrorCodes.PARSE_FAILED]: "Failed to parse the input:",
+	[ErrorCodes.UNKNOWN_PARSER_NAME]: "No parser is registered under this name; falling back to `parseAsString`. Pass it to `createWagen({ parsers })`:",
+	[ErrorCodes.WEB_STORAGE_UNAVAILABLE]: "The storage area is not accessible; falling back to in-memory storage. Values will not persist:",
+	[ErrorCodes.RESERVED_PARSER_NAME]: "Skipping a parser whose name is reserved by a built-in:",
+	[ErrorCodes.DUPLICATE_PARSER_NAME]: "A parser with this name was already found in another file — the last one wins:",
+	[ErrorCodes.NO_INJECTION_CONTEXT]: "Composables should be called inside `setup()` or a function that runs in an injection context; falling back to the active instance. Outside one, use `getActiveWagen()` or the `define*` APIs:",
+	[ErrorCodes.NO_EFFECT_SCOPE]: "Composables should be called inside `setup()` or a running effect scope; outside one the effects they create are never released, which leaks:"
+};
+function getMessage(code) {
+	return `${PREFIX} ${errorMessages[code]}`;
+}
+function warn(code, ...details) {
+	console.warn(getMessage(code), ...details);
+}
+function warnDev(code, ...details) {
+	if (process.env.NODE_ENV !== "production") warn(code, ...details);
+}
+//#endregion
+//#region src/parser/parsers.ts
+function tryParse(fn, input) {
+	try {
+		return fn(input);
+	} catch (error) {
+		warn(ErrorCodes.PARSE_FAILED, input, error);
+		return null;
+	}
+}
+function defineParser(options) {
+	const parse = options.parse;
+	const serialize = options.serialize ?? String;
+	return {
+		parse,
+		serialize,
+		withDefault(value) {
+			const parser = defineParser({
+				parse,
+				serialize
+			});
+			Object.defineProperty(parser, "defaultValue", {
+				value,
+				enumerable: true
+			});
+			return parser;
+		}
+	};
+}
+function unwrapDefault(value) {
+	return typeof value === "function" ? value() : value;
+}
+const parseAsString = defineParser({
+	parse: (v) => v,
+	serialize: String
+});
+const parseAsInteger = defineParser({
+	parse: (v) => {
+		const n = Number.parseInt(v, 10);
+		return Number.isNaN(n) ? null : n;
+	},
+	serialize: (v) => Math.trunc(v).toString()
+});
+const parseAsFloat = defineParser({
+	parse: (v) => {
+		const n = Number.parseFloat(v);
+		return Number.isNaN(n) ? null : n;
+	},
+	serialize: (v) => v.toString()
+});
+const parseAsIndex = defineParser({
+	parse: (v) => {
+		const n = Number.parseInt(v, 10);
+		return Number.isNaN(n) ? null : n - 1;
+	},
+	serialize: (v) => (Math.trunc(v) + 1).toString()
+});
+const parseAsBoolean = defineParser({
+	parse: (v) => v === "true" ? true : v === "false" ? false : null,
+	serialize: (v) => v ? "true" : "false"
+});
+function parseAsStringLiteral(values) {
+	return defineParser({
+		parse: (v) => values.includes(v) ? v : null,
+		serialize: (v) => v.toString()
+	});
+}
+function parseAsNumberLiteral(values) {
+	return defineParser({
+		parse: (v) => {
+			const n = Number.parseFloat(v);
+			return values.includes(n) ? n : null;
+		},
+		serialize: (v) => v.toString()
+	});
+}
+function parseAsStringEnum(values) {
+	return parseAsStringLiteral(values);
+}
+const parseAsDate = Object.assign(defineParser({
+	parse: (v) => {
+		const d = new Date(v.includes("T") ? v : `${v}T00:00:00.000Z`);
+		return Number.isNaN(d.getTime()) ? null : d;
+	},
+	serialize: (v) => v.toISOString().slice(0, 10)
+}), {
+	iso: () => defineParser({
+		parse: (v) => {
+			const d = new Date(v);
+			return Number.isNaN(d.getTime()) ? null : d;
+		},
+		serialize: (v) => v.toISOString()
+	}),
+	timestamp: () => defineParser({
+		parse: (v) => {
+			const n = Number.parseInt(v, 10);
+			if (Number.isNaN(n)) return null;
+			const d = new Date(n);
+			return Number.isNaN(d.getTime()) ? null : d;
+		},
+		serialize: (v) => v.getTime().toString()
+	})
+});
+function parseAsArrayOf(itemParser, separator = ",") {
+	const encodedSeparator = encodeURIComponent(separator);
+	return defineParser({
+		parse: (raw) => {
+			if (raw === "") return [];
+			return raw.split(separator).map((item) => tryParse(itemParser.parse, item.replaceAll(encodedSeparator, separator))).filter((value) => value !== null);
+		},
+		serialize: (values) => values.map((value) => itemParser.serialize(value).replaceAll(separator, encodedSeparator)).join(separator)
+	});
+}
+function parseAsJson() {
+	return defineParser({
+		parse: (v) => {
+			try {
+				return JSON.parse(v);
+			} catch {
+				return null;
+			}
+		},
+		serialize: (v) => JSON.stringify(v)
+	});
+}
+//#endregion
+export { warnDev as _, parseAsFloat as a, parseAsJson as c, parseAsStringEnum as d, parseAsStringLiteral as f, warn as g, ErrorCodes as h, parseAsDate as i, parseAsNumberLiteral as l, unwrapDefault as m, parseAsArrayOf as n, parseAsIndex as o, tryParse as p, parseAsBoolean as r, parseAsInteger as s, defineParser as t, parseAsString as u };

package/dist/router/index.d.mts

@@ -0,0 +1,40 @@
+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 { Ref } from "vue";
+//#region src/router/use-route-hash.d.ts
+interface RouteHashOptions {
+  parser?: ParserInput;
+  history?: HistoryMode;
+  clearOnDefault?: boolean;
+}
+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>>;
+//#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'>;
+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']>; };
+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>;
+//#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 };

package/dist/router/index.mjs

@@ -0,0 +1,179 @@
+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 { computed, customRef, getCurrentScope, nextTick, toValue } from "vue";
+import { useRoute, useRouter } from "vue-router";
+//#region src/router/use-route-hash.ts
+function toResolvedHashOptions(options, defaults) {
+	return {
+		parser: resolveParser(options.parser),
+		history: options.history ?? defaults.history,
+		clearOnDefault: options.clearOnDefault ?? defaults.clearOnDefault
+	};
+}
+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
+				});
+			});
+		}
+	}));
+}
+//#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;
+		}
+		router[history]({
+			params,
+			query,
+			hash: route.hash
+		});
+	}
+	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);
+				});
+			}
+		}));
+	}
+	return {
+		createRouteStateRef,
+		navigate
+	};
+}
+//#endregion
+//#region src/router/utils.ts
+function toResolvedOptions(input, defaults) {
+	return {
+		key: input.key,
+		parser: resolveParser(input.parser),
+		urlKey: input.urlKey ?? input.key,
+		source: input.source ?? defaults.source,
+		history: input.history ?? defaults.history,
+		clearOnDefault: input.clearOnDefault ?? defaults.clearOnDefault
+	};
+}
+//#endregion
+//#region src/router/use-route-state.ts
+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)));
+}
+//#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 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 next = patch[key];
+				changes.push({
+					urlKey,
+					source,
+					serialized: serializeValue(parser, clearOnDefault, next)
+				});
+				historyCandidates.push(history);
+			}
+			if (changes.length === 0) return;
+			const history = resolveBatchHistory(historyCandidates, options?.history);
+			nextTick(() => {
+				navigate(changes, history);
+			});
+		},
+		reset(options) {
+			const changes = [];
+			const historyCandidates = [];
+			for (const resolved of resolvedList) {
+				const { urlKey, source, parser, clearOnDefault, history } = resolved.value;
+				const next = parser.defaultValue !== void 0 ? unwrapDefault(parser.defaultValue) : null;
+				changes.push({
+					urlKey,
+					source,
+					serialized: serializeValue(parser, clearOnDefault, next)
+				});
+				historyCandidates.push(history);
+			}
+			const history = resolveBatchHistory(historyCandidates, options?.history);
+			nextTick(() => {
+				navigate(changes, history);
+			});
+		},
+		toObject() {
+			const snapshot = {};
+			for (const resolved of resolvedList) {
+				const { key } = resolved.value;
+				snapshot[key] = refs[key].value;
+			}
+			return snapshot;
+		}
+	};
+	return {
+		...refs,
+		...api
+	};
+}
+//#endregion
+export { useRouteHash, useRouteState, useRouteStates };

package/dist/storage/index.d.mts

@@ -0,0 +1,43 @@
+import { i as InferInputWritable, r as InferInputValue, s as ParserInput } from "../types-CNt2lcP1.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';
+interface StorageStateOptions {
+  key: string;
+  storage?: StorageSource;
+  parser?: ParserInput;
+  clearOnDefault?: boolean;
+}
+interface StorageState<T = string | null, W = T | null | undefined> {
+  readonly key: string;
+  readonly storage: StorageInstance;
+  get: () => T;
+  set: (value: W) => void;
+  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>>;
+//#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;
+//#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>>;
+//#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 };