attaform 0.28.0 → 0.29.0

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

@@ -1,16 +1,30 @@
-import { A as AttaformErrorCode, n as isPlainRecord, s as slimKindOf } from './attaform.B8k8JrmK.mjs';
-import { e as canonicalizePath } from './attaform.wfY8XFvm.mjs';
-import { a as safeOwnRead, b as safeAssign } from './attaform.h0i6LijT.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;
@@ -102,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 [];
@@ -123,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;
     },
@@ -146,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);
@@ -289,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);
     }
@@ -296,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 [];
@@ -349,11 +406,13 @@ 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 [];
   }
@@ -461,6 +520,15 @@ function fixNode(schema, value, 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);
@@ -684,58 +752,63 @@ function deriveDefaultWalk(schema, 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) ?? [];
 }
-let pathMapBuilder = null;
 function installFieldMetaPathMapBuilder(builder) {
-  pathMapBuilder = builder;
+  state.pathMapBuilder = builder;
 }
 function buildFieldMetaPathMap(rootSchema, services) {
-  return pathMapBuilder === null ? void 0 : pathMapBuilder(rootSchema, services);
+  const builder = state.pathMapBuilder;
+  return builder === null ? void 0 : builder(rootSchema, services);
 }
 
 const PERMISSIVE_SLIM_KINDS = /* @__PURE__ */ new Set([
@@ -764,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) {
@@ -820,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);
@@ -883,14 +976,19 @@ 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;
   }
@@ -984,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;