attaform 0.27.6 → 0.29.0

package/dist/shared/{attaform.CoR4mWfv.mjs → attaform.B0dKL8ST.mjs}

@@ -1,14 +1,30 @@
-import { A as AttaformErrorCode, n as isPlainRecord, s as safeOwnRead, o as safeAssign, p as slimKindOf } from './attaform.CKH2lGdL.mjs';
-import { f as canonicalizePath } from './attaform.nMaz2C5P.mjs';
+import { A as AttaformErrorCode, n as isPlainRecord, s as slimKindOf, o as crossCopyState } from './attaform.CZMAYwSK.mjs';
+import { e as canonicalizePath, h as SET_MEMBER_SEGMENT } from './attaform.CZYt_5N_.mjs';
+import { a as safeOwnRead, b as safeAssign } from './attaform.Cvao8bW5.mjs';
 
 const PATH_SEPARATOR = ".";
+function isOpaqueKind(kind) {
+  return kind === "any" || kind === "unknown" || kind === "custom";
+}
 function createAbstractSchema(rootSchema, intro, services, formKey, options) {
   const maxRecursionDepth = options.maxRecursionDepth;
   const leafCache = /* @__PURE__ */ new Map();
   const preprocessOrCoerceCache = /* @__PURE__ */ new Map();
+  const opaqueLeafCache = /* @__PURE__ */ new Map();
   const discriminatorCache = /* @__PURE__ */ new Map();
+  const entryKeyKindCache = /* @__PURE__ */ new Map();
   let asyncValidationFlag = null;
   let containerRefineFlag = null;
+  let discriminatedUnionFlag = null;
+  function mapKeySegmentKind(schema) {
+    const keyType = intro.getMapKeyType(schema);
+    if (keyType === void 0) return void 0;
+    const kinds = services.slimPrimitivesOf(keyType, maxRecursionDepth);
+    const string = kinds.has("string");
+    const number = kinds.has("number");
+    if (string === number) return void 0;
+    return string ? "string" : "number";
+  }
   function computeDiscriminator(path) {
     const candidates = path.length === 0 ? [rootSchema] : services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth);
     let matchedUnion;
@@ -60,6 +76,10 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
       containerRefineFlag ?? (containerRefineFlag = intro.hasContainerOrRootRefine(rootSchema));
       return containerRefineFlag;
     },
+    hasDiscriminatedUnions() {
+      discriminatedUnionFlag ?? (discriminatedUnionFlag = intro.containsDiscriminatedUnion(rootSchema));
+      return discriminatedUnionFlag;
+    },
     getDefaultValues(config) {
       return services.runStrictGetDefaults(rootSchema, config, formKey, maxRecursionDepth);
     },
@@ -81,14 +101,12 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
       return services.deriveDefault(first, false, maxRecursionDepth, formKey);
     },
     arrayShapeAtPath(path) {
-      if (path.length === 0) return void 0;
+      if (path.length === 0) return null;
       const [first] = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth);
-      if (first === void 0) return void 0;
+      if (first === void 0) return null;
       const peeled = services.peelAllWrappers(first);
-      const kind = intro.kindOf(peeled);
-      if (kind === "tuple") return intro.getTupleItems(peeled).length;
-      if (kind === "array") return null;
-      return void 0;
+      if (intro.kindOf(peeled) === "tuple") return intro.getTupleItems(peeled).length;
+      return null;
     },
     isFixedObjectAtPath(path) {
       if (path.length === 0) {
@@ -98,6 +116,32 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
       if (resolved.length === 0) return false;
       return resolved.every((s) => intro.kindOf(services.peelAllWrappers(s)) === "object");
     },
+    entryKeyKindAtPath(path) {
+      const cacheKey = canonicalizePath(path).key;
+      if (entryKeyKindCache.has(cacheKey)) return entryKeyKindCache.get(cacheKey);
+      const resolved = path.length === 0 ? [rootSchema] : services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth);
+      let answer;
+      const only = resolved.length === 1 ? resolved[0] : void 0;
+      if (only !== void 0) {
+        switch (intro.kindOf(services.peelAllWrappers(only))) {
+          case "array":
+          case "tuple":
+            answer = "number";
+            break;
+          case "object":
+          case "record":
+            answer = "string";
+            break;
+          case "map":
+            answer = mapKeySegmentKind(services.peelAllWrappers(only));
+            break;
+          default:
+            answer = void 0;
+        }
+      }
+      entryKeyKindCache.set(cacheKey, answer);
+      return answer;
+    },
     getSchemasAtPath(path) {
       const resolved = services.getNestedSchemasInSlimMode(rootSchema, path, maxRecursionDepth);
       if (resolved.length === 0) return [];
@@ -119,8 +163,9 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
       const cacheKey = canonicalizePath(path).key;
       const cached = leafCache.get(cacheKey);
       if (cached !== void 0) return cached;
-      const prim = this.getSlimPrimitiveTypesAtPath(path);
-      const isLeaf = prim.size > 0 && !prim.has("object") && !prim.has("array") && !prim.has("map") && !prim.has("set");
+      const opaque = path.length > 0 && this.isOpaqueLeafAtPath(path);
+      const prim = opaque ? void 0 : this.getSlimPrimitiveTypesAtPath(path);
+      const isLeaf = opaque || prim !== void 0 && prim.size > 0 && !prim.has("object") && !prim.has("array") && !prim.has("map") && !prim.has("set");
       leafCache.set(cacheKey, isLeaf);
       return isLeaf;
     },
@@ -142,6 +187,17 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
       preprocessOrCoerceCache.set(cacheKey, hit);
       return hit;
     },
+    isOpaqueLeafAtPath(path) {
+      const cacheKey = canonicalizePath(path).key;
+      const cached = opaqueLeafCache.get(cacheKey);
+      if (cached !== void 0) return cached;
+      const resolved = path.length === 0 ? [rootSchema] : services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth);
+      const opaque = resolved.length > 0 && resolved.every(
+        (candidate) => isOpaqueKind(intro.kindOf(services.peelAllWrappers(candidate)))
+      );
+      opaqueLeafCache.set(cacheKey, opaque);
+      return opaque;
+    },
     isRequiredAtPath(path) {
       if (path.length === 0) return true;
       const resolved = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth);
@@ -172,7 +228,7 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
       function parseResultToResponse(result) {
         return result.success ? { data: result.data, errors: void 0, success: true, formKey } : {
           data: void 0,
-          errors: services.issuesToValidationErrors(result.issues, formKey),
+          errors: services.issuesToValidationErrors(result.issues),
           success: false,
           formKey
         };
@@ -225,7 +281,6 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
             {
               message,
               path: [...errPath],
-              formKey,
               code: AttaformErrorCode.ValidatorThrew
             }
           ],
@@ -240,7 +295,6 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
             {
               message: `Path '${p.join(PATH_SEPARATOR)}' did not resolve to any schema`,
               path: [...p],
-              formKey,
               code: AttaformErrorCode.PathNotFound
             }
           ],
@@ -287,6 +341,7 @@ function walkPathSegments(schema, segments, intro, maxDepth, lazyDepth) {
       return inner === void 0 ? [] : walkPathSegments(inner, rest, intro, maxDepth, lazyDepth);
     }
     case "set": {
+      if (head !== SET_MEMBER_SEGMENT) return [];
       const inner = intro.getSetValueType(schema);
       return inner === void 0 ? [] : walkPathSegments(inner, rest, intro, maxDepth, lazyDepth);
     }
@@ -294,6 +349,10 @@ function walkPathSegments(schema, segments, intro, maxDepth, lazyDepth) {
       const inner = intro.getRecordValueType(schema);
       return inner === void 0 ? [] : walkPathSegments(inner, rest, intro, maxDepth, lazyDepth);
     }
+    case "map": {
+      const inner = intro.getMapValueType(schema);
+      return inner === void 0 ? [] : walkPathSegments(inner, rest, intro, maxDepth, lazyDepth);
+    }
     case "tuple": {
       const index = Number(head);
       if (!Number.isInteger(index)) return [];
@@ -347,16 +406,165 @@ function walkPathSegments(schema, segments, intro, maxDepth, lazyDepth) {
       const rightResults = right === void 0 ? [] : walkPathSegments(right, segments, intro, maxDepth, lazyDepth);
       return [...leftResults, ...rightResults];
     }
-    // Leaves — can't descend further. The unsupported kinds (`map` /
-    // `symbol` / `function` / `promise`) are rejected at adapter
-    // construction by `assertSupportedKinds`; falling through to `[]`
-    // keeps the walker defensive in case construction is skipped
-    // (e.g. a downstream test instantiates a sub-schema directly).
+    // Leaves — can't descend further. Opaque leaves (`any` /
+    // `unknown` / `custom`) land here too and `[]` is the truthful
+    // answer: the schema declares no sub-paths under them, so none are
+    // fabricated. `symbol` / `function` / `promise` hold a value
+    // without declaring anything inside it and land here for the same
+    // reason. No kind is refused at construction (#607), so this is
+    // the only branch they ever take.
     default:
       return [];
   }
 }
 
+function fixStructuralDefaults(schema, merged, useDefault, maxRecursionDepth, services) {
+  const ctx = {
+    useDefault,
+    maxDepth: maxRecursionDepth,
+    clean: true,
+    services
+  };
+  const data = fixNode(schema, merged, ctx, 0);
+  return { data, success: ctx.clean };
+}
+function fixNode(schema, value, ctx, lazyDepth) {
+  const { intro } = ctx.services;
+  if (intro.isCoercePrimitive(schema) || intro.isPreprocessNode(schema)) return value;
+  const kinds = ctx.services.slimPrimitivesOf(schema);
+  if (kinds.size > 0 && !kinds.has(slimKindOf(value))) {
+    const replacement = deriveFixValue(schema, value, ctx);
+    if (kinds.has(slimKindOf(replacement))) return replacement;
+    ctx.clean = false;
+    return replacement;
+  }
+  switch (intro.kindOf(schema)) {
+    case "optional":
+    case "nullable": {
+      if (value === void 0 || value === null) return value;
+      const inner = intro.unwrapInner(schema);
+      return inner === void 0 ? value : fixNode(inner, value, ctx, lazyDepth);
+    }
+    case "default":
+    case "readonly":
+    case "catch": {
+      const inner = intro.unwrapInner(schema);
+      return inner === void 0 ? value : fixNode(inner, value, ctx, lazyDepth);
+    }
+    case "branded": {
+      const inner = intro.unwrapBranded(schema);
+      return inner === void 0 ? value : fixNode(inner, value, ctx, lazyDepth);
+    }
+    case "effects": {
+      const inner = intro.unwrapEffectsSource(schema);
+      return inner === void 0 ? value : fixNode(inner, value, ctx, lazyDepth);
+    }
+    case "pipe":
+    case "pipeline": {
+      const pipeIn = intro.unwrapPipeIn(schema);
+      if (pipeIn === void 0 || intro.kindOf(pipeIn) === "transform") return value;
+      return fixNode(pipeIn, value, ctx, lazyDepth);
+    }
+    case "lazy": {
+      if (lazyDepth >= ctx.maxDepth) return value;
+      const inner = intro.unwrapLazy(schema);
+      return inner === void 0 ? value : fixNode(inner, value, ctx, lazyDepth + 1);
+    }
+    case "discriminated-union": {
+      if (value === null || typeof value !== "object") return value;
+      const variant = selectVariantByValue(schema, value, intro);
+      if (variant === void 0) return value;
+      const record = value;
+      const shape = intro.getObjectShape(variant);
+      for (const key of Object.keys(record)) {
+        if (!(key in shape)) delete record[key];
+      }
+      for (const [key, sub] of Object.entries(shape)) {
+        record[key] = fixNode(sub, record[key], ctx, lazyDepth);
+      }
+      return value;
+    }
+    case "object": {
+      if (value === null || typeof value !== "object") return value;
+      const record = value;
+      for (const [key, sub] of Object.entries(intro.getObjectShape(schema))) {
+        record[key] = fixNode(sub, record[key], ctx, lazyDepth);
+      }
+      return value;
+    }
+    case "array": {
+      if (!Array.isArray(value)) return value;
+      const element = intro.getArrayElement(schema);
+      if (element === void 0) return value;
+      for (let i = 0; i < value.length; i++) {
+        value[i] = fixNode(element, value[i], ctx, lazyDepth);
+      }
+      return value;
+    }
+    case "tuple": {
+      if (!Array.isArray(value)) return value;
+      const items = intro.getTupleItems(schema);
+      for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        if (item !== void 0) value[i] = fixNode(item, value[i], ctx, lazyDepth);
+      }
+      return value;
+    }
+    case "record": {
+      if (value === null || typeof value !== "object") return value;
+      const valueType = intro.getRecordValueType(schema);
+      if (valueType === void 0) return value;
+      const record = value;
+      for (const key of Object.keys(record)) {
+        record[key] = fixNode(valueType, record[key], ctx, lazyDepth);
+      }
+      return value;
+    }
+    case "map": {
+      if (!(value instanceof Map)) return value;
+      const valueType = intro.getMapValueType(schema);
+      if (valueType === void 0) return value;
+      for (const [key, entry] of [...value]) {
+        value.set(key, fixNode(valueType, entry, ctx, lazyDepth));
+      }
+      return value;
+    }
+    case "intersection": {
+      const left = intro.getIntersectionLeft(schema);
+      const right = intro.getIntersectionRight(schema);
+      let out = value;
+      if (left !== void 0) out = fixNode(left, out, ctx, lazyDepth);
+      if (right !== void 0) out = fixNode(right, out, ctx, lazyDepth);
+      return out;
+    }
+    default:
+      return value;
+  }
+}
+function deriveFixValue(schema, value, ctx) {
+  const du = ctx.services.unwrapToDiscriminatedUnion(schema);
+  if (du !== void 0) {
+    const selected = selectVariantByValue(du, value, ctx.services.intro) ?? ctx.services.intro.getDiscriminatedOptions(du)[0];
+    if (selected !== void 0) {
+      return ctx.services.deriveDefault(selected, ctx.useDefault);
+    }
+  }
+  return ctx.services.deriveDefault(schema, ctx.useDefault);
+}
+function selectVariantByValue(du, value, intro) {
+  if (value === null || typeof value !== "object") return void 0;
+  const discKey = intro.getDiscriminator(du);
+  if (discKey === void 0) return void 0;
+  const discValue = value[discKey];
+  if (discValue === void 0) return void 0;
+  for (const opt of intro.getDiscriminatedOptions(du)) {
+    const litSchema = intro.getObjectShape(opt)[discKey];
+    if (litSchema === void 0 || intro.kindOf(litSchema) !== "literal") continue;
+    if (intro.getLiteralValues(litSchema).includes(discValue)) return opt;
+  }
+  return void 0;
+}
+
 const NO_EMBEDDED_DEFAULT = /* @__PURE__ */ Symbol("atta:no-embedded-default");
 function peelEmbeddedDefault(schema, intro) {
   let current = schema;
@@ -539,59 +747,68 @@ function deriveDefaultWalk(schema, useDefault, intro, maxDepth, ctx, lazyDepth =
     }
     case "catch": {
       if (useDefault) return intro.getCatchDefault(schema);
-      if (ctx.catchOnUseDefaultFalse === "preserveCatch" && intro.hasCatchValue(schema)) {
-        return intro.getCatchDefault(schema);
-      }
       const inner = intro.unwrapInner(schema);
       return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth);
     }
     case "file":
       return null;
+    case "map":
+      return /* @__PURE__ */ new Map();
+    case "template-literal":
+      return "";
     case "any":
     case "unknown":
+    case "custom":
     case "void":
     case "never":
     case "promise":
-    case "custom":
-    case "template-literal":
-    case "transform":
-    case "map":
     case "symbol":
     case "function":
+    case "transform":
       return void 0;
     default:
       return ctx.unsupportedKindFallback(schema, kind);
   }
 }
 
-const store = /* @__PURE__ */ new WeakMap();
-const lists = /* @__PURE__ */ new WeakMap();
+const state = crossCopyState(/* @__PURE__ */ Symbol.for("attaform:field-meta-state"), () => ({
+  store: /* @__PURE__ */ new WeakMap(),
+  lists: /* @__PURE__ */ new WeakMap(),
+  pathMapBuilder: null
+}));
 const registry = {
   add(schema, payload) {
-    store.set(schema, payload);
-    const list = lists.get(schema) ?? [];
+    state.store.set(schema, payload);
+    const list = state.lists.get(schema) ?? [];
     list.push(payload);
-    lists.set(schema, list);
+    state.lists.set(schema, list);
     return registry;
   },
   get(schema) {
-    return store.get(schema);
+    return state.store.get(schema);
   },
   has(schema) {
-    return store.has(schema);
+    return state.store.has(schema);
   },
   remove(schema) {
-    store.delete(schema);
-    lists.delete(schema);
+    state.store.delete(schema);
+    state.lists.delete(schema);
     return registry;
   }
 };
 const fieldMetaStore = registry;
 function getFieldMetaForSchema(schema) {
-  return store.get(schema);
+  return state.store.get(schema);
 }
 function getFieldMetaListForSchema(schema) {
-  return lists.get(schema) ?? [];
+  return state.lists.get(schema) ?? [];
+}
+function installFieldMetaPathMapBuilder(builder) {
+  state.pathMapBuilder = builder;
+}
+function buildFieldMetaPathMap(rootSchema, services) {
+  const builder = state.pathMapBuilder;
+  return builder === null ? void 0 : builder(rootSchema, services);
 }
 
 const PERMISSIVE_SLIM_KINDS = /* @__PURE__ */ new Set([
@@ -620,6 +837,16 @@ const KIND_UNDEFINED = /* @__PURE__ */ new Set(["undefined"]);
 const KIND_OBJECT = /* @__PURE__ */ new Set(["object"]);
 const KIND_ARRAY = /* @__PURE__ */ new Set(["array"]);
 const KIND_SET = /* @__PURE__ */ new Set(["set"]);
+const KIND_MAP = /* @__PURE__ */ new Set(["map"]);
+const KIND_SYMBOL = /* @__PURE__ */ new Set(["symbol", "undefined"]);
+const KIND_FUNCTION = /* @__PURE__ */ new Set([
+  "function",
+  "undefined"
+]);
+const KIND_PROMISE = /* @__PURE__ */ new Set([
+  "object",
+  "undefined"
+]);
 const KIND_FILE = /* @__PURE__ */ new Set(["file", "null"]);
 const EMPTY_KINDS = /* @__PURE__ */ new Set();
 function slimPrimitivesWalk(schema, intro, maxDepth, lazyDepth = 0) {
@@ -676,6 +903,16 @@ function slimPrimitivesWalk(schema, intro, maxDepth, lazyDepth = 0) {
       return KIND_ARRAY;
     case "set":
       return KIND_SET;
+    case "map":
+      return KIND_MAP;
+    case "symbol":
+      return KIND_SYMBOL;
+    case "function":
+      return KIND_FUNCTION;
+    case "promise":
+      return KIND_PROMISE;
+    case "template-literal":
+      return KIND_STRING;
     case "optional": {
       const inner = intro.unwrapInner(schema);
       const innerSet = inner === void 0 ? EMPTY_KINDS : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth);
@@ -739,19 +976,37 @@ function slimPrimitivesWalk(schema, intro, maxDepth, lazyDepth = 0) {
     }
     case "never":
       return EMPTY_KINDS;
+    // Opaque leaves: the schema says nothing about the value's shape,
+    // so every kind is admissible. `custom` is the kind
+    // `z.instanceof(X)` and `z.custom<T>()` compile to on v4 (#542);
+    // it belongs with `any` / `unknown` rather than in the defensive
+    // fallthrough, because it reaches here through the public surface.
     case "any":
     case "unknown":
+    case "custom":
       return PERMISSIVE_SLIM_KINDS;
-    // Opaque / unsupported kinds: be permissive so legitimate writes
-    // aren't false-rejected. The unsupported kinds (`map` / `symbol` /
-    // `function` / `promise`) are rejected at adapter construction by
-    // `assertSupportedKinds`; this fallthrough keeps the walker
-    // defensive in case construction is skipped.
+    // A kind this walker has no case for — in practice a kind a newer
+    // Zod introduced. Be permissive rather than reject: the adapter
+    // carries the value opaquely and the schema's own parse is what
+    // decides whether it was legal.
     default:
       return PERMISSIVE_SLIM_KINDS;
   }
 }
 
+const installingFieldMetaStore = {
+  add(schema, payload) {
+    installFieldMetaPathMapBuilder(getFieldMetaPathMap);
+    fieldMetaStore.add(schema, payload);
+    return installingFieldMetaStore;
+  },
+  get: (schema) => fieldMetaStore.get(schema),
+  has: (schema) => fieldMetaStore.has(schema),
+  remove: (schema) => {
+    fieldMetaStore.remove(schema);
+    return installingFieldMetaStore;
+  }
+};
 const pathMetaCache = /* @__PURE__ */ new WeakMap();
 function getFieldMetaPathMap(rootSchema, services) {
   const cached = pathMetaCache.get(rootSchema);
@@ -827,11 +1082,20 @@ function walkForMeta(schema, path, map, counters, lastPathPerSchema, inProgress,
       case "set": {
         const inner = intro.getSetValueType(schema);
         if (inner !== void 0)
-          walkForMeta(inner, [...path, 0], map, counters, lastPathPerSchema, inProgress, services);
+          walkForMeta(
+            inner,
+            [...path, SET_MEMBER_SEGMENT],
+            map,
+            counters,
+            lastPathPerSchema,
+            inProgress,
+            services
+          );
         return;
       }
-      case "record": {
-        const inner = intro.getRecordValueType(schema);
+      case "record":
+      case "map": {
+        const inner = kind === "map" ? intro.getMapValueType(schema) : intro.getRecordValueType(schema);
         if (inner !== void 0)
           walkForMeta(inner, [...path, "*"], map, counters, lastPathPerSchema, inProgress, services);
         return;
@@ -903,5 +1167,4 @@ function walkForMeta(schema, path, map, counters, lastPathPerSchema, inProgress,
   }
 }
 
-export { NO_EMBEDDED_DEFAULT as N, getFieldMetaListForSchema as a, getFieldMetaPathMap as b, createAbstractSchema as c, deriveDefaultWalk as d, fieldMetaStore as f, getFieldMetaForSchema as g, mergeDeep as m, peelEmbeddedDefault as p, slimPrimitivesWalk as s, walkPathSegments as w };
-//# sourceMappingURL=attaform.CoR4mWfv.mjs.map
+export { getFieldMetaListForSchema as a, buildFieldMetaPathMap as b, createAbstractSchema as c, deriveDefaultWalk as d, fixStructuralDefaults as f, getFieldMetaForSchema as g, installingFieldMetaStore as i, mergeDeep as m, slimPrimitivesWalk as s, walkPathSegments as w };