attaform 0.30.1 → 0.31.0

package/dist/dev/shared/{attaform-dev.BJK1kqHY.mjs → attaform-dev.DJ3nsWw6.mjs}

@@ -1,6 +1,6 @@
-import { j as humanize, c as useAbstractForm } from './attaform-dev.DxHdkkPG.mjs';
+import { j as humanize, c as useAbstractForm } from './attaform-dev.y9x9Vp9F.mjs';
 import { A as AttaformError, e as canonicalizePath, a as InvalidUseFormConfigError } from './attaform-dev.zlvDr0WB.mjs';
-import { s as slimPrimitivesWalk, d as deriveDefaultWalk, m as mergeDeep, f as fixStructuralDefaults, w as walkPathSegments, c as createAbstractSchema, a as createSharedSchemaStore, b as buildFieldMetaPathMap, e as getFieldMetaListForSchema, g as getFieldMetaForSchema } from './attaform-dev.BUIFcTYf.mjs';
+import { s as slimPrimitivesWalk, d as deriveDefaultWalk, m as mergeDeep, f as fixStructuralDefaults, w as walkPathSegments, c as createAbstractSchema, a as createSharedSchemaStore, b as buildFieldMetaPathMap, e as getFieldMetaListForSchema, g as getFieldMetaForSchema } from './attaform-dev.Caibt7sb.mjs';
 import { c as callConsumerFn } from './attaform-dev.CZz4GYZ6.mjs';
 
 function readDef(schema) {
@@ -119,9 +119,7 @@ function isCoercePrimitive(schema) {
   return readDef(schema)?.coerce === true;
 }
 function isPreprocessNode(schema) {
-  if (kindOf(schema) !== "pipe") return false;
-  const pipeIn = unwrapPipeIn(schema);
-  return pipeIn !== void 0 && kindOf(pipeIn) === "transform";
+  return kindOf(schema) === "pipe" && kindOf(readDef(schema)?.in) === "transform";
 }
 function unwrapPipeOut(schema) {
   const def = readDef(schema);
@@ -202,60 +200,6 @@ const DESCEND_SINGLE = [
 ];
 const DESCEND_RECORD = ["shape", "entries"];
 const DESCEND_LIST = ["options", "items"];
-function walkSchemaTree(schema, visit, 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);
-  if (visit(schema)) return true;
-  const def = readDef(schema);
-  if (def === void 0) return false;
-  const slots = def;
-  for (const key of DESCEND_SINGLE) {
-    const child = slots[key];
-    if (child !== void 0 && walkSchemaTree(child, visit, visited)) return true;
-  }
-  for (const key of DESCEND_RECORD) {
-    const record = slots[key];
-    if (record !== void 0) {
-      for (const sub of Object.values(record)) {
-        if (walkSchemaTree(sub, visit, visited)) return true;
-      }
-    }
-  }
-  for (const key of DESCEND_LIST) {
-    const list = slots[key];
-    if (list !== void 0) {
-      for (const sub of list) {
-        if (walkSchemaTree(sub, visit, visited)) return true;
-      }
-    }
-  }
-  if (typeof def.getter === "function") {
-    try {
-      const inner = def.getter();
-      if (walkSchemaTree(inner, visit, visited)) return true;
-    } catch {
-    }
-  }
-  return false;
-}
-function containsDiscriminatedUnion(schema, seen) {
-  return walkSchemaTree(schema, (node) => kindOf(node) === "discriminated-union", seen);
-}
-function containsAsyncRefine(schema, seen) {
-  return walkSchemaTree(
-    schema,
-    (node) => {
-      for (const check of getChecks(node)) {
-        if (isAsyncCheck(check)) return true;
-      }
-      return false;
-    },
-    seen
-  );
-}
 const CONTAINER_SLOTS = [
   "shape",
   "entries",
@@ -267,31 +211,55 @@ const CONTAINER_SLOTS = [
   "left",
   "right"
 ];
-function hasContainerOrRootRefine(schema, seen) {
-  return walkSchemaTree(
-    schema,
-    (node) => {
-      const def = readDef(node);
-      if (def === void 0) return false;
-      const slots = def;
-      if (!CONTAINER_SLOTS.some((key) => slots[key] !== void 0)) return false;
-      return getChecks(node).length > 0;
-    },
-    seen
-  );
-}
-function containsAsyncTransform(schema, seen) {
-  return walkSchemaTree(
-    schema,
-    (node) => {
-      const def = readDef(node);
-      if (def === void 0) return false;
-      const fn = def.transform;
-      if (typeof fn !== "function") return false;
-      return fn.constructor.name === "AsyncFunction";
-    },
-    seen
-  );
+const capabilityMemo = /* @__PURE__ */ new WeakMap();
+function capabilitiesOf(schema) {
+  let capabilities = capabilityMemo.get(schema);
+  if (capabilities === void 0) {
+    capabilities = scanCapabilities(schema);
+    const key = schema;
+    if (typeof key === "object" && key !== null) capabilityMemo.set(key, capabilities);
+  }
+  return capabilities;
+}
+function scanCapabilities(schema) {
+  const capabilities = {
+    asyncRefine: false,
+    asyncTransform: false,
+    discriminatedUnion: false,
+    containerOrRootRefine: false,
+    preprocessOrCoerce: false
+  };
+  walkCapabilities(schema, capabilities, /* @__PURE__ */ new WeakSet());
+  return capabilities;
+}
+function walkCapabilities(node, capabilities, visited) {
+  if (typeof node !== "object" || node === null || visited.has(node)) return;
+  visited.add(node);
+  const def = readDef(node);
+  if (def === void 0) return;
+  const checks = getChecks(node);
+  if (checks.some(isAsyncCheck)) capabilities.asyncRefine = true;
+  if (checks.length > 0 && CONTAINER_SLOTS.some((key) => def[key] !== void 0)) {
+    capabilities.containerOrRootRefine = true;
+  }
+  if (typeof def.transform === "function" && def.transform.constructor.name === "AsyncFunction") {
+    capabilities.asyncTransform = true;
+  }
+  if (kindOf(node) === "discriminated-union") capabilities.discriminatedUnion = true;
+  if (isCoercePrimitive(node) || isPreprocessNode(node)) capabilities.preprocessOrCoerce = true;
+  for (const key of DESCEND_SINGLE) walkCapabilities(def[key], capabilities, visited);
+  for (const key of DESCEND_RECORD) {
+    for (const sub of Object.values(def[key] ?? {})) walkCapabilities(sub, capabilities, visited);
+  }
+  for (const key of DESCEND_LIST) {
+    for (const sub of def[key] ?? []) walkCapabilities(sub, capabilities, visited);
+  }
+  if (typeof def.getter === "function") {
+    try {
+      walkCapabilities(def.getter(), capabilities, visited);
+    } catch {
+    }
+  }
 }
 function isAsyncCheck(check) {
   if (typeof check !== "object" || check === null) return false;
@@ -363,10 +331,7 @@ const V4_INTROSPECTOR = {
   getLiteralValues,
   isPreprocessNode,
   isCoercePrimitive,
-  containsAsyncRefine,
-  containsAsyncTransform,
-  containsDiscriminatedUnion,
-  hasContainerOrRootRefine,
+  capabilitiesOf,
   // Walker accessors (D2 / D3 / D5).
   getArrayElement: (schema) => {
     if (kindOf(schema) !== "array") return void 0;
@@ -393,7 +358,7 @@ const V4_INTROSPECTOR = {
 };
 
 function slimPrimitivesOf(schema, maxRecursionDepth) {
-  return new Set(slimPrimitivesWalk(schema, V4_INTROSPECTOR, maxRecursionDepth));
+  return slimPrimitivesWalk(schema, V4_INTROSPECTOR, maxRecursionDepth);
 }
 
 function deriveDefault(schema, useDefault, maxRecursionDepth) {
@@ -549,6 +514,7 @@ function buildV4Services() {
     slimPrimitivesOf: (schema, maxRecursionDepth) => slimPrimitivesOf(schema, maxRecursionDepth),
     deriveDefault: (schema, useDefault, maxRecursionDepth) => deriveDefault(schema, useDefault, maxRecursionDepth),
     runGetDefaults: (schema, config, maxRecursionDepth) => runGetDefaultsV4(schema, config, maxRecursionDepth),
+    validateSync: (schema, data) => validateSyncV4(schema, data),
     unwrapStructuralWrappers: (schema) => unwrapStructuralWrappers(schema),
     unwrapToDiscriminatedUnion: (schema) => unwrapToDiscriminatedUnion(schema),
     peelAllWrappers: (schema) => peelAllWrappers(schema),
@@ -567,37 +533,35 @@ function buildV4Services() {
   };
 }
 function runGetDefaultsV4(rootSchema, config, maxRecursionDepth) {
-  const { data } = getDefaultValuesFromZodSchema({
+  return getDefaultValuesFromZodSchema({
     schema: rootSchema,
     useDefaultSchemaValues: config.useDefaultSchemaValues,
     constraints: config.constraints,
     maxRecursionDepth
-  });
-  if (containsAsyncTransform(rootSchema) || containsAsyncRefine(rootSchema)) {
-    return { data, errors: void 0, success: true };
-  }
+  }).data;
+}
+const verdictRan = /* @__PURE__ */ new WeakMap();
+function validateSyncV4(rootSchema, data) {
+  const { asyncRefine, asyncTransform } = capabilitiesOf(rootSchema);
+  if (asyncRefine || asyncTransform) return [];
   try {
-    const parseResult = rootSchema.safeParse(data);
-    if (parseResult.success) {
-      return { data, errors: void 0, success: true };
-    }
-    return {
-      data,
-      errors: zodIssuesToValidationErrors(parseResult.error.issues),
-      success: false
-    };
+    const jitless = !verdictRan.has(rootSchema);
+    if (jitless) verdictRan.set(rootSchema, true);
+    const parseResult = rootSchema.safeParse(data, { jitless });
+    return parseResult.success ? [] : zodIssuesToValidationErrors(parseResult.error.issues);
   } catch {
-    return { data, errors: void 0, success: true };
+    return [];
   }
 }
 function buildSubSchemaStubV4(schema, maxRecursionDepth) {
   return {
-    needsAsyncValidation: () => containsAsyncRefine(schema),
-    getDefaultValues: () => ({
-      data: deriveDefault(schema, true, maxRecursionDepth),
-      errors: void 0,
-      success: true
-    }),
+    // Async work of either kind, as the root's `needsAsyncValidation`
+    // counts it: the field's `valid` waits for the first async pass.
+    needsAsyncValidation: () => {
+      const { asyncRefine, asyncTransform } = scanCapabilities(schema);
+      return asyncRefine || asyncTransform;
+    },
+    getDefaultValues: () => deriveDefault(schema, true, maxRecursionDepth),
     getSchemasAtPath: () => [],
     validateAtPath: async (data) => {
       const result = await schema.safeParseAsync(data);

package/dist/dev/shared/{attaform-dev.DuEE4GU1.mjs → attaform-dev.DlaT4xGd.mjs}

@@ -1,7 +1,7 @@
 import { a as InvalidUseFormConfigError } from './attaform-dev.zlvDr0WB.mjs';
-import { u as useForm$2 } from './attaform-dev.CT7MDjPy.mjs';
-import { u as useForm$1 } from './attaform-dev.BJK1kqHY.mjs';
-import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './attaform-dev.BUIFcTYf.mjs';
+import { u as useForm$2 } from './attaform-dev.CtyqGia7.mjs';
+import { u as useForm$1 } from './attaform-dev.DJ3nsWw6.mjs';
+import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './attaform-dev.Caibt7sb.mjs';
 
 function isZodV4SchemaShape(value) {
   if (typeof value !== "object" || value === null) return false;