@victorylabs/params 0.1.0

package/dist/storage/url.js

@@ -0,0 +1,100 @@
+import {
+  defaultSerialize
+} from "../chunk-NUO3GOXV.js";
+
+// src/storage/url/index.ts
+var isClient = typeof window !== "undefined";
+function urlStorage(options = {}) {
+  const adapterStrategy = options.strategy ?? "replace";
+  const paramMap = options.paramMap ?? {};
+  const reverseMap = buildReverseMap(paramMap);
+  const serialize = options.serialize ?? {};
+  const deserialize = options.deserialize ?? {};
+  const readImpl = () => {
+    if (!isClient) return void 0;
+    try {
+      const params = new URLSearchParams(window.location.search);
+      const partial = {};
+      let hasAny = false;
+      for (const [paramKey, raw] of params.entries()) {
+        const formPath = reverseMap[paramKey] ?? paramKey;
+        const deserializer = deserialize[formPath];
+        try {
+          partial[formPath] = deserializer ? deserializer(raw) : raw;
+          hasAny = true;
+        } catch {
+        }
+      }
+      return hasAny ? partial : void 0;
+    } catch {
+      return void 0;
+    }
+  };
+  const updateUrl = (params, opts) => {
+    if (!isClient) return;
+    const search = params.toString();
+    const url = search ? `${window.location.pathname}?${search}` : window.location.pathname;
+    const strategy = opts?.history ?? adapterStrategy;
+    try {
+      if (strategy === "push") {
+        window.history.pushState(null, "", url);
+      } else {
+        window.history.replaceState(null, "", url);
+      }
+    } catch {
+    }
+  };
+  return {
+    name: "urlStorage",
+    clientOnly: true,
+    read: readImpl,
+    write: (values, _changed, opts) => {
+      if (!isClient) return;
+      const params = new URLSearchParams(window.location.search);
+      for (const [path, value] of Object.entries(values)) {
+        const paramKey = paramMap[path] ?? path;
+        if (value === void 0 || value === null) {
+          params.delete(paramKey);
+          continue;
+        }
+        const serializer = serialize[path];
+        const str = serializer ? serializer(value) : defaultSerialize(value);
+        params.set(paramKey, str);
+      }
+      updateUrl(params, opts);
+    },
+    clear: (paths, opts) => {
+      if (!isClient) return;
+      if (paths.length === 0) {
+        updateUrl(new URLSearchParams(), opts);
+        return;
+      }
+      const params = new URLSearchParams(window.location.search);
+      for (const path of paths) {
+        const paramKey = paramMap[path] ?? path;
+        params.delete(paramKey);
+      }
+      updateUrl(params, opts);
+    },
+    subscribe: (callback) => {
+      if (!isClient) return () => void 0;
+      const handler = () => {
+        const values = readImpl();
+        if (values) callback(values);
+      };
+      window.addEventListener("popstate", handler);
+      return () => window.removeEventListener("popstate", handler);
+    }
+  };
+}
+function buildReverseMap(map) {
+  const reverse = {};
+  for (const [formPath, paramKey] of Object.entries(map)) {
+    reverse[paramKey] = formPath;
+  }
+  return reverse;
+}
+export {
+  urlStorage
+};
+//# sourceMappingURL=url.js.map

package/dist/storage/url.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/storage/url/index.ts"],"sourcesContent":["import { defaultSerialize } from '../../schema'\nimport type { ParamsStorage, WriteOptions } from '../../storage'\n\nexport interface UrlStorageOptions {\n  /**\n   * History API strategy. `'replace'` keeps the back-stack clean (recommended\n   * for filters/search). `'push'` creates a new history entry for every write.\n   * Default: `'replace'`.\n   */\n  readonly strategy?: 'replace' | 'push'\n\n  /** form path → URL search-param key. Defaults to identity. */\n  readonly paramMap?: Record<string, string>\n\n  /** Per-path string serializer. Default: `defaultSerialize` (same as schema). */\n  readonly serialize?: Record<string, (value: unknown) => string>\n\n  /** Per-path string-to-value deserializer. Default: identity (raw string). */\n  readonly deserialize?: Record<string, (str: string) => unknown>\n}\n\nconst isClient = typeof window !== 'undefined'\n\n/**\n * URL search-param storage backend (native History API).\n *\n * - Hydrates from `window.location.search` on store creation.\n * - Reflects writes back to the URL via `replaceState` (default) or `pushState`.\n * - Subscribes to `popstate` so back/forward navigation flows into the store.\n *\n * `omitWhenDefault` is honored at the engine level (the store sends `undefined`\n * for paths at default; the backend deletes them from the URL).\n *\n * Limitations (v0.1):\n *  - History API only — `hashchange` not supported.\n *  - Cross-tab URL sync not supported (History API is per-tab).\n *\n * v0.4: per-call strategy override via `WriteOptions.history` — store callers\n * can pass `params.set(path, value, { history: 'push' })` to override the\n * adapter-level default for that single write.\n */\nexport function urlStorage<T = Record<string, unknown>>(\n  options: UrlStorageOptions = {},\n): ParamsStorage<T> {\n  const adapterStrategy = options.strategy ?? 'replace'\n  const paramMap = options.paramMap ?? {}\n  const reverseMap = buildReverseMap(paramMap)\n  const serialize = options.serialize ?? {}\n  const deserialize = options.deserialize ?? {}\n\n  const readImpl = (): Partial<T> | undefined => {\n    if (!isClient) return undefined\n    try {\n      const params = new URLSearchParams(window.location.search)\n      const partial: Record<string, unknown> = {}\n      let hasAny = false\n      for (const [paramKey, raw] of params.entries()) {\n        const formPath = reverseMap[paramKey] ?? paramKey\n        const deserializer = deserialize[formPath]\n        try {\n          partial[formPath] = deserializer ? deserializer(raw) : raw\n          hasAny = true\n        } catch {\n          // Per-path deserialize failure → skip; engine falls back to default\n        }\n      }\n      return hasAny ? (partial as Partial<T>) : undefined\n    } catch {\n      return undefined\n    }\n  }\n\n  const updateUrl = (params: URLSearchParams, opts?: WriteOptions): void => {\n    if (!isClient) return\n    const search = params.toString()\n    const url = search ? `${window.location.pathname}?${search}` : window.location.pathname\n    const strategy = opts?.history ?? adapterStrategy\n    try {\n      if (strategy === 'push') {\n        window.history.pushState(null, '', url)\n      } else {\n        window.history.replaceState(null, '', url)\n      }\n    } catch {\n      // Some browsers cap History API writes (rare) — silent fallback.\n    }\n  }\n\n  return {\n    name: 'urlStorage',\n    clientOnly: true,\n    read: readImpl,\n    write: (values, _changed, opts) => {\n      if (!isClient) return\n      const params = new URLSearchParams(window.location.search)\n      for (const [path, value] of Object.entries(values as Record<string, unknown>)) {\n        const paramKey = paramMap[path] ?? path\n        if (value === undefined || value === null) {\n          params.delete(paramKey)\n          continue\n        }\n        const serializer = serialize[path]\n        const str = serializer ? serializer(value) : defaultSerialize(value)\n        params.set(paramKey, str)\n      }\n      updateUrl(params, opts)\n    },\n    clear: (paths, opts) => {\n      if (!isClient) return\n      if (paths.length === 0) {\n        updateUrl(new URLSearchParams(), opts)\n        return\n      }\n      const params = new URLSearchParams(window.location.search)\n      for (const path of paths) {\n        const paramKey = paramMap[path] ?? path\n        params.delete(paramKey)\n      }\n      updateUrl(params, opts)\n    },\n    subscribe: (callback) => {\n      if (!isClient) return () => undefined\n      const handler = () => {\n        const values = readImpl()\n        if (values) callback(values)\n      }\n      window.addEventListener('popstate', handler)\n      return () => window.removeEventListener('popstate', handler)\n    },\n  }\n}\n\nfunction buildReverseMap(map: Record<string, string>): Record<string, string> {\n  const reverse: Record<string, string> = {}\n  for (const [formPath, paramKey] of Object.entries(map)) {\n    reverse[paramKey] = formPath\n  }\n  return reverse\n}\n"],"mappings":"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","names":[]}

package/dist/storage-DBLIRR-4.d.cts

@@ -0,0 +1,59 @@
+/**
+ * Per-call write/clear options. Backends opt-in to the fields that apply to
+ * them — `urlStorage` reads `history`; other backends ignore the field.
+ */
+interface WriteOptions {
+    /**
+     * History API strategy override for URL-like backends. When set, takes
+     * precedence over the adapter's construction-time `strategy`. Strongest-wins
+     * across batched writes (`'push'` beats `'replace'`).
+     */
+    readonly history?: 'push' | 'replace';
+}
+/**
+ * ParamsStorage — bidirectional bridge between the in-memory state container
+ * and an external source (URL, localStorage, sessionStorage, server, …).
+ *
+ * Storage interface is **public + stable**. Custom backends (IndexedDB,
+ * cookies, server) implement this directly. Built-in backends (memory, URL,
+ * local, session) are reference implementations.
+ */
+interface ParamsStorage<T = Record<string, unknown>> {
+    /** Identifier — used in dev warnings and devtools. */
+    readonly name: string;
+    /**
+     * Skip on server (no `window`). URL / localStorage / sessionStorage all set
+     * this to `true`. Memory storage leaves it unset.
+     */
+    readonly clientOnly?: boolean;
+    /**
+     * Synchronous read. Memory, URL, localStorage all return values immediately.
+     * Returning `undefined` means "no stored values" — engine uses defaults.
+     * Read failures (corrupted JSON, parse errors) should fall back to undefined
+     * silently; the engine surfaces them via `params.store.storageErrors`.
+     */
+    read(): Partial<T> | undefined;
+    /** Async read — for backends that need it (server, IndexedDB). v0.2. */
+    readAsync?(): Promise<Partial<T> | undefined>;
+    /**
+     * Persist a write. `changed` lists paths whose values updated since the
+     * last write — backends MAY use it for selective persistence. `options`
+     * carries per-call overrides (e.g. URL history strategy); backends that
+     * don't recognize a field SHOULD ignore it silently.
+     *
+     * Write failures (quota exceeded, History API rejected, storage unavailable)
+     * should be swallowed silently — params always have a usable in-memory
+     * value; consumer code never has to handle storage I/O exceptions.
+     */
+    write(values: Partial<T>, changed: string[], options?: WriteOptions): void | Promise<void>;
+    /**
+     * Subscribe to external changes (popstate, storage events, server pushes).
+     * The engine handles loop prevention via deep-equal-against-last-written;
+     * adapters should fire callbacks for genuinely external changes.
+     */
+    subscribe?(callback: (values: Partial<T>) => void): () => void;
+    /** Invoked by `params.reset()`. Removes the storage representation. */
+    clear?(paths: string[], options?: WriteOptions): void | Promise<void>;
+}
+
+export type { ParamsStorage as P, WriteOptions as W };

package/dist/storage-DBLIRR-4.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Per-call write/clear options. Backends opt-in to the fields that apply to
+ * them — `urlStorage` reads `history`; other backends ignore the field.
+ */
+interface WriteOptions {
+    /**
+     * History API strategy override for URL-like backends. When set, takes
+     * precedence over the adapter's construction-time `strategy`. Strongest-wins
+     * across batched writes (`'push'` beats `'replace'`).
+     */
+    readonly history?: 'push' | 'replace';
+}
+/**
+ * ParamsStorage — bidirectional bridge between the in-memory state container
+ * and an external source (URL, localStorage, sessionStorage, server, …).
+ *
+ * Storage interface is **public + stable**. Custom backends (IndexedDB,
+ * cookies, server) implement this directly. Built-in backends (memory, URL,
+ * local, session) are reference implementations.
+ */
+interface ParamsStorage<T = Record<string, unknown>> {
+    /** Identifier — used in dev warnings and devtools. */
+    readonly name: string;
+    /**
+     * Skip on server (no `window`). URL / localStorage / sessionStorage all set
+     * this to `true`. Memory storage leaves it unset.
+     */
+    readonly clientOnly?: boolean;
+    /**
+     * Synchronous read. Memory, URL, localStorage all return values immediately.
+     * Returning `undefined` means "no stored values" — engine uses defaults.
+     * Read failures (corrupted JSON, parse errors) should fall back to undefined
+     * silently; the engine surfaces them via `params.store.storageErrors`.
+     */
+    read(): Partial<T> | undefined;
+    /** Async read — for backends that need it (server, IndexedDB). v0.2. */
+    readAsync?(): Promise<Partial<T> | undefined>;
+    /**
+     * Persist a write. `changed` lists paths whose values updated since the
+     * last write — backends MAY use it for selective persistence. `options`
+     * carries per-call overrides (e.g. URL history strategy); backends that
+     * don't recognize a field SHOULD ignore it silently.
+     *
+     * Write failures (quota exceeded, History API rejected, storage unavailable)
+     * should be swallowed silently — params always have a usable in-memory
+     * value; consumer code never has to handle storage I/O exceptions.
+     */
+    write(values: Partial<T>, changed: string[], options?: WriteOptions): void | Promise<void>;
+    /**
+     * Subscribe to external changes (popstate, storage events, server pushes).
+     * The engine handles loop prevention via deep-equal-against-last-written;
+     * adapters should fire callbacks for genuinely external changes.
+     */
+    subscribe?(callback: (values: Partial<T>) => void): () => void;
+    /** Invoked by `params.reset()`. Removes the storage representation. */
+    clear?(paths: string[], options?: WriteOptions): void | Promise<void>;
+}
+
+export type { ParamsStorage as P, WriteOptions as W };

package/dist/types-BSWKH-jw.d.cts

@@ -0,0 +1,68 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { P as ParamsStorage } from './storage-DBLIRR-4.cjs';
+
+/**
+ * Plain field spec — for fields without a schema library. Provides a default
+ * value plus optional parse/serialize for storage round-tripping.
+ */
+interface PlainFieldSpec<T = unknown> {
+    default: T;
+    /** Storage string → typed value. Default: identity if T extends string. */
+    parse?: (raw: string) => T;
+    /** Typed value → storage string. Default: String(value). */
+    serialize?: (value: T) => string;
+}
+/**
+ * Field spec — a Zod / Standard Schema-compatible schema OR a plain spec.
+ * Each field MUST be able to produce a default value (either via schema's
+ * `.default()` or plain spec's `default:` field).
+ */
+type FieldSpec<T = unknown> = StandardSchemaV1<unknown, T> | PlainFieldSpec<T>;
+interface FieldConfig {
+    /** Trailing-edge debounce on store propagation (ms). 0 = no debounce. */
+    debounce?: number;
+    /**
+     * Strip the value from external storage when it deep-equals the field's
+     * default. Useful for keeping URLs clean (`?page=1` becomes empty when
+     * page is at default).
+     */
+    omitWhenDefault?: boolean;
+    /**
+     * Paths whose changes trigger this field's `onDepChange`. `'*'` means
+     * "every other field"; `excludeDeps` carves out exceptions. Resolved at
+     * cascade time, so adding fields to a definition doesn't invalidate
+     * `'*'` consumers.
+     */
+    dependsOn?: string[] | '*';
+    /**
+     * Paths to exclude from the `'*'` wildcard. Only meaningful when
+     * `dependsOn === '*'`. The field itself is always implicitly excluded.
+     */
+    excludeDeps?: string[];
+    /**
+     * What to do when a dep changes. `'reset'` restores default; `'clear'`
+     * sets to `undefined`; a function receives ALL dep values (changed +
+     * unchanged) plus the current value, and returns the new value.
+     */
+    onDepChange?: 'reset' | 'clear' | ((deps: Record<string, unknown>, current: unknown) => unknown);
+}
+interface ParamsConfig<T> {
+    /** Storage backend. Default: `memoryStorage()`. URL/local/session are opt-in. */
+    storage?: ParamsStorage<T>;
+    /** Per-field config keyed by field name. */
+    fields?: Record<string, FieldConfig>;
+    /**
+     * Optional definition name. Reserved for v0.2 SSR snapshot keys. Stored
+     * for forward-compat; in v0.1 it has no runtime behavior except a dev-mode
+     * warning when two definitions share a name.
+     */
+    name?: string;
+}
+interface ParamsDefinition<T = Record<string, unknown>> {
+    readonly name: string | undefined;
+    readonly spec: Readonly<Record<string, FieldSpec>>;
+    readonly storage: ParamsStorage<T>;
+    readonly fields: Readonly<Record<string, FieldConfig>>;
+}
+
+export type { FieldSpec as F, ParamsConfig as P, ParamsDefinition as a, PlainFieldSpec as b, FieldConfig as c };

package/dist/types-BUmNpSyP.d.ts

@@ -0,0 +1,68 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { P as ParamsStorage } from './storage-DBLIRR-4.js';
+
+/**
+ * Plain field spec — for fields without a schema library. Provides a default
+ * value plus optional parse/serialize for storage round-tripping.
+ */
+interface PlainFieldSpec<T = unknown> {
+    default: T;
+    /** Storage string → typed value. Default: identity if T extends string. */
+    parse?: (raw: string) => T;
+    /** Typed value → storage string. Default: String(value). */
+    serialize?: (value: T) => string;
+}
+/**
+ * Field spec — a Zod / Standard Schema-compatible schema OR a plain spec.
+ * Each field MUST be able to produce a default value (either via schema's
+ * `.default()` or plain spec's `default:` field).
+ */
+type FieldSpec<T = unknown> = StandardSchemaV1<unknown, T> | PlainFieldSpec<T>;
+interface FieldConfig {
+    /** Trailing-edge debounce on store propagation (ms). 0 = no debounce. */
+    debounce?: number;
+    /**
+     * Strip the value from external storage when it deep-equals the field's
+     * default. Useful for keeping URLs clean (`?page=1` becomes empty when
+     * page is at default).
+     */
+    omitWhenDefault?: boolean;
+    /**
+     * Paths whose changes trigger this field's `onDepChange`. `'*'` means
+     * "every other field"; `excludeDeps` carves out exceptions. Resolved at
+     * cascade time, so adding fields to a definition doesn't invalidate
+     * `'*'` consumers.
+     */
+    dependsOn?: string[] | '*';
+    /**
+     * Paths to exclude from the `'*'` wildcard. Only meaningful when
+     * `dependsOn === '*'`. The field itself is always implicitly excluded.
+     */
+    excludeDeps?: string[];
+    /**
+     * What to do when a dep changes. `'reset'` restores default; `'clear'`
+     * sets to `undefined`; a function receives ALL dep values (changed +
+     * unchanged) plus the current value, and returns the new value.
+     */
+    onDepChange?: 'reset' | 'clear' | ((deps: Record<string, unknown>, current: unknown) => unknown);
+}
+interface ParamsConfig<T> {
+    /** Storage backend. Default: `memoryStorage()`. URL/local/session are opt-in. */
+    storage?: ParamsStorage<T>;
+    /** Per-field config keyed by field name. */
+    fields?: Record<string, FieldConfig>;
+    /**
+     * Optional definition name. Reserved for v0.2 SSR snapshot keys. Stored
+     * for forward-compat; in v0.1 it has no runtime behavior except a dev-mode
+     * warning when two definitions share a name.
+     */
+    name?: string;
+}
+interface ParamsDefinition<T = Record<string, unknown>> {
+    readonly name: string | undefined;
+    readonly spec: Readonly<Record<string, FieldSpec>>;
+    readonly storage: ParamsStorage<T>;
+    readonly fields: Readonly<Record<string, FieldConfig>>;
+}
+
+export type { FieldSpec as F, ParamsConfig as P, ParamsDefinition as a, PlainFieldSpec as b, FieldConfig as c };

package/package.json

@@ -0,0 +1,114 @@
+{
+  "name": "@victorylabs/params",
+  "version": "0.1.0",
+  "description": "Centralized view-state config (filters, sort, pagination, app config) with pluggable storage. Memory by default; URL/localStorage/sessionStorage opt-in. Single React hook DX, schema-validated reads, cross-component sharing.",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.js",
+      "require": "./dist/react.cjs"
+    },
+    "./storage/url": {
+      "types": "./dist/storage/url.d.ts",
+      "import": "./dist/storage/url.js",
+      "require": "./dist/storage/url.cjs"
+    },
+    "./storage/local": {
+      "types": "./dist/storage/local.d.ts",
+      "import": "./dist/storage/local.js",
+      "require": "./dist/storage/local.cjs"
+    },
+    "./storage/session": {
+      "types": "./dist/storage/session.d.ts",
+      "import": "./dist/storage/session.js",
+      "require": "./dist/storage/session.cjs"
+    },
+    "./storage/cookie": {
+      "types": "./dist/storage/cookie.d.ts",
+      "import": "./dist/storage/cookie.js",
+      "require": "./dist/storage/cookie.cjs"
+    },
+    "./storage/server": {
+      "types": "./dist/storage/server.d.ts",
+      "import": "./dist/storage/server.js",
+      "require": "./dist/storage/server.cjs"
+    },
+    "./storage/compose": {
+      "types": "./dist/storage/compose.d.ts",
+      "import": "./dist/storage/compose.js",
+      "require": "./dist/storage/compose.cjs"
+    },
+    "./storage/idb": {
+      "types": "./dist/storage/idb.d.ts",
+      "import": "./dist/storage/idb.js",
+      "require": "./dist/storage/idb.cjs"
+    },
+    "./snapshot": {
+      "types": "./dist/snapshot.d.ts",
+      "import": "./dist/snapshot.js",
+      "require": "./dist/snapshot.cjs"
+    },
+    "./integrations/forms": {
+      "types": "./dist/integrations/forms.d.ts",
+      "import": "./dist/integrations/forms.js",
+      "require": "./dist/integrations/forms.cjs"
+    },
+    "./integrations/forms-reverse": {
+      "types": "./dist/integrations/forms-reverse.d.ts",
+      "import": "./dist/integrations/forms-reverse.js",
+      "require": "./dist/integrations/forms-reverse.cjs"
+    },
+    "./devtools": {
+      "types": "./dist/devtools.d.ts",
+      "import": "./dist/devtools.js",
+      "require": "./dist/devtools.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@standard-schema/spec": "^1.0.0"
+  },
+  "devDependencies": {
+    "fake-indexeddb": "^6.0.0",
+    "zod": "^3.23.8",
+    "@victorylabs/forms": "0.1.0",
+    "@victorylabs/utils": "0.1.0"
+  },
+  "peerDependencies": {
+    "react": ">=18",
+    "zod": ">=3.23"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "zod": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check src"
+  }
+}