@victorylabs/params 0.1.0

package/dist/integrations/forms-reverse.cjs

@@ -0,0 +1,777 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react/integrations/forms-reverse/index.ts
+var forms_reverse_exports = {};
+__export(forms_reverse_exports, {
+  useFormToParamsSync: () => useFormToParamsSync
+});
+module.exports = __toCommonJS(forms_reverse_exports);
+var import_react = require("react");
+
+// src/dev.ts
+var isDev = (() => {
+  try {
+    return typeof process !== "undefined" && process?.env?.NODE_ENV !== "production";
+  } catch {
+    return false;
+  }
+})();
+var warned = /* @__PURE__ */ new Set();
+function warn(message) {
+  if (!isDev) return;
+  if (warned.has(message)) return;
+  warned.add(message);
+  console.warn(`[@victorylabs/params] ${message}`);
+}
+
+// ../utils/src/cascade.ts
+var DEPTH_CAP = 10;
+function resolveCascade(initialChanges, ctx) {
+  const changes = { ...initialChanges };
+  const warnings = [];
+  const working = { ...ctx.currentValues, ...initialChanges };
+  let frontier = new Set(Object.keys(initialChanges));
+  const visited = new Set(frontier);
+  let depth = 0;
+  while (frontier.size > 0) {
+    if (depth >= DEPTH_CAP) {
+      warnings.push(
+        `cascade depth cap (${DEPTH_CAP}) reached; stopping. Frontier: [${[...frontier].join(", ")}]. Likely a config error \u2014 check for accidental long chains.`
+      );
+      break;
+    }
+    const nextFrontier = /* @__PURE__ */ new Set();
+    for (const targetPath of ctx.allPaths) {
+      const config = ctx.fieldConfigs[targetPath];
+      if (!config?.onDepChange) continue;
+      if (frontier.has(targetPath)) continue;
+      const deps = resolveDeps(config, ctx.allPaths, targetPath);
+      const changedDeps = deps.filter((d) => frontier.has(d));
+      if (changedDeps.length === 0) continue;
+      if (visited.has(targetPath)) {
+        warnings.push(
+          `cycle detected: '${targetPath}' would cascade twice (triggered by [${changedDeps.join(", ")}]). Skipping re-entry.`
+        );
+        continue;
+      }
+      const newValue = applyDepChange(config.onDepChange, deps, working, ctx.defaults, targetPath);
+      if (Object.is(newValue, working[targetPath])) continue;
+      changes[targetPath] = newValue;
+      working[targetPath] = newValue;
+      visited.add(targetPath);
+      nextFrontier.add(targetPath);
+    }
+    frontier = nextFrontier;
+    depth++;
+  }
+  return { changes, warnings };
+}
+function resolveDeps(config, allPaths, selfPath) {
+  if (config.dependsOn === "*") {
+    const exclude = new Set(config.excludeDeps ?? []);
+    exclude.add(selfPath);
+    return allPaths.filter((p) => !exclude.has(p));
+  }
+  if (Array.isArray(config.dependsOn)) {
+    return config.dependsOn.filter((p) => p !== selfPath);
+  }
+  return [];
+}
+function applyDepChange(onDepChange, deps, working, defaults, targetPath) {
+  if (onDepChange === "reset") return defaults[targetPath];
+  if (onDepChange === "clear") return void 0;
+  const depsRecord = {};
+  for (const d of deps) {
+    depsRecord[d] = working[d];
+  }
+  return onDepChange(depsRecord, working[targetPath]);
+}
+
+// ../utils/src/deep.ts
+function splitPath(path) {
+  if (path === "") return [];
+  return path.split(".");
+}
+function deepGet(obj, path) {
+  const segments = splitPath(path);
+  let current = obj;
+  for (const seg of segments) {
+    if (current === null || current === void 0) return void 0;
+    if (Array.isArray(current)) {
+      const idx = Number(seg);
+      if (!Number.isInteger(idx) || idx < 0) return void 0;
+      current = current[idx];
+    } else if (typeof current === "object") {
+      current = current[seg];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function deepSet(obj, path, value) {
+  const segments = splitPath(path);
+  if (segments.length === 0) return value;
+  return setRecursive(obj, segments, 0, value);
+}
+function setRecursive(current, segments, i, value) {
+  const seg = segments[i];
+  if (seg === void 0) return value;
+  const isLast = i === segments.length - 1;
+  const idx = Number(seg);
+  const isNumericSeg = Number.isInteger(idx) && idx >= 0 && /^\d+$/.test(seg);
+  if (isNumericSeg) {
+    const arr = Array.isArray(current) ? current.slice() : [];
+    arr[idx] = isLast ? value : setRecursive(arr[idx], segments, i + 1, value);
+    return arr;
+  }
+  const next = current && typeof current === "object" && !Array.isArray(current) ? { ...current } : {};
+  next[seg] = isLast ? value : setRecursive(next[seg], segments, i + 1, value);
+  return next;
+}
+function deepEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== typeof b) return false;
+  if (a === null || b === null) return false;
+  if (typeof a !== "object") return false;
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b)) return false;
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  if (Array.isArray(b)) return false;
+  if (a instanceof Date) {
+    return b instanceof Date && a.getTime() === b.getTime();
+  }
+  if (b instanceof Date) return false;
+  if (a instanceof RegExp) {
+    return b instanceof RegExp && a.source === b.source && a.flags === b.flags;
+  }
+  if (b instanceof RegExp) return false;
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length) return false;
+  for (const key of aKeys) {
+    if (!Object.hasOwn(b, key)) return false;
+    if (!deepEqual(a[key], b[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// ../utils/src/path-trie.ts
+var makeNode = () => ({ listeners: /* @__PURE__ */ new Set(), children: /* @__PURE__ */ new Map() });
+var PathTrie = class {
+  root = makeNode();
+  subscribe(path, listener) {
+    const node = this.ensure(path);
+    node.listeners.add(listener);
+    return () => {
+      node.listeners.delete(listener);
+    };
+  }
+  notify(path) {
+    const segments = splitPath(path);
+    let current = this.root;
+    fire(current);
+    for (const seg of segments) {
+      const next = current.children.get(seg);
+      if (!next) return;
+      current = next;
+      fire(current);
+    }
+    fireSubtree(current);
+  }
+  /** Test/diagnostic helper — total subscriber count below a given path. */
+  size(path = "") {
+    const node = this.find(path);
+    if (!node) return 0;
+    return countSubtree(node);
+  }
+  ensure(path) {
+    let node = this.root;
+    for (const seg of splitPath(path)) {
+      let child = node.children.get(seg);
+      if (!child) {
+        child = makeNode();
+        node.children.set(seg, child);
+      }
+      node = child;
+    }
+    return node;
+  }
+  find(path) {
+    let node = this.root;
+    for (const seg of splitPath(path)) {
+      node = node?.children.get(seg);
+      if (!node) return void 0;
+    }
+    return node;
+  }
+};
+function fire(node) {
+  for (const listener of node.listeners) listener();
+}
+function fireSubtree(node) {
+  for (const child of node.children.values()) {
+    fire(child);
+    fireSubtree(child);
+  }
+}
+function countSubtree(node) {
+  let total = node.listeners.size;
+  for (const child of node.children.values()) {
+    total += countSubtree(child);
+  }
+  return total;
+}
+
+// src/name-registry.ts
+var preHydrationCache = /* @__PURE__ */ new Map();
+function takePreHydrationValues(name) {
+  if (name === void 0) return void 0;
+  if (!preHydrationCache.has(name)) return void 0;
+  return preHydrationCache.get(name);
+}
+
+// src/schema.ts
+function isStandardSchema(spec) {
+  return typeof spec === "object" && spec !== null && "~standard" in spec && typeof spec["~standard"] === "object";
+}
+function isPlainSpec(spec) {
+  return !isStandardSchema(spec) && typeof spec === "object" && spec !== null && "default" in spec;
+}
+function getDefault(spec) {
+  if (isStandardSchema(spec)) {
+    const result = spec["~standard"].validate(void 0);
+    if (result instanceof Promise) return void 0;
+    if ("value" in result && !result.issues) return result.value;
+    return void 0;
+  }
+  return spec.default;
+}
+function parseField(spec, raw) {
+  if (isStandardSchema(spec)) {
+    const result = spec["~standard"].validate(raw);
+    if (result instanceof Promise) {
+      return { ok: false, reason: "async-schema-not-supported-in-v0.1" };
+    }
+    if ("value" in result && !result.issues) return { ok: true, value: result.value };
+    return { ok: false, reason: result.issues?.[0]?.message ?? "parse-failed" };
+  }
+  const plainSpec = spec;
+  if (typeof raw === "string" && plainSpec.parse) {
+    try {
+      return { ok: true, value: plainSpec.parse(raw) };
+    } catch (err) {
+      return { ok: false, reason: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  if (raw === void 0) return { ok: false, reason: "undefined-no-parse" };
+  return { ok: true, value: raw };
+}
+function defaultSerialize(value) {
+  if (value === void 0 || value === null) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") return Number.isFinite(value) ? String(value) : "";
+  return JSON.stringify(value);
+}
+function extractEnumValues(spec) {
+  let current = spec;
+  for (let i = 0; i < 8 && current !== null && typeof current === "object"; i++) {
+    const def = current._def;
+    if (!def) return void 0;
+    if (Array.isArray(def.values)) return def.values;
+    if (typeof def.values === "object" && def.values !== null) {
+      const all = Object.values(def.values);
+      const hasNumber = all.some((v) => typeof v === "number");
+      return hasNumber ? all.filter((v) => typeof v === "number") : all;
+    }
+    if (def.innerType) {
+      current = def.innerType;
+      continue;
+    }
+    return void 0;
+  }
+  return void 0;
+}
+
+// src/params-store.ts
+var isClient = typeof window !== "undefined";
+var ParamsStore = class {
+  spec;
+  storage;
+  fieldConfigs;
+  values;
+  defaults;
+  trie = new PathTrie();
+  storageErrorMap = /* @__PURE__ */ new Map();
+  lastWritten;
+  storageUnsubscribe;
+  toQueryCache;
+  disposed = false;
+  constructor(def) {
+    this.spec = def.spec;
+    this.storage = def.storage;
+    this.fieldConfigs = def.fields;
+    this.defaults = this.computeDefaults();
+    this.values = { ...this.defaults };
+    const seeded = takePreHydrationValues(def.name);
+    if (seeded !== void 0) {
+      this.values = { ...this.defaults, ...seeded };
+    } else if (this.storage.clientOnly && !isClient) {
+    } else {
+      this.hydrateFromStorage();
+    }
+    if (this.storage.subscribe) {
+      this.storageUnsubscribe = this.storage.subscribe((raw) => this.onExternalChange(raw));
+    }
+  }
+  // ─── Reads (synchronous, framework-agnostic) ──────────────────────────
+  getValues() {
+    return this.values;
+  }
+  getValue(path) {
+    return deepGet(this.values, path);
+  }
+  /** Storage parse failures discovered on hydrate or external change. */
+  get storageErrors() {
+    const out = {};
+    for (const [path, reason] of this.storageErrorMap) out[path] = reason;
+    return out;
+  }
+  /** Per-field config (for the React adapter to read debounce settings, etc.). */
+  getFieldConfig(path) {
+    return this.fieldConfigs[path];
+  }
+  set(pathOrPartial, valueOrOptions, maybeOptions) {
+    if (this.disposed) return;
+    let updates;
+    let options;
+    if (typeof pathOrPartial === "string") {
+      updates = { [pathOrPartial]: valueOrOptions };
+      options = maybeOptions;
+    } else {
+      updates = pathOrPartial;
+      options = valueOrOptions;
+    }
+    const initialChanges = {};
+    for (const [path, v] of Object.entries(updates)) {
+      const old = deepGet(this.values, path);
+      if (deepEqual(old, v)) continue;
+      initialChanges[path] = v;
+    }
+    if (Object.keys(initialChanges).length === 0) return;
+    const cascade = resolveCascade(initialChanges, {
+      fieldConfigs: this.fieldConfigs,
+      defaults: this.defaults,
+      currentValues: this.values,
+      allPaths: Object.keys(this.spec)
+    });
+    for (const w of cascade.warnings) warn(w);
+    const changed = [];
+    let next = this.values;
+    for (const [path, v] of Object.entries(cascade.changes)) {
+      const old = deepGet(next, path);
+      if (deepEqual(old, v)) continue;
+      next = deepSet(next, path, v);
+      changed.push(path);
+    }
+    if (changed.length === 0) return;
+    this.values = next;
+    this.invalidateToQueryCache();
+    for (const path of changed) this.trie.notify(path);
+    this.persistToStorage(changed, options);
+  }
+  /** Boolean-flip helper. */
+  toggle(path, options) {
+    const current = this.getValue(path);
+    this.set(path, !current, options);
+  }
+  /** Push a value onto an array field. */
+  append(path, value, options) {
+    const current = this.getValue(path);
+    if (!Array.isArray(current)) return;
+    this.set(path, [...current, value], options);
+  }
+  /** Remove the first array element matching `value` by deepEqual. */
+  remove(path, value, options) {
+    const current = this.getValue(path);
+    if (!Array.isArray(current)) return;
+    const idx = current.findIndex((item) => deepEqual(item, value));
+    if (idx === -1) return;
+    this.set(path, [...current.slice(0, idx), ...current.slice(idx + 1)], options);
+  }
+  /** Remove the array element at the given index. */
+  removeAt(path, index, options) {
+    const current = this.getValue(path);
+    if (!Array.isArray(current)) return;
+    if (index < 0 || index >= current.length) return;
+    this.set(path, [...current.slice(0, index), ...current.slice(index + 1)], options);
+  }
+  cycle(path, valuesOrOptions, maybeOptions) {
+    let resolved;
+    let setOpts;
+    if (Array.isArray(valuesOrOptions)) {
+      resolved = valuesOrOptions;
+      setOpts = maybeOptions;
+    } else {
+      resolved = void 0;
+      setOpts = valuesOrOptions;
+    }
+    if (resolved === void 0) {
+      const fieldSpec = this.spec[path];
+      const derived = fieldSpec !== void 0 ? extractEnumValues(fieldSpec) : void 0;
+      if (!derived || derived.length === 0) {
+        throw new Error(
+          `Cannot derive enum values for params field '${path}'; pass values explicitly to cycle().`
+        );
+      }
+      resolved = derived;
+    }
+    if (resolved.length === 0) return;
+    const current = this.getValue(path);
+    const idx = resolved.findIndex((o) => deepEqual(o, current));
+    const next = idx === -1 ? resolved[0] : resolved[(idx + 1) % resolved.length];
+    this.set(path, next, setOpts);
+  }
+  /** Reset a single field to its default. */
+  clear(path, options) {
+    const def = deepGet(this.defaults, path);
+    this.set(path, def, options);
+  }
+  /** Reset all fields to defaults; optional partial overrides + SetOptions. */
+  reset(values, options) {
+    if (this.disposed) return;
+    const next = values ? { ...this.defaults, ...values } : { ...this.defaults };
+    const changed = Object.keys({ ...this.values, ...next });
+    this.values = next;
+    this.invalidateToQueryCache();
+    for (const path of changed) this.trie.notify(path);
+    const writeOptions = options?.history !== void 0 ? { history: options.history } : void 0;
+    void this.storage.clear?.([], writeOptions);
+    this.lastWritten = void 0;
+  }
+  // ─── Subscriptions ────────────────────────────────────────────────────
+  subscribe(path, listener) {
+    return this.trie.subscribe(path, listener);
+  }
+  // ─── URL helpers ──────────────────────────────────────────────────────
+  toQuery(overrides) {
+    const effective = overrides ? { ...this.values, ...overrides } : this.values;
+    if (!overrides && this.toQueryCache && this.toQueryCache.values === this.values) {
+      return this.toQueryCache.query;
+    }
+    const params = new URLSearchParams();
+    const keys = Object.keys(effective).sort();
+    for (const key of keys) {
+      const value = effective[key];
+      if (value === void 0 || value === null) continue;
+      const config = this.fieldConfigs[key];
+      const def = deepGet(this.defaults, key);
+      if (config?.omitWhenDefault && deepEqual(value, def)) continue;
+      params.set(key, defaultSerialize(value));
+    }
+    const str = params.toString();
+    const out = str ? `?${str}` : "";
+    if (!overrides) this.toQueryCache = { values: this.values, query: out };
+    return out;
+  }
+  href(overrides) {
+    if (!overrides) {
+      const query = this.toQuery();
+      const pathname2 = isClient ? window.location.pathname : "";
+      const cached = this.toQueryCache;
+      if (cached && cached.values === this.values && cached.href !== void 0) {
+        const expected = pathname2 + query;
+        if (cached.href === expected) return cached.href;
+      }
+      const out = pathname2 + query;
+      if (cached && cached.values === this.values) cached.href = out;
+      return out;
+    }
+    const pathname = isClient ? window.location.pathname : "";
+    return pathname + this.toQuery(overrides);
+  }
+  // ─── Disposal ─────────────────────────────────────────────────────────
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.storageUnsubscribe?.();
+    this.storageUnsubscribe = void 0;
+  }
+  // ─── Devtools / debugging escape hatch (v0.5) ─────────────────────────
+  /**
+   * Devtools / debugging escape hatch. Returns a frozen, defensive-copied
+   * snapshot of all internal state. Pure read — no side effects, no
+   * subscriptions registered.
+   *
+   * Uses `structuredClone` for the values + defaults deep-copy. Because
+   * params values round-trip through storage backends, they're already
+   * restricted to JSON-safe shapes — so `__introspect()` is safer here than
+   * on `FormStore`. Still: marked unstable via the `__` prefix; field set
+   * may grow over releases.
+   */
+  __introspect() {
+    const specTypes = {};
+    for (const [path, spec] of Object.entries(this.spec)) {
+      if (isPlainSpec(spec)) {
+        specTypes[path] = "plain";
+        continue;
+      }
+      if (spec?._def) {
+        specTypes[path] = "zod";
+        continue;
+      }
+      if (isStandardSchema(spec)) {
+        specTypes[path] = "standard-schema";
+        continue;
+      }
+      specTypes[path] = "plain";
+    }
+    let valuesClone;
+    let defaultsClone;
+    let lastWrittenClone;
+    try {
+      valuesClone = structuredClone(this.values);
+      defaultsClone = structuredClone(this.defaults);
+      lastWrittenClone = this.lastWritten ? structuredClone(this.lastWritten) : void 0;
+    } catch (err) {
+      throw new Error(
+        `ParamsStore.__introspect() failed: values contain non-cloneable data (functions, Symbols, DOM nodes are not allowed in params state). Original error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    return Object.freeze({
+      values: valuesClone,
+      defaults: defaultsClone,
+      fieldsConfigured: Object.freeze({ ...this.fieldConfigs }),
+      fieldsBySpecType: Object.freeze(specTypes),
+      storageErrors: Object.freeze({ ...this.storageErrors }),
+      storage: Object.freeze({
+        name: this.storage.name,
+        clientOnly: this.storage.clientOnly === true,
+        hasReadAsync: this.storage.readAsync !== void 0,
+        hasSubscribe: this.storage.subscribe !== void 0,
+        hasClear: this.storage.clear !== void 0
+      }),
+      lastWritten: lastWrittenClone
+    });
+  }
+  // ─── Internals ────────────────────────────────────────────────────────
+  computeDefaults() {
+    const out = {};
+    for (const [key, fieldSpec] of Object.entries(this.spec)) {
+      const def = getDefault(fieldSpec);
+      if (def !== void 0) out[key] = def;
+    }
+    return out;
+  }
+  hydrateFromStorage() {
+    let raw;
+    try {
+      raw = this.storage.read();
+    } catch (err) {
+      this.storageErrorMap.set("__read__", err instanceof Error ? err.message : String(err));
+      return;
+    }
+    if (!raw) return;
+    for (const [key, rawValue] of Object.entries(raw)) {
+      const fieldSpec = this.spec[key];
+      if (!fieldSpec) continue;
+      const result = parseField(fieldSpec, rawValue);
+      if (result.ok && result.value !== void 0) {
+        ;
+        this.values[key] = result.value;
+      } else if (result.reason) {
+        this.storageErrorMap.set(key, result.reason);
+      }
+    }
+  }
+  persistToStorage(changed, options) {
+    const filtered = {};
+    for (const path of changed) {
+      const value = this.values[path];
+      const config = this.fieldConfigs[path];
+      const def = deepGet(this.defaults, path);
+      if (config?.omitWhenDefault && deepEqual(value, def)) {
+        filtered[path] = void 0;
+      } else {
+        filtered[path] = value;
+      }
+    }
+    const writeOptions = options?.history !== void 0 ? { history: options.history } : void 0;
+    this.lastWritten = { ...this.values };
+    try {
+      const result = this.storage.write(filtered, changed, writeOptions);
+      if (result && typeof result.then === "function") {
+        ;
+        result.catch(() => void 0);
+      }
+    } catch {
+    }
+  }
+  onExternalChange(raw) {
+    if (this.disposed) return;
+    if (this.lastWritten && deepEqual(raw, this.lastWritten)) return;
+    const changed = [];
+    let next = this.values;
+    for (const [key, rawValue] of Object.entries(raw)) {
+      const fieldSpec = this.spec[key];
+      if (!fieldSpec) continue;
+      const result = parseField(fieldSpec, rawValue);
+      const newValue = result.ok ? result.value : deepGet(this.defaults, key);
+      const oldValue = deepGet(next, key);
+      if (deepEqual(oldValue, newValue)) continue;
+      next = deepSet(next, key, newValue);
+      changed.push(key);
+      if (!result.ok && result.reason) {
+        this.storageErrorMap.set(key, result.reason);
+      } else {
+        this.storageErrorMap.delete(key);
+      }
+    }
+    if (changed.length === 0) return;
+    this.values = next;
+    this.invalidateToQueryCache();
+    for (const path of changed) this.trie.notify(path);
+  }
+  invalidateToQueryCache() {
+    this.toQueryCache = void 0;
+  }
+};
+
+// src/store-cache.ts
+var cache = /* @__PURE__ */ new WeakMap();
+var seenNames = /* @__PURE__ */ new Map();
+function acquire(def) {
+  warnOnDuplicateName(def);
+  let entry = cache.get(def);
+  if (!entry) {
+    entry = {
+      store: new ParamsStore(def),
+      refCount: 0,
+      disposalQueued: false
+    };
+    cache.set(def, entry);
+  } else {
+    entry.disposalQueued = false;
+  }
+  entry.refCount++;
+  return entry.store;
+}
+function release(def) {
+  const entry = cache.get(def);
+  if (!entry) return;
+  entry.refCount--;
+  if (entry.refCount > 0) return;
+  entry.disposalQueued = true;
+  queueMicrotask(() => {
+    if (!entry.disposalQueued) return;
+    entry.disposalQueued = false;
+    disposeAndClear(def, entry);
+  });
+}
+function disposeAndClear(def, entry) {
+  entry.store.dispose();
+  cache.delete(def);
+  if (def.name !== void 0 && seenNames.get(def.name) === def) {
+    seenNames.delete(def.name);
+  }
+}
+function warnOnDuplicateName(def) {
+  if (def.name === void 0) return;
+  const existing = seenNames.get(def.name);
+  if (existing !== void 0 && existing !== def) {
+    warn(
+      `Duplicate definition name '${def.name}' detected. Names must be unique across definitions for v0.2 SSR snapshot keys.`
+    );
+    return;
+  }
+  seenNames.set(def.name, def);
+}
+
+// src/react/integrations/forms-reverse/index.ts
+var activeReverseBridges = /* @__PURE__ */ new WeakMap();
+function useFormToParamsSync(form, paramsDef) {
+  const lastPushedRef = (0, import_react.useRef)(void 0);
+  (0, import_react.useEffect)(() => {
+    const formStore = form.store;
+    const existing = activeReverseBridges.get(formStore);
+    if (existing && existing === paramsDef) {
+      throw new Error(
+        `useFormToParamsSync: this (form, paramsDef) pair is already bridged. Calling the hook twice for the same pair would cycle.`
+      );
+    }
+    if (existing && existing !== paramsDef) {
+      throw new Error(
+        "useFormToParamsSync: this form already has an active reverse bridge to a different params definition. Use one bridge per form."
+      );
+    }
+    activeReverseBridges.set(formStore, paramsDef);
+    const internalStore = formStore;
+    const entries = internalStore.syncEngine?.entries;
+    if (Array.isArray(entries)) {
+      const forwardName = `paramsToFormSync(${paramsDef.name ?? paramsDef.storage.name})`;
+      if (entries.some((e) => e?.adapter?.name === forwardName)) {
+        warn(
+          `useFormToParamsSync: form already has a paramsToFormSync(${paramsDef.name ?? paramsDef.storage.name}) adapter in its sync array. Pairing both directions on the same (form, paramsDef) creates a cycle.`
+        );
+      }
+    }
+    const paramsStore = acquire(paramsDef);
+    const push = () => {
+      const values = form.getValues();
+      const last = lastPushedRef.current;
+      if (last !== void 0 && deepEqualShallow(last, values)) return;
+      lastPushedRef.current = values;
+      paramsStore.set(values);
+    };
+    push();
+    const unsubscribe = formStore.subscribe("", push);
+    return () => {
+      unsubscribe();
+      release(paramsDef);
+      activeReverseBridges.delete(formStore);
+    };
+  }, [form, paramsDef]);
+}
+function deepEqualShallow(a, b) {
+  if (Object.is(a, b)) return true;
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") return false;
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length) return false;
+  for (const k of aKeys) {
+    if (!Object.is(a[k], b[k])) {
+      return false;
+    }
+  }
+  return true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useFormToParamsSync
+});
+//# sourceMappingURL=forms-reverse.cjs.map