attaform 0.14.0 → 0.15.1

package/dist/zod.cjs

@@ -1,9 +1,31 @@
 'use strict';
 
-const useFormContext = require('./shared/attaform.CNJO3mME.cjs');
-const paths = require('./shared/attaform.xKWYHMdq.cjs');
-const sensitiveNames = require('./shared/attaform.B5GWYl76.cjs');
+const useFormContext = require('./shared/attaform.CDJVeoJU.cjs');
 const zod = require('zod');
+const paths = require('./shared/attaform.BOi138GE.cjs');
+const sensitiveNames = require('./shared/attaform.RypIkgVy.cjs');
+
+const fieldMeta = zod.z.registry();
+const fieldMetaLists = /* @__PURE__ */ new WeakMap();
+const originalAdd = fieldMeta.add.bind(fieldMeta);
+fieldMeta.add = function add(schema, payload) {
+  const list = fieldMetaLists.get(schema) ?? [];
+  list.push(payload);
+  fieldMetaLists.set(schema, list);
+  return originalAdd(schema, payload);
+};
+function getFieldMetaList(schema) {
+  return fieldMetaLists.get(schema) ?? [];
+}
+function withMeta(schema, payload) {
+  const existing = fieldMeta.get(schema) ?? {};
+  const cloned = schema.clone();
+  fieldMeta.add(cloned, { ...existing, ...payload });
+  return cloned;
+}
+function getFieldMeta(schema) {
+  return fieldMeta.get(schema);
+}
 
 let warnedZodCodeMissing = false;
 function zodIssuesToValidationErrors(issues, formKey) {
@@ -839,7 +861,9 @@ function walkSegments(schema, segments) {
 function carryChecks(rebuilt, original, stripConfig) {
   if (stripConfig.stripRefinements === true) return rebuilt;
   if (!hasChecks(original)) return rebuilt;
-  const checks = getChecks(original);
+  const all = getChecks(original);
+  const checks = stripConfig.shouldKeepCheck === void 0 ? all : all.filter(stripConfig.shouldKeepCheck);
+  if (checks.length === 0) return rebuilt;
   return rebuilt.check(
     ...checks
   );
@@ -944,6 +968,131 @@ function stripRefinements(schema) {
     }
   }
 }
+function stripAsyncChecks(schema) {
+  const config = {
+    stripRefinements: false,
+    shouldKeepCheck: (c) => !isAsyncCheck(c)
+  };
+  const seen = /* @__PURE__ */ new WeakSet();
+  function recurse(s) {
+    if (seen.has(s)) return s;
+    seen.add(s);
+    const kind = kindOf(s);
+    switch (kind) {
+      case "string":
+        return hasChecks(s) ? carryChecks(zod.z.string(), s, config) : s;
+      case "number":
+        return hasChecks(s) ? carryChecks(zod.z.number(), s, config) : s;
+      case "bigint":
+        return hasChecks(s) ? carryChecks(zod.z.bigint(), s, config) : s;
+      case "array": {
+        const element = getArrayElement(s);
+        return carryChecks(zod.z.array(recurse(element)), s, config);
+      }
+      case "set": {
+        const valueType = getSetValueType(s);
+        return carryChecks(zod.z.set(recurse(valueType)), s, config);
+      }
+      case "tuple": {
+        const items = getTupleItems(s).map(recurse);
+        const rebuilt = zod.z.tuple(
+          items
+        );
+        return carryChecks(rebuilt, s, config);
+      }
+      case "object": {
+        const shape = getObjectShape(s);
+        const next = {};
+        for (const [k, v] of Object.entries(shape)) {
+          next[k] = recurse(v);
+        }
+        return carryChecks(zod.z.object(next), s, config);
+      }
+      case "record": {
+        const keyType = getRecordKeyType(s);
+        const valueType = recurse(getRecordValueType(s));
+        const rebuilt = zod.z.record(keyType, valueType);
+        return carryChecks(rebuilt, s, config);
+      }
+      case "union": {
+        const options = getUnionOptions(s).map(recurse);
+        const rebuilt = zod.z.union(
+          options
+        );
+        return carryChecks(rebuilt, s, config);
+      }
+      case "discriminated-union": {
+        const options = getDiscriminatedOptions(s).map((opt) => recurse(opt));
+        const discriminator = getDiscriminator(s);
+        if (discriminator === void 0) return s;
+        return zod.z.discriminatedUnion(
+          discriminator,
+          options
+        );
+      }
+      case "optional": {
+        const inner = unwrapInner(s);
+        if (inner === void 0) return s;
+        return recurse(inner).optional();
+      }
+      case "nullable": {
+        const inner = unwrapInner(s);
+        if (inner === void 0) return s;
+        return recurse(inner).nullable();
+      }
+      case "default": {
+        const inner = unwrapInner(s);
+        if (inner === void 0) return s;
+        return recurse(inner).default(getDefaultValue(s));
+      }
+      case "readonly": {
+        const inner = unwrapInner(s);
+        if (inner === void 0) return s;
+        return recurse(inner).readonly();
+      }
+      case "pipe":
+        return s;
+      case "lazy": {
+        const inner = unwrapLazy(s);
+        if (inner === void 0) return s;
+        const stripped = recurse(inner);
+        return zod.z.lazy(() => stripped);
+      }
+      case "intersection": {
+        const left = getIntersectionLeft(s);
+        const right = getIntersectionRight(s);
+        if (left === void 0 || right === void 0) return s;
+        return zod.z.intersection(recurse(left), recurse(right));
+      }
+      case "catch": {
+        const inner = unwrapInner(s);
+        if (inner === void 0) return s;
+        return recurse(inner).catch(getCatchDefault(s));
+      }
+      // Leaves with no checks — pass through unchanged.
+      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":
+        return s;
+      default: {
+        const _exhaustive = kind;
+        throw new Error(`stripAsyncChecks: unhandled ZodKind '${_exhaustive}'`);
+      }
+    }
+  }
+  return recurse(schema);
+}
 function getSlimSchema(schema, stripConfig) {
   const kind = kindOf(schema);
   switch (kind) {
@@ -1352,7 +1501,21 @@ function zodV4Adapter(rootSchema) {
               formKey
             };
           } catch {
-            return { data, errors: void 0, success: true, formKey };
+            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 };
@@ -1426,6 +1589,9 @@ function zodV4Adapter(rootSchema) {
         if (resolved.length === 0) return false;
         return resolved.every((candidate) => isLeafRequired(candidate));
       },
+      getFieldMetaAtPath(path) {
+        return resolveFieldMetaAtPath(rootSchema, path);
+      },
       getUnionDiscriminatorAtPath(path) {
         const candidates = path.length === 0 ? [rootSchema] : getNestedZodSchemasAtPath(rootSchema, path);
         let matchedUnion;
@@ -1526,6 +1692,203 @@ function zodV4Adapter(rootSchema) {
     };
   };
 }
+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":
+        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) {
+  const lastSegment = path.length === 0 ? "" : path[path.length - 1];
+  const candidates = path.length === 0 ? [rootSchema] : getNestedZodSchemasAtPath(rootSchema, path);
+  const target = candidates[0];
+  if (target === void 0) {
+    return {
+      label: useFormContext.humanize(lastSegment),
+      description: void 0,
+      placeholder: void 0,
+      meta: Object.freeze({})
+    };
+  }
+  const pathMap = getPathMetaMap(rootSchema);
+  const pathKey = paths.canonicalizePath(path).key;
+  const peeled = peelAllWrappers(target);
+  const payload = pathMap.get(pathKey) ?? getFieldMeta(target) ?? (peeled !== target ? getFieldMeta(peeled) : void 0);
+  const targetDescription = readDescription(target);
+  const peeledDescription = peeled !== target ? readDescription(peeled) : void 0;
+  const schemaDescription = targetDescription ?? peeledDescription;
+  return {
+    label: payload?.label ?? useFormContext.humanize(lastSegment),
+    description: payload?.description ?? schemaDescription ?? void 0,
+    placeholder: payload?.placeholder ?? void 0,
+    meta: Object.freeze({ ...payload ?? {} })
+  };
+}
+function readDescription(schema) {
+  const candidate = schema.description;
+  return typeof candidate === "string" ? candidate : void 0;
+}
 
 function useForm(configuration) {
   const adapter = zodV4Adapter(
@@ -1543,6 +1906,10 @@ exports.isUnset = useFormContext.isUnset;
 exports.unset = useFormContext.unset;
 exports.useRegister = sensitiveNames.useRegister;
 exports.UnsupportedSchemaError = UnsupportedSchemaError;
+exports.assertZodVersion = assertZodVersion;
+exports.fieldMeta = fieldMeta;
+exports.kindOf = kindOf;
 exports.useForm = useForm;
+exports.withMeta = withMeta;
 exports.zodAdapter = zodV4Adapter;
 //# sourceMappingURL=zod.cjs.map