attaform 0.30.1 → 0.31.1

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

@@ -1,7 +1,7 @@
-import { j as humanize, c as useAbstractForm } from './attaform-dev.DxHdkkPG.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 { c as callConsumerFn } from './attaform-dev.CZz4GYZ6.mjs';
+import { j as humanize, c as useAbstractForm } from './attaform-dev.3uTCYwy8.mjs';
+import { A as AttaformError, e as canonicalizePath, a as InvalidUseFormConfigError } from './attaform-dev.04aupFBW.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.PTGM9KE1.mjs';
+import { d as callConsumerFn } from './attaform-dev.CwYTWyPX.mjs';
 
 function readDef(schema) {
   if (schema === null || typeof schema !== "object") return void 0;
@@ -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);
@@ -183,6 +181,9 @@ function getDiscriminatedOptions(schema) {
   return Array.isArray(options) ? options : [];
 }
 function assertZodVersion(schema) {
+  assertZodV4Node(schema);
+}
+function assertZodV4Node(schema) {
   const def = readDef(schema);
   if (def?.type === void 0) {
     throw new Error(
@@ -202,60 +203,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 +214,60 @@ 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
-  );
+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.some(isVerdictCheck) && 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 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
-  );
+function isVerdictCheck(check) {
+  if (typeof check !== "object" || check === null) return true;
+  const kind = check._zod?.def?.check;
+  return kind !== "describe" && kind !== "meta";
 }
 function isAsyncCheck(check) {
   if (typeof check !== "object" || check === null) return false;
@@ -356,17 +332,14 @@ function zodIssuesToValidationErrors(issues) {
 
 const V4_INTROSPECTOR = {
   kindOf: (schema) => kindOf(schema),
-  getObjectShape: (schema) => getObjectShape(schema),
+  getObjectShape,
   getTupleItems,
-  getDiscriminatedOptions: (schema) => getDiscriminatedOptions(schema),
+  getDiscriminatedOptions,
   getDiscriminator,
   getLiteralValues,
   isPreprocessNode,
   isCoercePrimitive,
-  containsAsyncRefine,
-  containsAsyncTransform,
-  containsDiscriminatedUnion,
-  hasContainerOrRootRefine,
+  capabilitiesOf,
   // Walker accessors (D2 / D3 / D5).
   getArrayElement: (schema) => {
     if (kindOf(schema) !== "array") return void 0;
@@ -393,7 +366,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) {
@@ -525,7 +498,7 @@ function isLeafRequired(schema, depth = 0) {
   return true;
 }
 function zodV4Adapter(rootSchema) {
-  assertZodVersion(rootSchema);
+  assertZodV4Node(rootSchema);
   assertKeyedRoot(rootSchema);
   return (_formKey, options) => sharedV4Schemas(
     rootSchema,
@@ -549,6 +522,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 +541,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);
@@ -647,7 +619,8 @@ function resolveFieldMetaAtPath(rootSchema, path, maxRecursionDepth) {
   };
 }
 function readDescription(schema) {
-  const candidate = schema.description;
+  const scope = globalThis;
+  const candidate = scope.__zod_globalRegistry?.get(schema)?.description ?? schema.description;
   return typeof candidate === "string" ? candidate : void 0;
 }
 

package/dist/dev/shared/{attaform-dev.Chm4D6SJ.mjs → attaform-dev.Bu6wgrA5.mjs}

@@ -1,4 +1,4 @@
-import { c as RegistryNotInstalledError, O as OutsideSetupError, g as pathKeyToDotted } from './attaform-dev.zlvDr0WB.mjs';
+import { c as RegistryNotInstalledError, O as OutsideSetupError, g as pathKeyToDotted } from './attaform-dev.04aupFBW.mjs';
 import { shallowReactive, getCurrentInstance, inject } from 'vue';
 
 function detectSSR(options = {}) {
@@ -182,8 +182,8 @@ function renderAttaformState(app) {
         // The wire shape stays two per-source arrays; the tagged store
         // splits at the boundary and the client replays each side into
         // its cell half.
-        schemaErrors: [...state.errorCells.entries()].filter(([, cell]) => cell.schema.length > 0).map(([key2, cell]) => [key2, cell.schema]),
-        userErrors: [...state.errorCells.entries()].filter(([, cell]) => cell.user.length > 0).map(([key2, cell]) => [key2, cell.user]),
+        schemaErrors: [...state.errorCells().entries()].filter(([, cell]) => cell.schema.length > 0).map(([key2, cell]) => [key2, cell.schema]),
+        userErrors: [...state.errorCells().entries()].filter(([, cell]) => cell.user.length > 0).map(([key2, cell]) => [key2, cell.user]),
         fields: Array.from(state.fields.entries()),
         ...transientList.length > 0 ? { blankPaths: transientList } : {}
       }