usewagen 0.0.0 → 0.1.0

package/dist/storage/index.mjs

@@ -0,0 +1,84 @@
+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 { 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() {
+		const source = options.storage;
+		if (source && typeof source !== "string") return source;
+		const { storage } = getActiveWagen();
+		return source ? storage[source] : storage.default;
+	}
+	return {
+		key,
+		get storage() {
+			return storage();
+		},
+		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);
+		},
+		remove: () => storage().removeItem(key),
+		subscribe: (listener) => storage().subscribe(key, listener)
+	};
+}
+//#endregion
+//#region src/storage/use-storage.ts
+function isStorageState(input) {
+	return typeof input === "object" && input !== null && typeof input.get === "function";
+}
+function withResolvedStorage(options, wagen) {
+	const source = options.storage;
+	if (source && typeof source !== "string") return options;
+	return {
+		...options,
+		storage: source ? wagen.storage[source] : wagen.storage.default
+	};
+}
+function useStorageState(input) {
+	if (isStorageState(input)) return computed(() => input);
+	const wagen = getActiveWagen();
+	return computed(() => defineStorageState(withResolvedStorage(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-CNt2lcP1.d.mts

@@ -0,0 +1,60 @@
+//#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 InferInputValue<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
+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 };

package/dist/types-CuwASQTi.d.mts

@@ -0,0 +1,24 @@
+import { c as DefaultValue, s as ParserInput } from "./types-CNt2lcP1.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;
+}
+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-B-885gDp.mjs

@@ -0,0 +1,76 @@
+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 { 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 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);
+	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 i, serializeValue as n, resolveParser as r, parseValue as t };

package/dist/vite/index.d.mts

@@ -0,0 +1,19 @@
+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 {
+  /**
+   * 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;
+}
+declare function usewagen(options?: WagenPluginOptions): Plugin;
+//#endregion
+export { PARSERS_ID, RESOLVED_PARSERS_ID, WagenPluginOptions, usewagen as default, usewagen };

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 };