usewagen 0.0.0 → 0.2.0

package/dist/storage/index.mjs

@@ -0,0 +1,115 @@
+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 { 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);
+	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();
+		return {
+			instance: source === void 0 ? wagen.storage.default : typeof source === "string" ? wagen.storage[source] : source,
+			optimistic: (mode ?? wagen.storage.mode) === "optimistic"
+		};
+	}
+	function write(serialized) {
+		const { instance, optimistic } = resolved();
+		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 resolved().instance;
+		},
+		get: () => {
+			const { instance, optimistic } = resolved();
+			const current = instance.getItem(key);
+			if (!optimistic) {
+				cache = null;
+				return parseValue(parser, current);
+			}
+			if (cache && cache.seen === current) return parseValue(parser, cache.raw);
+			cache = {
+				seen: current,
+				raw: current
+			};
+			return parseValue(parser, current);
+		},
+		set: (next) => write(serializeValue(parser, clearOnDefault, next)),
+		remove: () => write(null),
+		subscribe: (listener) => resolved().instance.subscribe(key, listener)
+	};
+}
+//#endregion
+//#region src/storage/use-storage.ts
+function isStorageState(input) {
+	return typeof input === "object" && input !== null && typeof input.get === "function";
+}
+function withWagenDefaults(options, wagen) {
+	const source = options.storage;
+	const storage = source === void 0 ? wagen.storage.default : typeof source === "string" ? wagen.storage[source] : source;
+	return {
+		...options,
+		storage,
+		mode: options.mode ?? wagen.storage.mode
+	};
+}
+function useStorageState(input) {
+	if (isStorageState(input)) return computed(() => input);
+	const wagen = getActiveWagen();
+	return computed(() => defineStorageState(withWagenDefaults(toValueDeep(input), wagen)));
+}
+function useStorage(input) {
+	if (!getCurrentScope()) warnDev(ErrorCodes.NO_EFFECT_SCOPE, "useStorage");
+	const state = useStorageState(input);
+	let notify;
+	const value = customRef((track, trigger) => {
+		notify = trigger;
+		return {
+			get: () => {
+				track();
+				return state.value.get();
+			},
+			set: (next) => state.value.set(next)
+		};
+	});
+	watch(state, (current) => {
+		onWatcherCleanup(current.subscribe(notify));
+	}, {
+		immediate: true,
+		flush: "sync"
+	});
+	return value;
+}
+function useLocalStorage(options) {
+	return useStorage(() => ({
+		...toValue(options),
+		storage: "local"
+	}));
+}
+function useSessionStorage(options) {
+	return useStorage(() => ({
+		...toValue(options),
+		storage: "session"
+	}));
+}
+//#endregion
+export { createLocalStorage, createMemoryStorage, createSessionStorage, createStorage, defineStorageState, useLocalStorage, useSessionStorage, useStorage };

package/dist/types-JtRmT3qo.d.mts

@@ -0,0 +1,72 @@
+import { MaybeRefOrGetter, Ref } from "vue";
+//#region src/parser/parsers.d.ts
+type ParserOptions<T> = {
+  parse: (raw: string) => T | null;
+  serialize?: (value: T) => string;
+};
+type DefaultValue<T> = T | (() => T);
+type Parser<T> = {
+  parse: (raw: string) => T | null;
+  serialize: (value: T) => string;
+  withDefault: (value: DefaultValue<T>) => ParserWithDefault<T>;
+};
+type ParserWithDefault<T> = Parser<T> & {
+  readonly defaultValue: DefaultValue<T>;
+};
+declare function tryParse<I, R>(fn: (input: I) => R, input: I): R | null;
+declare function defineParser<T>(options: ParserOptions<T>): Parser<T>;
+declare function unwrapDefault<T>(value: DefaultValue<T>): T;
+declare const parseAsString: Parser<string>;
+declare const parseAsInteger: Parser<number>;
+declare const parseAsFloat: Parser<number>;
+declare const parseAsIndex: Parser<number>;
+declare const parseAsBoolean: Parser<boolean>;
+declare function parseAsStringLiteral<const T extends readonly string[]>(values: T): Parser<T[number]>;
+declare function parseAsNumberLiteral<const T extends readonly number[]>(values: T): Parser<T[number]>;
+declare function parseAsStringEnum<T extends string>(values: T[]): Parser<T>;
+declare const parseAsDate: Parser<Date> & {
+  iso: () => Parser<Date>;
+  timestamp: () => Parser<Date>;
+};
+declare function parseAsArrayOf<T>(itemParser: Parser<T>, separator?: string): Parser<T[]>;
+declare function parseAsJson<T>(): Parser<T>;
+//#endregion
+//#region src/parser/types.d.ts
+type BuiltinParsers = {
+  parseAsString: Parser<string>;
+  parseAsInteger: Parser<number>;
+  parseAsFloat: Parser<number>;
+  parseAsIndex: Parser<number>;
+  parseAsBoolean: Parser<boolean>;
+  parseAsDate: Parser<Date>;
+};
+interface CustomParsers {}
+type KnownParsers = BuiltinParsers & Omit<CustomParsers, keyof BuiltinParsers>;
+type InferParserValue<P> = P extends Parser<infer T> ? T : never;
+type NamedParserRef = { [K in keyof KnownParsers]: {
+  name: K;
+  defaultValue?: DefaultValue<InferParserValue<KnownParsers[K]>>;
+}; }[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'> & {
+  parser?: P;
+};
+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 {
+  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>>;
+//#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 };

package/dist/types-fVW6rBJ3.d.mts

@@ -0,0 +1,25 @@
+import { p as DefaultValue, r as StateMode, u as ParserInput } from "./types-JtRmT3qo.mjs";
+//#region src/parser/resolve.d.ts
+type ResolvedParser<T> = {
+  parse: (raw: string) => T | null;
+  serialize: (value: T) => string;
+  defaultValue?: DefaultValue<T>;
+};
+//#endregion
+//#region src/router/types.d.ts
+type RouteStateSource = 'params' | 'query';
+type HistoryMode = 'push' | 'replace';
+interface RouteStateOptions {
+  key: string;
+  parser?: ParserInput;
+  urlKey?: string;
+  source?: RouteStateSource;
+  history?: HistoryMode;
+  clearOnDefault?: boolean;
+  mode?: StateMode;
+}
+type ResolvedRouteStateOptions = Omit<Required<RouteStateOptions>, 'parser'> & {
+  parser: ResolvedParser<any>;
+};
+//#endregion
+export { RouteStateSource as i, ResolvedRouteStateOptions as n, RouteStateOptions as r, HistoryMode as t };

package/dist/utils-EL2EiRpH.mjs

@@ -0,0 +1,79 @@
+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 { 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];
+	const { parsers } = getActiveWagen();
+	return Object.hasOwn(parsers, name) ? parsers[name] : void 0;
+}
+function fromParser(parser) {
+	const resolved = {
+		parse: parser.parse,
+		serialize: parser.serialize
+	};
+	if ("defaultValue" in parser) resolved.defaultValue = parser.defaultValue;
+	return resolved;
+}
+function fromName(name, override) {
+	let warned = false;
+	function get() {
+		const found = getParser(name);
+		if (found) return found;
+		if (!warned) {
+			warned = true;
+			warn(ErrorCodes.UNKNOWN_PARSER_NAME, name);
+		}
+		return parseAsString;
+	}
+	const base = {
+		parse: (raw) => get().parse(raw),
+		serialize: (value) => get().serialize(value)
+	};
+	if (override) return {
+		...base,
+		defaultValue: override.defaultValue
+	};
+	return {
+		...base,
+		get defaultValue() {
+			return get().defaultValue;
+		}
+	};
+}
+function resolveParser(input = { name: "parseAsString" }) {
+	if ("parse" in input) return fromParser(input);
+	const override = "defaultValue" in input ? { defaultValue: input.defaultValue } : void 0;
+	return fromName(input.name, override);
+}
+//#endregion
+//#region src/parser/utils.ts
+function normalizeRaw(raw) {
+	return (Array.isArray(raw) ? raw.find((v) => v != null) : raw) ?? null;
+}
+function parseValue(parser, raw) {
+	const value = normalizeRaw(raw);
+	if (value === null) return parser.defaultValue !== void 0 ? unwrapDefault(parser.defaultValue) : null;
+	const parsed = parser.parse(value);
+	if (parsed !== null) return parsed;
+	return parser.defaultValue !== void 0 ? unwrapDefault(parser.defaultValue) : null;
+}
+function serializeValue(parser, clearOnDefault, next) {
+	if (next == null) return null;
+	const serialized = parser.serialize(next);
+	if (clearOnDefault && parser.defaultValue !== void 0) {
+		if (serialized === parser.serialize(unwrapDefault(parser.defaultValue))) return null;
+	}
+	return serialized;
+}
+//#endregion
+export { toValueDeep as a, resolveParser as i, parseValue as n, serializeValue as r, normalizeRaw as t };

package/dist/vite/index.d.mts

@@ -0,0 +1,19 @@
+import { Plugin } from "vite";
+//#region src/vite/index.d.ts
+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'
+   */
+  dirs?: string | string[];
+  /**
+   * Output path for the generated `.d.ts` file, or `false` to disable.
+   * @default 'usewagen.d.ts'
+   */
+  dts?: string | false;
+}
+export declare function usewagen(options?: WagenPluginOptions): Plugin;
+//#endregion
+export { usewagen as default };

package/dist/vite/index.mjs

@@ -0,0 +1,230 @@
+import { g as warn, h as ErrorCodes } from "../parsers-CA8aZuF-.mjs";
+import { n as isBuiltinParserName } from "../builtins-DiCjLgsG.mjs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+//#region src/vite/generate.ts
+const BANNER = "// Auto-generated by usewagen/vite — do not edit";
+function toPosix(path) {
+	return path.split(sep).join("/");
+}
+function toSpecifier(from, file) {
+	const target = relative(from, file);
+	const specifier = toPosix(join(dirname(target), basename(target, extname(target))));
+	return specifier.startsWith(".") ? specifier : `./${specifier}`;
+}
+function generateModule(entries) {
+	const byFile = /* @__PURE__ */ new Map();
+	for (const { name, file } of entries) {
+		const names = byFile.get(file) ?? [];
+		names.push(name);
+		byFile.set(file, names);
+	}
+	const lines = [BANNER];
+	for (const [file, names] of byFile) lines.push(`import { ${names.join(", ")} } from ${JSON.stringify(toPosix(file))}`);
+	lines.push("");
+	if (entries.length === 0) {
+		lines.push("export const parsers = {}", "");
+		return lines.join("\n");
+	}
+	lines.push("export const parsers = {");
+	for (const { name } of entries) lines.push(`  ${name},`);
+	lines.push("}", "");
+	return lines.join("\n");
+}
+function generateDeclaration(entries, dtsPath) {
+	const dtsDir = dirname(dtsPath);
+	const lines = [
+		BANNER,
+		"/// <reference types=\"usewagen/client\" />",
+		"export {}",
+		"",
+		"declare module 'usewagen' {",
+		"  interface CustomParsers {"
+	];
+	for (const { name, file } of entries) lines.push(`    ${name}: typeof import('${toSpecifier(dtsDir, file)}')['${name}']`);
+	lines.push("  }", "}", "");
+	return lines.join("\n");
+}
+//#endregion
+//#region src/vite/strip.ts
+const DIVISION_PRECEDING = /[\w$)\]]/;
+function stripNonCode(source) {
+	let output = "";
+	let index = 0;
+	let previous = "";
+	const push = (char) => {
+		output += char;
+		if (!/\s/.test(char)) previous = char;
+	};
+	while (index < source.length) {
+		const char = source[index];
+		const next = source[index + 1];
+		if (char === "/" && next === "/") {
+			while (index < source.length && source[index] !== "\n") index++;
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			index += 2;
+			while (index < source.length && !(source[index] === "*" && source[index + 1] === "/")) {
+				if (source[index] === "\n") output += "\n";
+				index++;
+			}
+			index += 2;
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") {
+			index++;
+			while (index < source.length && source[index] !== char) {
+				if (source[index] === "\\") index++;
+				index++;
+			}
+			index++;
+			push(char);
+			continue;
+		}
+		if (char === "/" && !DIVISION_PRECEDING.test(previous)) {
+			index++;
+			let inClass = false;
+			while (index < source.length && source[index] !== "\n") {
+				const current = source[index];
+				if (current === "\\") {
+					index += 2;
+					continue;
+				}
+				if (current === "[") inClass = true;
+				else if (current === "]") inClass = false;
+				else if (current === "/" && !inClass) break;
+				index++;
+			}
+			index++;
+			previous = "/";
+			continue;
+		}
+		push(char);
+		index++;
+	}
+	return output;
+}
+//#endregion
+//#region src/vite/scan.ts
+const MODULE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".js",
+	".mjs",
+	".ts",
+	".mts"
+]);
+const DECLARATION_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".mts"]);
+const PARSER_EXPORT = /export\s+const\s+(parseAs\w+)/g;
+function isDeclarationFile(name, extension) {
+	return DECLARATION_EXTENSIONS.has(extension) && basename(name, extension).endsWith(".d");
+}
+function isParserFile(name) {
+	const extension = extname(name);
+	return MODULE_EXTENSIONS.has(extension) && !isDeclarationFile(name, extension);
+}
+function extractNames(file) {
+	const source = stripNonCode(readFileSync(file, "utf-8"));
+	const names = [];
+	PARSER_EXPORT.lastIndex = 0;
+	let match;
+	while ((match = PARSER_EXPORT.exec(source)) !== null) {
+		const name = match[1];
+		if (isBuiltinParserName(name)) {
+			warn(ErrorCodes.RESERVED_PARSER_NAME, name, file);
+			continue;
+		}
+		names.push(name);
+	}
+	return names;
+}
+function walk(dir, entries) {
+	if (!existsSync(dir)) return;
+	for (const item of readdirSync(dir, { withFileTypes: true })) {
+		if (item.isDirectory()) {
+			walk(resolve(dir, item.name), entries);
+			continue;
+		}
+		if (!isParserFile(item.name)) continue;
+		const file = resolve(dir, item.name);
+		for (const name of extractNames(file)) entries.push({
+			name,
+			file
+		});
+	}
+}
+function dedupe(entries) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const previous = byName.get(entry.name);
+		if (previous) warn(ErrorCodes.DUPLICATE_PARSER_NAME, entry.name, previous.file, entry.file);
+		byName.set(entry.name, entry);
+	}
+	return [...byName.values()];
+}
+function scanParsers(dirs) {
+	const entries = [];
+	for (const dir of dirs) walk(dir, entries);
+	return dedupe(entries);
+}
+//#endregion
+//#region src/vite/index.ts
+const PARSERS_ID = "virtual:usewagen/parsers";
+const RESOLVED_PARSERS_ID = `\0${PARSERS_ID}`;
+function contains(dir, path) {
+	const target = relative(dir, path);
+	return !isAbsolute(target) && !target.startsWith(`..${sep}`);
+}
+function usewagen(options = {}) {
+	const { dirs: rawDirs = "src/parsers", dts = "usewagen.d.ts" } = options;
+	let dirs = [];
+	let dtsPath = "";
+	let entries = null;
+	function scan() {
+		entries ??= scanParsers(dirs);
+		return entries;
+	}
+	function writeDeclaration() {
+		if (dts === false) return;
+		const content = generateDeclaration(scan(), dtsPath);
+		const dir = dirname(dtsPath);
+		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+		if ((existsSync(dtsPath) ? readFileSync(dtsPath, "utf-8") : "") !== content) writeFileSync(dtsPath, content, "utf-8");
+	}
+	function isScanned(path) {
+		return dirs.some((dir) => contains(dir, path)) && isParserFile(basename(path));
+	}
+	return {
+		name: "usewagen",
+		configResolved(config) {
+			dirs = (Array.isArray(rawDirs) ? rawDirs : [rawDirs]).map((dir) => resolve(config.root, dir));
+			if (dts !== false) dtsPath = resolve(config.root, dts);
+			entries = null;
+			writeDeclaration();
+		},
+		resolveId(id) {
+			if (id === "virtual:usewagen/parsers") return RESOLVED_PARSERS_ID;
+		},
+		load(id) {
+			if (id !== RESOLVED_PARSERS_ID) return;
+			const found = scan();
+			for (const dir of dirs) this.addWatchFile(dir);
+			for (const { file } of found) this.addWatchFile(file);
+			return generateModule(found);
+		},
+		configureServer(server) {
+			for (const dir of dirs) server.watcher.add(dir);
+			server.watcher.on("all", (event, path) => {
+				if (event !== "add" && event !== "unlink" && event !== "change") return;
+				if (!isScanned(path)) return;
+				entries = null;
+				writeDeclaration();
+				const mod = server.moduleGraph.getModuleById(RESOLVED_PARSERS_ID);
+				if (!mod) return;
+				server.moduleGraph.invalidateModule(mod);
+				server.ws.send({ type: "full-reload" });
+			});
+		}
+	};
+}
+//#endregion
+export { PARSERS_ID, RESOLVED_PARSERS_ID, usewagen as default, usewagen };