attaform 0.17.1 → 0.18.0

package/dist/shared/{attaform.CpERWz3u.mjs → attaform.Xt0A3QUd.mjs}

@@ -1,7 +1,6 @@
-import { g as getAtPath, s as slimKindOf, f as setAtPath, j as isPlainRecord, A as AttaformErrorCode, h as humanize, e as useAbstractForm } from './attaform.B3ZaPIzS.mjs';
-import { a as AttaformError, _ as __DEV__, b as InvalidUseFormConfigError } from './attaform.CIEQgJnM.mjs';
+import { h as getAtPath, s as slimKindOf, k as setAtPath, m as isPlainRecord, A as AttaformErrorCode, j as humanize, g as useAbstractForm } from './attaform.DsC3rZHG.mjs';
+import { b as AttaformError, _ as __DEV__, a as canonicalizePath, d as InvalidUseFormConfigError } from './attaform.Xhg0AYNa.mjs';
 import { f as fieldMetaStore, g as getFieldMetaForSchema, a as getFieldMetaListForSchema } from './attaform.D13GMFgK.mjs';
-import { c as canonicalizePath } from './attaform.h1sq3BFu.mjs';
 import { z } from 'zod';
 
 const fieldMeta = fieldMetaStore;
@@ -124,6 +123,8 @@ function kindOf(schema) {
     case "template_literal":
     case "templateLiteral":
       return "template-literal";
+    case "file":
+      return "file";
     default:
       return "unknown";
   }
@@ -178,14 +179,13 @@ function unwrapPipeIn(schema) {
   const def = readDef(schema);
   return def?.in;
 }
+function isCoercePrimitive(schema) {
+  return readDef(schema)?.coerce === true;
+}
 function unwrapPipeOut(schema) {
   const def = readDef(schema);
   return def?.out;
 }
-function readTransformFn(schema) {
-  const def = readDef(schema);
-  return typeof def?.transform === "function" ? def.transform : void 0;
-}
 function unwrapLazy(schema) {
   const def = readDef(schema);
   const getter = def?.getter;
@@ -310,6 +310,70 @@ function containsAsyncRefine(schema, seen) {
   }
   return false;
 }
+function containsAsyncTransform(schema, seen) {
+  const visited = seen ?? /* @__PURE__ */ new WeakSet();
+  const candidate = schema;
+  if (typeof candidate !== "object" || candidate === null) return false;
+  if (visited.has(candidate)) return false;
+  visited.add(candidate);
+  const def = readDef(schema);
+  if (def === void 0) return false;
+  if (typeof def.transform === "function" && def.transform.constructor.name === "AsyncFunction") {
+    return true;
+  }
+  if (def.innerType !== void 0 && containsAsyncTransform(def.innerType, visited)) {
+    return true;
+  }
+  if (def.element !== void 0 && containsAsyncTransform(def.element, visited)) {
+    return true;
+  }
+  if (def.in !== void 0 && containsAsyncTransform(def.in, visited)) {
+    return true;
+  }
+  if (def.out !== void 0 && containsAsyncTransform(def.out, visited)) {
+    return true;
+  }
+  if (def.left !== void 0 && containsAsyncTransform(def.left, visited)) {
+    return true;
+  }
+  if (def.right !== void 0 && containsAsyncTransform(def.right, visited)) {
+    return true;
+  }
+  if (def.keyType !== void 0 && containsAsyncTransform(def.keyType, visited)) {
+    return true;
+  }
+  if (def.valueType !== void 0 && containsAsyncTransform(def.valueType, visited)) {
+    return true;
+  }
+  if (def.shape !== void 0) {
+    for (const sub of Object.values(def.shape)) {
+      if (containsAsyncTransform(sub, visited)) return true;
+    }
+  }
+  if (def.entries !== void 0) {
+    for (const sub of Object.values(def.entries)) {
+      if (containsAsyncTransform(sub, visited)) return true;
+    }
+  }
+  if (def.options !== void 0) {
+    for (const sub of def.options) {
+      if (containsAsyncTransform(sub, visited)) return true;
+    }
+  }
+  if (def.items !== void 0) {
+    for (const sub of def.items) {
+      if (containsAsyncTransform(sub, visited)) return true;
+    }
+  }
+  if (typeof def.getter === "function") {
+    try {
+      const inner = def.getter();
+      if (containsAsyncTransform(inner, visited)) return true;
+    } catch {
+    }
+  }
+  return false;
+}
 function isAsyncCheck(check) {
   if (typeof check !== "object" || check === null) return false;
   const c = check;
@@ -414,6 +478,7 @@ function assertSupportedKinds(schema, path = [], lazyGetters = []) {
     case "custom":
     case "template-literal":
     case "transform":
+    case "file":
       return;
     default: {
       const _exhaustive = kind;
@@ -569,6 +634,7 @@ function computeFingerprint(schema, cache, inProgress) {
     case "custom":
     case "template-literal":
     case "transform":
+    case "file":
       return `${kind}:*`;
     default: {
       const _ = kind;
@@ -648,30 +714,45 @@ const PERMISSIVE = /* @__PURE__ */ new Set([
   "symbol",
   "function",
   "map",
-  "set"
+  "set",
+  "file"
 ]);
+const KIND_STRING = /* @__PURE__ */ new Set(["string"]);
+const KIND_NUMBER = /* @__PURE__ */ new Set(["number"]);
+const KIND_BOOLEAN = /* @__PURE__ */ new Set(["boolean"]);
+const KIND_BIGINT = /* @__PURE__ */ new Set(["bigint"]);
+const KIND_DATE = /* @__PURE__ */ new Set(["date"]);
+const KIND_NULL = /* @__PURE__ */ new Set(["null"]);
+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_FILE = /* @__PURE__ */ new Set(["file", "null"]);
+const EMPTY_KINDS = /* @__PURE__ */ new Set();
 function slimPrimitivesOf(schema, maxRecursionDepth) {
-  return walk(schema, 0, maxRecursionDepth);
+  return new Set(walk(schema, 0, maxRecursionDepth));
 }
 function walk(schema, lazyDepth, maxDepth) {
   const kind = kindOf(schema);
   switch (kind) {
     case "string":
-      return /* @__PURE__ */ new Set(["string"]);
+      return KIND_STRING;
     case "number":
     case "nan":
-      return /* @__PURE__ */ new Set(["number"]);
+      return KIND_NUMBER;
     case "boolean":
-      return /* @__PURE__ */ new Set(["boolean"]);
+      return KIND_BOOLEAN;
     case "bigint":
-      return /* @__PURE__ */ new Set(["bigint"]);
+      return KIND_BIGINT;
     case "date":
-      return /* @__PURE__ */ new Set(["date"]);
+      return KIND_DATE;
+    case "file":
+      return KIND_FILE;
     case "null":
-      return /* @__PURE__ */ new Set(["null"]);
+      return KIND_NULL;
     case "undefined":
     case "void":
-      return /* @__PURE__ */ new Set(["undefined"]);
+      return KIND_UNDEFINED;
     case "enum": {
       const values = getEnumValues(schema);
       const out = /* @__PURE__ */ new Set();
@@ -679,48 +760,52 @@ function walk(schema, lazyDepth, maxDepth) {
         if (typeof v === "string") out.add("string");
         else if (typeof v === "number") out.add("number");
       }
-      return out.size === 0 ? /* @__PURE__ */ new Set(["string"]) : out;
+      return out.size === 0 ? KIND_STRING : out;
     }
     case "literal": {
       const values = getLiteralValues(schema);
       const out = /* @__PURE__ */ new Set();
       for (const v of values) out.add(slimKindOfRaw(v));
-      return out.size === 0 ? new Set(PERMISSIVE) : out;
+      return out.size === 0 ? PERMISSIVE : out;
     }
     case "object":
     case "record":
-      return /* @__PURE__ */ new Set(["object"]);
+      return KIND_OBJECT;
     case "array":
     case "tuple":
-      return /* @__PURE__ */ new Set(["array"]);
+      return KIND_ARRAY;
     case "set":
-      return /* @__PURE__ */ new Set(["set"]);
+      return KIND_SET;
     case "optional": {
       const inner = unwrapInner(schema);
-      const innerSet = inner === void 0 ? /* @__PURE__ */ new Set() : walk(inner, lazyDepth, maxDepth);
-      innerSet.add("undefined");
-      return innerSet;
+      const innerSet = inner === void 0 ? EMPTY_KINDS : walk(inner, lazyDepth, maxDepth);
+      const out = new Set(innerSet);
+      out.add("undefined");
+      return out;
     }
     case "nullable": {
       const inner = unwrapInner(schema);
-      const innerSet = inner === void 0 ? /* @__PURE__ */ new Set() : walk(inner, lazyDepth, maxDepth);
-      innerSet.add("null");
-      return innerSet;
+      const innerSet = inner === void 0 ? EMPTY_KINDS : walk(inner, lazyDepth, maxDepth);
+      const out = new Set(innerSet);
+      out.add("null");
+      return out;
     }
     case "default":
     case "readonly":
     case "catch": {
       const inner = unwrapInner(schema);
-      return inner === void 0 ? new Set(PERMISSIVE) : walk(inner, lazyDepth, maxDepth);
+      return inner === void 0 ? PERMISSIVE : walk(inner, lazyDepth, maxDepth);
     }
     case "pipe": {
-      const inner = unwrapPipe(schema);
-      return inner === void 0 ? new Set(PERMISSIVE) : walk(inner, lazyDepth, maxDepth);
+      const pipeIn = unwrapPipeIn(schema);
+      const pipeOut = unwrapPipeOut(schema);
+      const inner = pipeIn !== void 0 && kindOf(pipeIn) === "transform" ? pipeOut : pipeIn ?? pipeOut;
+      return inner === void 0 ? PERMISSIVE : walk(inner, lazyDepth, maxDepth);
     }
     case "lazy": {
-      if (lazyDepth >= maxDepth) return new Set(PERMISSIVE);
+      if (lazyDepth >= maxDepth) return PERMISSIVE;
       const inner = unwrapLazy(schema);
-      return inner === void 0 ? new Set(PERMISSIVE) : walk(inner, lazyDepth + 1, maxDepth);
+      return inner === void 0 ? PERMISSIVE : walk(inner, lazyDepth + 1, maxDepth);
     }
     case "union":
     case "discriminated-union": {
@@ -729,22 +814,22 @@ function walk(schema, lazyDepth, maxDepth) {
       for (const opt of options) {
         for (const k of walk(opt, lazyDepth, maxDepth)) out.add(k);
       }
-      return out.size === 0 ? new Set(PERMISSIVE) : out;
+      return out.size === 0 ? PERMISSIVE : out;
     }
     case "intersection": {
       const left = getIntersectionLeft(schema);
       const right = getIntersectionRight(schema);
-      const leftSet = left === void 0 ? new Set(PERMISSIVE) : walk(left, lazyDepth, maxDepth);
-      const rightSet = right === void 0 ? new Set(PERMISSIVE) : walk(right, lazyDepth, maxDepth);
+      const leftSet = left === void 0 ? PERMISSIVE : walk(left, lazyDepth, maxDepth);
+      const rightSet = right === void 0 ? PERMISSIVE : walk(right, lazyDepth, maxDepth);
       const out = /* @__PURE__ */ new Set();
       for (const k of leftSet) if (rightSet.has(k)) out.add(k);
       return out;
     }
     case "never":
-      return /* @__PURE__ */ new Set();
+      return EMPTY_KINDS;
     case "any":
     case "unknown":
-      return new Set(PERMISSIVE);
+      return PERMISSIVE;
     // Kinds we don't understand at the slim level: be permissive to
     // avoid false-rejecting legitimate writes against schema shapes
     // we haven't characterised.
@@ -752,9 +837,9 @@ function walk(schema, lazyDepth, maxDepth) {
     case "custom":
     case "template-literal":
     case "transform":
-      return new Set(PERMISSIVE);
+      return PERMISSIVE;
     default:
-      return new Set(PERMISSIVE);
+      return PERMISSIVE;
   }
 }
 function slimKindOfRaw(value) {
@@ -873,6 +958,7 @@ function walkSegments(schema, segments, maxDepth, lazyDepth) {
     case "custom":
     case "template-literal":
     case "transform":
+    case "file":
       return [];
     default: {
       const _exhaustive = kind;
@@ -985,6 +1071,7 @@ function stripRefinements(schema) {
     case "custom":
     case "template-literal":
     case "transform":
+    case "file":
       return schema;
     default: {
       const _exhaustive = kind;
@@ -1109,6 +1196,7 @@ function stripAsyncChecks(schema) {
       case "custom":
       case "template-literal":
       case "transform":
+      case "file":
         return s;
       default: {
         const _exhaustive = kind;
@@ -1254,6 +1342,7 @@ function walkSlim(schema, stripConfig, maxDepth, lazyDepth) {
       return slimmedInner.catch(getCatchDefault(schema));
     }
     case "transform":
+    case "file":
       return schema;
     default: {
       const _exhaustive = kind;
@@ -1262,10 +1351,25 @@ function walkSlim(schema, stripConfig, maxDepth, lazyDepth) {
   }
 }
 
+function hasDeclaredDefaultInChain(schema) {
+  let current = schema;
+  for (let i = 0; i < 32; i++) {
+    if (current === void 0) return false;
+    const k = kindOf(current);
+    if (k === "default") return true;
+    if (k === "optional" || k === "nullable" || k === "readonly" || k === "catch") {
+      current = unwrapInner(current);
+      continue;
+    }
+    return false;
+  }
+  return false;
+}
 function deriveDefault(schema, useDefault, maxRecursionDepth) {
   return defaultForKind(kindOf(schema), schema, useDefault, maxRecursionDepth, 0);
 }
 function defaultForKind(kind, schema, useDefault, maxDepth, lazyDepth) {
+  if (isCoercePrimitive(schema)) return void 0;
   switch (kind) {
     case "object": {
       const shape = getObjectShape(schema);
@@ -1289,8 +1393,15 @@ function defaultForKind(kind, schema, useDefault, maxDepth, lazyDepth) {
       return inner === void 0 ? void 0 : defaultForKind(kindOf(inner), inner, useDefault, maxDepth, lazyDepth);
     }
     case "pipe": {
-      const out = unwrapPipeOut(schema);
       const inn = unwrapPipeIn(schema);
+      if (inn !== void 0 && kindOf(inn) === "transform") {
+        const out2 = unwrapPipeOut(schema);
+        if (out2 !== void 0 && hasDeclaredDefaultInChain(out2)) {
+          return defaultForKind(kindOf(out2), out2, useDefault, maxDepth, lazyDepth);
+        }
+        return void 0;
+      }
+      const out = unwrapPipeOut(schema);
       const real = inn !== void 0 && kindOf(inn) !== "transform" ? inn : out !== void 0 && kindOf(out) !== "transform" ? out : inn ?? out;
       return real === void 0 ? void 0 : defaultForKind(kindOf(real), real, useDefault, maxDepth, lazyDepth);
     }
@@ -1341,7 +1452,12 @@ function defaultForKind(kind, schema, useDefault, maxDepth, lazyDepth) {
       return NaN;
     case "lazy": {
       if (lazyDepth >= maxDepth) return void 0;
-      const inner = unwrapLazy(schema);
+      let inner;
+      try {
+        inner = unwrapLazy(schema);
+      } catch {
+        return void 0;
+      }
       return inner === void 0 ? void 0 : defaultForKind(kindOf(inner), inner, useDefault, maxDepth, lazyDepth + 1);
     }
     case "intersection": {
@@ -1365,6 +1481,8 @@ function defaultForKind(kind, schema, useDefault, maxDepth, lazyDepth) {
     case "template-literal":
     case "transform":
       return void 0;
+    case "file":
+      return null;
     default: {
       const _exhaustive = kind;
       throw new Error(`deriveDefault: unhandled ZodKind '${_exhaustive}'`);
@@ -1381,7 +1499,7 @@ function mergeDeep(base, override) {
     const bVal = base[key];
     if (isPlainRecord(oVal) && isPlainRecord(bVal)) {
       result[key] = mergeDeep(bVal, oVal);
-    } else if (oVal !== void 0) {
+    } else {
       result[key] = oVal;
     }
   }
@@ -1407,6 +1525,14 @@ function getDefaultValuesFromZodSchema(opts) {
   let fixedData = merged;
   for (const issue of firstParse.error.issues) {
     const pathSegments = issue.path.map((seg) => typeof seg === "number" ? seg : String(seg));
+    const originalCandidate = getNestedZodSchemasAtPath(schema, pathSegments, maxRecursionDepth)[0];
+    if (originalCandidate !== void 0) {
+      if (isCoercePrimitive(originalCandidate)) continue;
+      if (kindOf(originalCandidate) === "pipe") {
+        const pipeIn = unwrapPipeIn(originalCandidate);
+        if (pipeIn !== void 0 && kindOf(pipeIn) === "transform") continue;
+      }
+    }
     const candidates = getNestedZodSchemasAtPath(slimSchema, pathSegments, maxRecursionDepth);
     if (candidates.length === 0) continue;
     const candidate = candidates[0];
@@ -1535,11 +1661,12 @@ function zodV4Adapter(rootSchema) {
   return (formKey, options) => {
     const maxRecursionDepth = options.maxRecursionDepth;
     const leafCache = /* @__PURE__ */ new Map();
+    const preprocessOrCoerceCache = /* @__PURE__ */ new Map();
     let asyncValidationFlag = null;
     return {
       fingerprint: () => fingerprintZodSchema(rootSchema),
       needsAsyncValidation() {
-        asyncValidationFlag ?? (asyncValidationFlag = containsAsyncRefine(rootSchema));
+        asyncValidationFlag ?? (asyncValidationFlag = containsAsyncRefine(rootSchema) || containsAsyncTransform(rootSchema));
         return asyncValidationFlag;
       },
       getDefaultValues(config) {
@@ -1550,8 +1677,12 @@ function zodV4Adapter(rootSchema) {
           maxRecursionDepth
         });
         if (config.strict !== false) {
+          if (containsAsyncTransform(rootSchema)) {
+            return { data, errors: void 0, success: true, formKey };
+          }
+          const parseTarget = containsAsyncRefine(rootSchema) ? stripAsyncChecks(rootSchema) : rootSchema;
           try {
-            const strictResult = rootSchema.safeParse(
+            const strictResult = parseTarget.safeParse(
               data
             );
             if (strictResult.success) {
@@ -1564,56 +1695,11 @@ function zodV4Adapter(rootSchema) {
               formKey
             };
           } catch {
-            try {
-              const syncOnly = stripAsyncChecks(rootSchema);
-              const syncResult = syncOnly.safeParse(data);
-              if (syncResult.success) {
-                return { data, errors: void 0, success: true, formKey };
-              }
-              return {
-                data,
-                errors: zodIssuesToValidationErrors(syncResult.error.issues, formKey),
-                success: false,
-                formKey
-              };
-            } catch {
-              return { data, errors: void 0, success: true, formKey };
-            }
+            return { data, errors: void 0, success: true, formKey };
           }
         }
         return { data, errors: void 0, success: true, formKey };
       },
-      normalizeWriteValueAtPath(value, path) {
-        const candidates = path.length === 0 ? [rootSchema] : getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth);
-        const [first] = candidates;
-        if (first === void 0) return value;
-        let current = first;
-        let result = value;
-        for (let i = 0; i < 64; i++) {
-          if (kindOf(current) !== "pipe") break;
-          const pipeIn = unwrapPipeIn(current);
-          if (pipeIn === void 0 || kindOf(pipeIn) !== "transform") break;
-          const fn = readTransformFn(pipeIn);
-          if (typeof fn !== "function") break;
-          let next;
-          try {
-            next = fn(result);
-          } catch (cause) {
-            throw new Error(
-              `[attaform] input normalization at path "${path.join(".")}" threw \u2014 write rejected.`,
-              { cause }
-            );
-          }
-          if (next instanceof Promise) {
-            return value;
-          }
-          result = next;
-          const out = unwrapPipeOut(current);
-          if (out === void 0) break;
-          current = out;
-        }
-        return result;
-      },
       getDefaultAtPath(path) {
         if (path.length === 0) return deriveDefault(rootSchema, true, maxRecursionDepth);
         const [first] = getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth);
@@ -1683,6 +1769,30 @@ function zodV4Adapter(rootSchema) {
         leafCache.set(cacheKey, isLeaf);
         return isLeaf;
       },
+      isPreprocessOrCoerceLeaf(path) {
+        const cacheKey = canonicalizePath(path).key;
+        const cached = preprocessOrCoerceCache.get(cacheKey);
+        if (cached !== void 0) return cached;
+        let hit = false;
+        for (let i = 0; i <= path.length && !hit; i++) {
+          const prefix = path.slice(0, i);
+          const candidates = prefix.length === 0 ? [rootSchema] : getNestedZodSchemasAtPath(rootSchema, prefix, maxRecursionDepth);
+          for (const candidate of candidates) {
+            if (isCoercePrimitive(candidate)) {
+              hit = true;
+              break;
+            }
+            if (kindOf(candidate) !== "pipe") continue;
+            const pipeIn = unwrapPipeIn(candidate);
+            if (pipeIn !== void 0 && kindOf(pipeIn) === "transform") {
+              hit = true;
+              break;
+            }
+          }
+        }
+        preprocessOrCoerceCache.set(cacheKey, hit);
+        return hit;
+      },
       isRequiredAtPath(path) {
         if (path.length === 0) return true;
         const resolved = getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth);
@@ -1769,9 +1879,14 @@ function zodV4Adapter(rootSchema) {
         }
         async function runAsync() {
           if (path === void 0) {
-            const result = await rootSchema.safeParseAsync(
-              data
-            );
+            let result;
+            try {
+              result = await rootSchema.safeParseAsync(
+                data
+              );
+            } catch (err) {
+              return validatorThrewResponse(err, []);
+            }
             return result.success ? { data: result.data, errors: void 0, success: true, formKey } : {
               data: void 0,
               errors: zodIssuesToValidationErrors(result.error.issues, formKey),
@@ -1783,7 +1898,12 @@ function zodV4Adapter(rootSchema) {
           if (resolved.length === 0) return pathNotFound(path);
           const aggregated = [];
           for (const candidate of resolved) {
-            const result = await candidate.safeParseAsync(data);
+            let result;
+            try {
+              result = await candidate.safeParseAsync(data);
+            } catch (err) {
+              return validatorThrewResponse(err, path);
+            }
             if (result.success) {
               return {
                 data: result.data,
@@ -1796,6 +1916,22 @@ function zodV4Adapter(rootSchema) {
           }
           return { data: void 0, errors: aggregated, success: false, formKey };
         }
+        function validatorThrewResponse(err, errPath) {
+          const message = err instanceof Error ? err.message : typeof err === "string" ? err : "Validator threw";
+          return {
+            data: void 0,
+            errors: [
+              {
+                message,
+                path: [...errPath],
+                formKey,
+                code: AttaformErrorCode.ValidatorThrew
+              }
+            ],
+            success: false,
+            formKey
+          };
+        }
         function pathNotFound(p) {
           return {
             data: void 0,
@@ -1969,6 +2105,7 @@ function walkForMeta(schema, path, map, counters, lastPathPerSchema, inProgress)
       case "custom":
       case "template-literal":
       case "transform":
+      case "file":
         return;
     }
   } finally {
@@ -2027,4 +2164,4 @@ 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.CpERWz3u.mjs.map
+//# sourceMappingURL=attaform.Xt0A3QUd.mjs.map