attaform 0.20.2 → 0.21.0

package/dist/shared/{attaform.Cd4AOfwu.cjs → attaform.PnqML3xW.cjs}

@@ -1,22 +1,22 @@
 'use strict';
 
-const injectWizard = require('./attaform.CwLjUqmQ.cjs');
-const paths = require('./attaform.z5j3LwJz.cjs');
-const walkSlimPrimitives = require('./attaform.B_hph5AE.cjs');
+const injectWizard = require('./attaform.BUszFoKq.cjs');
+const paths = require('./attaform.BA3vRDos.cjs');
+const walkFieldMeta = require('./attaform._rsCZy2j.cjs');
 const zod = require('zod');
 
-const fieldMeta = walkSlimPrimitives.fieldMetaStore;
+const fieldMeta = walkFieldMeta.fieldMetaStore;
 function getFieldMetaList(schema) {
-  return walkSlimPrimitives.getFieldMetaListForSchema(schema);
+  return walkFieldMeta.getFieldMetaListForSchema(schema);
 }
 function withMeta(schema, payload) {
-  const existing = walkSlimPrimitives.getFieldMetaForSchema(schema) ?? {};
+  const existing = walkFieldMeta.getFieldMetaForSchema(schema) ?? {};
   const cloned = schema.clone();
-  walkSlimPrimitives.fieldMetaStore.add(cloned, { ...existing, ...payload });
+  walkFieldMeta.fieldMetaStore.add(cloned, { ...existing, ...payload });
   return cloned;
 }
 function getFieldMeta(schema) {
-  return walkSlimPrimitives.getFieldMetaForSchema(schema);
+  return walkFieldMeta.getFieldMetaForSchema(schema);
 }
 
 let warnedZodCodeMissing = false;
@@ -516,207 +516,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;
@@ -725,35 +536,35 @@ 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) {
-  return new Set(walkSlimPrimitives.slimPrimitivesWalk(schema, V4_INTROSPECTOR, maxRecursionDepth));
+  return new Set(walkFieldMeta.slimPrimitivesWalk(schema, V4_INTROSPECTOR, maxRecursionDepth));
 }
 
 const PATH_SEPARATOR = ".";
 function getNestedZodSchemasAtPath(schema, path, maxRecursionDepth) {
   if (Array.isArray(path)) {
-    return walkSlimPrimitives.walkPathSegments(schema, path.map(String), V4_INTROSPECTOR, maxRecursionDepth, 0);
+    return walkFieldMeta.walkPathSegments(schema, path.map(String), V4_INTROSPECTOR, maxRecursionDepth, 0);
   }
   const pathString = path;
   if (pathString.length === 0) return [schema];
-  return walkSlimPrimitives.walkPathSegments(
+  return walkFieldMeta.walkPathSegments(
     schema,
     pathString.split(PATH_SEPARATOR),
     V4_INTROSPECTOR,
@@ -1156,7 +967,7 @@ function walkSlim(schema, stripConfig, maxDepth, lazyDepth) {
 }
 
 function deriveDefault(schema, useDefault, maxRecursionDepth) {
-  return walkSlimPrimitives.deriveDefaultWalk(schema, useDefault, V4_INTROSPECTOR, maxRecursionDepth, {
+  return walkFieldMeta.deriveDefaultWalk(schema, useDefault, V4_INTROSPECTOR, maxRecursionDepth, {
     // v4 has an exhaustive switch against `SchemaIntrospector.kindOf`;
     // unknown kinds genuinely shouldn't appear, so return undefined.
     unsupportedKindFallback: () => void 0,
@@ -1170,7 +981,7 @@ function deriveDefault(schema, useDefault, maxRecursionDepth) {
 function getDefaultValuesFromZodSchema(opts) {
   const { schema, useDefaultSchemaValues, constraints, maxRecursionDepth } = opts;
   const initial = deriveDefault(schema, useDefaultSchemaValues, maxRecursionDepth);
-  const merged = walkSlimPrimitives.mergeDeep(initial, constraints);
+  const merged = walkFieldMeta.mergeDeep(initial, constraints);
   const slimSchema = getSlimSchema(
     schema,
     {
@@ -1319,7 +1130,7 @@ function isLeafRequired(schema, depth = 0) {
 function zodV4Adapter(rootSchema) {
   assertZodVersion(rootSchema);
   assertSupportedKinds(rootSchema);
-  return (formKey, options) => walkSlimPrimitives.createAbstractSchema(
+  return (formKey, options) => walkFieldMeta.createAbstractSchema(
     rootSchema,
     V4_INTROSPECTOR,
     buildV4Services(),
@@ -1327,9 +1138,13 @@ function zodV4Adapter(rootSchema) {
     options
   );
 }
+async function lazyFingerprint(schema) {
+  const { fingerprintZodSchema } = await import('../chunks/fingerprint2.cjs');
+  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
@@ -1386,7 +1201,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),
@@ -1414,178 +1229,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 = paths.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);
@@ -1598,7 +1241,11 @@ function resolveFieldMetaAtPath(rootSchema, path, maxRecursionDepth) {
       meta: Object.freeze({})
     };
   }
-  const pathMap = getPathMetaMap(rootSchema);
+  const pathMap = walkFieldMeta.getFieldMetaPathMap(rootSchema, {
+    intro: V4_INTROSPECTOR,
+    peelAllWrappers,
+    getFieldMetaList
+  });
   const pathKey = paths.canonicalizePath(path).key;
   const peeled = peelAllWrappers(target);
   const payload = pathMap.get(pathKey) ?? getFieldMeta(target) ?? (peeled !== target ? getFieldMeta(peeled) : void 0);
@@ -1632,8 +1279,27 @@ function useForm(configuration) {
 exports.UnsupportedSchemaError = UnsupportedSchemaError;
 exports.assertZodVersion = assertZodVersion;
 exports.fieldMeta = fieldMeta;
+exports.getArrayElement = getArrayElement;
+exports.getCatchDefault = getCatchDefault;
+exports.getChecks = getChecks;
+exports.getDefaultValue = getDefaultValue;
+exports.getDiscriminatedOptions = getDiscriminatedOptions;
+exports.getDiscriminator = getDiscriminator;
+exports.getEnumValues = getEnumValues;
+exports.getIntersectionLeft = getIntersectionLeft;
+exports.getIntersectionRight = getIntersectionRight;
+exports.getLiteralValues = getLiteralValues;
+exports.getObjectShape = getObjectShape;
+exports.getRecordKeyType = getRecordKeyType;
+exports.getRecordValueType = getRecordValueType;
+exports.getSetValueType = getSetValueType;
+exports.getTupleItems = getTupleItems;
+exports.getUnionOptions = getUnionOptions;
 exports.kindOf = kindOf;
+exports.unwrapInner = unwrapInner;
+exports.unwrapLazy = unwrapLazy;
+exports.unwrapPipe = unwrapPipe;
 exports.useForm = useForm;
 exports.withMeta = withMeta;
 exports.zodV4Adapter = zodV4Adapter;
-//# sourceMappingURL=attaform.Cd4AOfwu.cjs.map
+//# sourceMappingURL=attaform.PnqML3xW.cjs.map