attaform 0.20.2 → 0.21.1

package/dist/shared/{attaform.C5aYC_T8.mjs → attaform.DMEP_ENr.mjs}

@@ -1,6 +1,6 @@
-import { g as getAtPath, m as slimKindOf, k as setAtPath, h as humanize, o as useAbstractForm } from './attaform.tiWEVznj.mjs';
-import { a as AttaformError, _ as __DEV__, j as canonicalizePath, d as InvalidUseFormConfigError } from './attaform.QG5TG8lB.mjs';
-import { f as fieldMetaStore, g as getFieldMetaForSchema, a as getFieldMetaListForSchema, s as slimPrimitivesWalk, w as walkPathSegments, d as deriveDefaultWalk, m as mergeDeep, c as createAbstractSchema } from './attaform.BGk8cfw2.mjs';
+import { i as getAtPath, x as slimKindOf, w as setAtPath, j as humanize, B as useAbstractForm } from './attaform.DR6RmxWZ.mjs';
+import { a as AttaformError, _ as __DEV__, j as canonicalizePath, d as InvalidUseFormConfigError } from './attaform.pmtahXKy.mjs';
+import { f as fieldMetaStore, g as getFieldMetaForSchema, a as getFieldMetaListForSchema, s as slimPrimitivesWalk, w as walkPathSegments, d as deriveDefaultWalk, m as mergeDeep, c as createAbstractSchema, b as getFieldMetaPathMap } from './attaform.Be8NZG9M.mjs';
 import { z } from 'zod';
 
 const fieldMeta = fieldMetaStore;
@@ -514,207 +514,18 @@ function getDiscriminatedUnionFirstOption(schema) {
   return options[0];
 }
 
-const cyclicSentinel = "<cyclic>";
-function fingerprintZodSchema(schema) {
-  const cache = /* @__PURE__ */ new WeakMap();
-  const inProgress = /* @__PURE__ */ new WeakSet();
-  return visit(schema, cache, inProgress);
-}
-function visit(schema, cache, inProgress) {
-  const cached = cache.get(schema);
-  if (cached !== void 0) return cached;
-  if (inProgress.has(schema)) return cyclicSentinel;
-  inProgress.add(schema);
-  try {
-    const computed = computeFingerprint(schema, cache, inProgress);
-    cache.set(schema, computed);
-    return computed;
-  } finally {
-    inProgress.delete(schema);
-  }
-}
-function computeFingerprint(schema, cache, inProgress) {
-  const kind = kindOf(schema);
-  const recurse = (child) => visit(child, cache, inProgress);
-  switch (kind) {
-    // Kind-only leaves: no further structure to descend into.
-    case "boolean":
-    case "null":
-    case "undefined":
-    case "any":
-    case "unknown":
-    case "nan":
-    case "void":
-    case "never":
-      return kind;
-    // Leaves with checks (min/max/email/regex/...). Checks are
-    // canonicalised and sorted so `.min(3).max(10)` and `.max(10).min(3)`
-    // produce identical fingerprints.
-    case "string":
-    case "number":
-    case "bigint":
-    case "date":
-      return `${kind}${formatChecks(schema)}`;
-    case "literal": {
-      const values = [...getLiteralValues(schema)].sort((a, b) => {
-        const as = canonicalStringify(a);
-        const bs = canonicalStringify(b);
-        return as < bs ? -1 : as > bs ? 1 : 0;
-      });
-      return `literal:${canonicalStringify(values)}`;
-    }
-    case "enum":
-      return `enum:${canonicalStringify([...getEnumValues(schema)].sort((a, b) => compare(a, b)))}`;
-    case "object": {
-      const shape = getObjectShape(schema);
-      const sortedEntries = Object.entries(shape).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${recurse(v)}`);
-      return `object{${sortedEntries.join(",")}}${formatChecks(schema)}`;
-    }
-    case "array":
-      return `array[${recurse(getArrayElement(schema))}]${formatChecks(schema)}`;
-    case "set":
-      return `set<${recurse(getSetValueType(schema))}>${formatChecks(schema)}`;
-    case "tuple":
-      return `tuple[${getTupleItems(schema).map(recurse).join(",")}]`;
-    case "record":
-      return `record<${recurse(getRecordKeyType(schema))},${recurse(getRecordValueType(schema))}>`;
-    case "union": {
-      const options = getUnionOptions(schema).map(recurse).sort();
-      return `union(${options.join("|")})`;
-    }
-    case "discriminated-union": {
-      const disc = getDiscriminator(schema) ?? "?";
-      const options = getDiscriminatedOptions(schema).map(recurse).sort();
-      return `dunion[${JSON.stringify(disc)}](${options.join("|")})`;
-    }
-    case "optional": {
-      const inner = unwrapInner(schema);
-      return inner === void 0 ? "optional(?)" : `optional(${recurse(inner)})`;
-    }
-    case "nullable": {
-      const inner = unwrapInner(schema);
-      return inner === void 0 ? "nullable(?)" : `nullable(${recurse(inner)})`;
-    }
-    case "default": {
-      const inner = unwrapInner(schema);
-      return `default[${stableValueRepr(getDefaultValue, schema)}](${inner === void 0 ? "?" : recurse(inner)})`;
-    }
-    case "readonly": {
-      const inner = unwrapInner(schema);
-      return inner === void 0 ? "readonly(?)" : `readonly(${recurse(inner)})`;
-    }
-    case "pipe": {
-      const inner = unwrapPipe(schema);
-      return inner === void 0 ? "pipe(?)" : `pipe(${recurse(inner)})`;
-    }
-    case "catch": {
-      const inner = unwrapInner(schema);
-      return `catch[${stableValueRepr(getCatchDefault, schema)}](${inner === void 0 ? "?" : recurse(inner)})`;
-    }
-    case "lazy": {
-      const inner = unwrapLazy(schema);
-      return inner === void 0 ? "lazy(?)" : `lazy(${recurse(inner)})`;
-    }
-    case "intersection": {
-      const left = getIntersectionLeft(schema);
-      const right = getIntersectionRight(schema);
-      const leftFp = left === void 0 ? "?" : recurse(left);
-      const rightFp = right === void 0 ? "?" : recurse(right);
-      const parts = [leftFp, rightFp].sort();
-      return `intersection(${parts.join("&")})`;
-    }
-    // Structural shape isn't observable for these. Bucket them into
-    // kind-only fingerprints — a schema-mismatch warning can't do
-    // better than "both are `custom`" here, but that still catches
-    // `object` vs `custom` mismatches. `map` / `symbol` / `function`
-    // are rejected at adapter construction; kept here for exhaustive
-    // switch safety when `fingerprintSchema` is called from tooling.
-    case "promise":
-    case "custom":
-    case "template-literal":
-    case "transform":
-    case "file":
-    case "map":
-    case "symbol":
-    case "function":
-      return `${kind}:*`;
-    default: {
-      const _ = kind;
-      return `unknown:${String(_)}`;
-    }
-  }
-}
-function stableValueRepr(get, schema) {
-  const first = get(schema);
-  const second = get(schema);
-  if (!Object.is(first, second) || typeof first === "function") return "fn:*";
-  return canonicalStringify(first);
-}
-function formatChecks(schema) {
-  const checks = getChecks(schema);
-  if (checks.length === 0) return "";
-  const parts = checks.map((c) => serializeCheck(c)).sort();
-  return `[${parts.join(";")}]`;
-}
-function serializeCheck(check) {
-  if (check !== null && typeof check === "object") {
-    const def = check._zod?.def;
-    if (def !== void 0) return canonicalStringify(def);
-  }
-  return canonicalStringify(check);
-}
-function canonicalStringify(value, seen = /* @__PURE__ */ new WeakSet()) {
-  if (value === null) return "null";
-  if (value === void 0) return "undefined";
-  const t = typeof value;
-  if (t === "string") return JSON.stringify(value);
-  if (t === "number" || t === "boolean") return String(value);
-  if (t === "bigint") return `${String(value)}n`;
-  if (t === "function") return "fn:*";
-  if (t === "symbol") return "symbol:*";
-  if (Array.isArray(value)) {
-    if (seen.has(value)) return "<cyclic>";
-    seen.add(value);
-    try {
-      const parts = value.map((v) => canonicalStringify(v, seen));
-      return `[${parts.join(",")}]`;
-    } finally {
-      seen.delete(value);
-    }
-  }
-  if (t === "object") {
-    const obj = value;
-    if (seen.has(obj)) return "<cyclic>";
-    seen.add(obj);
-    try {
-      if (value instanceof Date) return `date:${value.getTime()}`;
-      if (value instanceof RegExp) return `regex:${String(value)}`;
-      const entries = Object.entries(obj).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${canonicalStringify(v, seen)}`);
-      return `{${entries.join(",")}}`;
-    } finally {
-      seen.delete(obj);
-    }
-  }
-  return "unknown";
-}
-function compare(a, b) {
-  const as = String(a);
-  const bs = String(b);
-  return as < bs ? -1 : as > bs ? 1 : 0;
-}
-
 const V4_INTROSPECTOR = {
   kindOf: (schema) => kindOf(schema),
   getObjectShape: (schema) => getObjectShape(schema),
-  getTupleItems: (schema) => getTupleItems(schema),
+  getTupleItems,
   getDiscriminatedOptions: (schema) => getDiscriminatedOptions(schema),
-  getDiscriminator: (schema) => getDiscriminator(schema),
-  getLiteralValues: (schema) => getLiteralValues(schema),
-  isPreprocessNode: (schema) => isPreprocessNode(schema),
-  isCoercePrimitive: (schema) => isCoercePrimitive(schema),
-  containsAsyncRefine: (schema) => containsAsyncRefine(schema),
-  containsAsyncTransform: (schema) => containsAsyncTransform(schema),
-  hasContainerOrRootRefine: (schema) => hasContainerOrRootRefine(schema),
+  getDiscriminator,
+  getLiteralValues,
+  isPreprocessNode,
+  isCoercePrimitive,
+  containsAsyncRefine,
+  containsAsyncTransform,
+  hasContainerOrRootRefine,
   // Walker accessors (D2 / D3 / D5).
   getArrayElement: (schema) => {
     if (kindOf(schema) !== "array") return void 0;
@@ -723,21 +534,21 @@ const V4_INTROSPECTOR = {
   getSetValueType: (schema) => kindOf(schema) === "set" ? getSetValueType(schema) : void 0,
   getRecordKeyType: (schema) => kindOf(schema) === "record" ? getRecordKeyType(schema) : void 0,
   getRecordValueType: (schema) => kindOf(schema) === "record" ? getRecordValueType(schema) : void 0,
-  getUnionOptions: (schema) => getUnionOptions(schema),
-  getIntersectionLeft: (schema) => getIntersectionLeft(schema),
-  getIntersectionRight: (schema) => getIntersectionRight(schema),
-  getEnumValues: (schema) => getEnumValues(schema),
-  getNativeEnumValues: (schema) => getNativeEnumValues(),
-  unwrapInner: (schema) => unwrapInner(schema),
-  unwrapBranded: (schema) => unwrapBranded(),
-  unwrapEffectsSource: (schema) => unwrapEffectsSource(),
-  unwrapPipeIn: (schema) => unwrapPipeIn(schema),
-  unwrapPipeOut: (schema) => unwrapPipeOut(schema),
-  unwrapLazy: (schema) => unwrapLazy(schema),
-  getLazyGetter: (schema) => getLazyGetter(schema),
-  getDefaultValue: (schema) => getDefaultValue(schema),
-  getCatchDefault: (schema) => getCatchDefault(schema),
-  hasCatchValue: (schema) => hasCatchValue(schema)
+  getUnionOptions,
+  getIntersectionLeft,
+  getIntersectionRight,
+  getEnumValues,
+  getNativeEnumValues,
+  unwrapInner,
+  unwrapBranded,
+  unwrapEffectsSource,
+  unwrapPipeIn,
+  unwrapPipeOut,
+  unwrapLazy,
+  getLazyGetter,
+  getDefaultValue,
+  getCatchDefault,
+  hasCatchValue
 };
 
 function slimPrimitivesOf(schema, maxRecursionDepth) {
@@ -1325,9 +1136,13 @@ function zodV4Adapter(rootSchema) {
     options
   );
 }
+async function lazyFingerprint(schema) {
+  const { fingerprintZodSchema } = await import('../chunks/fingerprint2.mjs');
+  return fingerprintZodSchema(schema);
+}
 function buildV4Services() {
   return {
-    fingerprint: (schema) => fingerprintZodSchema(schema),
+    fingerprint: (schema) => lazyFingerprint(schema),
     getNestedSchemasAtPath: (schema, path, maxRecursionDepth) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth),
     // v4 doesn't pre-strip for the slim-mode walk — its path walker
     // already peels every transparent wrapper inline, so the slim and
@@ -1384,7 +1199,7 @@ function runStrictGetDefaultsV4(rootSchema, config, formKey, maxRecursionDepth)
 }
 function buildSubSchemaStubV4(schema, formKey, maxRecursionDepth) {
   return {
-    fingerprint: () => fingerprintZodSchema(schema),
+    fingerprint: () => lazyFingerprint(schema),
     needsAsyncValidation: () => containsAsyncRefine(schema),
     getDefaultValues: () => ({
       data: deriveDefault(schema, true, maxRecursionDepth),
@@ -1412,178 +1227,6 @@ function buildSubSchemaStubV4(schema, formKey, maxRecursionDepth) {
     }
   };
 }
-const pathMetaCache = /* @__PURE__ */ new WeakMap();
-function getPathMetaMap(rootSchema) {
-  const cached = pathMetaCache.get(rootSchema);
-  if (cached !== void 0) return cached;
-  const map = /* @__PURE__ */ new Map();
-  const counters = /* @__PURE__ */ new Map();
-  const lastPathPerSchema = /* @__PURE__ */ new Map();
-  const inProgress = /* @__PURE__ */ new WeakSet();
-  walkForMeta(rootSchema, [], map, counters, lastPathPerSchema, inProgress);
-  for (const [schema, lastPath] of lastPathPerSchema) {
-    const list = getFieldMetaList(schema);
-    const consumed = counters.get(schema) ?? 0;
-    if (list.length <= consumed) continue;
-    const surplus = list.slice(consumed).reduce((acc, p) => ({ ...acc, ...p }), {});
-    const existing = map.get(lastPath) ?? {};
-    map.set(lastPath, { ...existing, ...surplus });
-  }
-  pathMetaCache.set(rootSchema, map);
-  return map;
-}
-function walkForMeta(schema, path, map, counters, lastPathPerSchema, inProgress) {
-  if (inProgress.has(schema)) return;
-  inProgress.add(schema);
-  try {
-    const pathKey = canonicalizePath(path).key;
-    if (!map.has(pathKey)) {
-      const payload = consumePayload(schema, counters);
-      if (payload !== void 0) {
-        map.set(pathKey, payload);
-        lastPathPerSchema.set(schema, pathKey);
-      }
-    }
-    const peeled = peelAllWrappers(schema);
-    if (peeled !== schema && !map.has(pathKey)) {
-      const payload = consumePayload(peeled, counters);
-      if (payload !== void 0) {
-        map.set(pathKey, payload);
-        lastPathPerSchema.set(peeled, pathKey);
-      }
-    }
-    const kind = kindOf(schema);
-    switch (kind) {
-      case "object": {
-        const shape = getObjectShape(schema);
-        for (const [key, child] of Object.entries(shape)) {
-          walkForMeta(child, [...path, key], map, counters, lastPathPerSchema, inProgress);
-        }
-        return;
-      }
-      case "array": {
-        walkForMeta(
-          getArrayElement(schema),
-          [...path, 0],
-          map,
-          counters,
-          lastPathPerSchema,
-          inProgress
-        );
-        return;
-      }
-      case "tuple": {
-        const items = getTupleItems(schema);
-        for (let i = 0; i < items.length; i++) {
-          const item = items[i];
-          if (item !== void 0)
-            walkForMeta(item, [...path, i], map, counters, lastPathPerSchema, inProgress);
-        }
-        return;
-      }
-      case "set":
-        walkForMeta(
-          getSetValueType(schema),
-          [...path, 0],
-          map,
-          counters,
-          lastPathPerSchema,
-          inProgress
-        );
-        return;
-      case "record":
-        walkForMeta(
-          getRecordValueType(schema),
-          [...path, "*"],
-          map,
-          counters,
-          lastPathPerSchema,
-          inProgress
-        );
-        return;
-      case "union": {
-        for (const opt of getUnionOptions(schema)) {
-          walkForMeta(opt, path, map, counters, lastPathPerSchema, inProgress);
-        }
-        return;
-      }
-      case "discriminated-union": {
-        for (const opt of getDiscriminatedOptions(schema)) {
-          walkForMeta(opt, path, map, counters, lastPathPerSchema, inProgress);
-        }
-        return;
-      }
-      case "optional":
-      case "nullable":
-      case "default":
-      case "readonly":
-      case "catch": {
-        const inner = unwrapInner(schema);
-        if (inner !== void 0)
-          walkForMeta(inner, path, map, counters, lastPathPerSchema, inProgress);
-        return;
-      }
-      case "pipe": {
-        const inner = unwrapPipe(schema);
-        if (inner !== void 0)
-          walkForMeta(inner, path, map, counters, lastPathPerSchema, inProgress);
-        return;
-      }
-      case "lazy": {
-        const inner = unwrapLazy(schema);
-        if (inner !== void 0)
-          walkForMeta(inner, path, map, counters, lastPathPerSchema, inProgress);
-        return;
-      }
-      case "intersection": {
-        const left = getIntersectionLeft(schema);
-        const right = getIntersectionRight(schema);
-        if (left !== void 0)
-          walkForMeta(left, path, map, counters, lastPathPerSchema, inProgress);
-        if (right !== void 0)
-          walkForMeta(right, path, map, counters, lastPathPerSchema, inProgress);
-        return;
-      }
-      // Leaf kinds — no children to descend into; metadata for the
-      // path itself was captured above. Listed explicitly so the
-      // exhaustiveness check catches any new kind landing in Zod
-      // without a corresponding decision here.
-      case "string":
-      case "number":
-      case "bigint":
-      case "boolean":
-      case "date":
-      case "enum":
-      case "literal":
-      case "null":
-      case "undefined":
-      case "any":
-      case "unknown":
-      case "nan":
-      case "void":
-      case "never":
-      case "promise":
-      case "custom":
-      case "template-literal":
-      case "transform":
-      case "file":
-      case "map":
-      case "symbol":
-      case "function":
-        return;
-    }
-  } finally {
-    inProgress.delete(schema);
-  }
-}
-function consumePayload(schema, counters) {
-  const list = getFieldMetaList(schema);
-  if (list.length === 0) return void 0;
-  const idx = counters.get(schema) ?? 0;
-  const payload = list[Math.min(idx, list.length - 1)];
-  counters.set(schema, idx + 1);
-  return payload;
-}
 function resolveFieldMetaAtPath(rootSchema, path, maxRecursionDepth) {
   const lastSegment = path.length === 0 ? "" : path[path.length - 1];
   const candidates = path.length === 0 ? [rootSchema] : getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth);
@@ -1596,7 +1239,11 @@ function resolveFieldMetaAtPath(rootSchema, path, maxRecursionDepth) {
       meta: Object.freeze({})
     };
   }
-  const pathMap = getPathMetaMap(rootSchema);
+  const pathMap = getFieldMetaPathMap(rootSchema, {
+    intro: V4_INTROSPECTOR,
+    peelAllWrappers,
+    getFieldMetaList
+  });
   const pathKey = canonicalizePath(path).key;
   const peeled = peelAllWrappers(target);
   const payload = pathMap.get(pathKey) ?? getFieldMeta(target) ?? (peeled !== target ? getFieldMeta(peeled) : void 0);
@@ -1627,5 +1274,5 @@ function useForm(configuration) {
   });
 }
 
-export { UnsupportedSchemaError as U, assertZodVersion as a, fieldMeta as f, kindOf as k, useForm as u, withMeta as w, zodV4Adapter as z };
-//# sourceMappingURL=attaform.C5aYC_T8.mjs.map
+export { UnsupportedSchemaError as U, assertZodVersion as a, getCatchDefault as b, getChecks as c, getDefaultValue as d, getDiscriminatedOptions as e, fieldMeta as f, getArrayElement as g, getDiscriminator as h, getEnumValues as i, getIntersectionLeft as j, getIntersectionRight as k, getLiteralValues as l, getObjectShape as m, getRecordKeyType as n, getRecordValueType as o, getSetValueType as p, getTupleItems as q, getUnionOptions as r, kindOf as s, unwrapLazy as t, unwrapInner as u, unwrapPipe as v, useForm as w, withMeta as x, zodV4Adapter as z };
+//# sourceMappingURL=attaform.DMEP_ENr.mjs.map