attaform 0.28.0 → 0.30.0

package/dist/shared/{attaform.NLmerepI.mjs → attaform.BXneBxEj.mjs}

@@ -1,29 +1,7 @@
-import { o as humanize, h as useAbstractForm } from './attaform.B8k8JrmK.mjs';
-import { A as AttaformError, e as canonicalizePath, a as InvalidUseFormConfigError } from './attaform.wfY8XFvm.mjs';
-import { s as slimPrimitivesWalk, d as deriveDefaultWalk, m as mergeDeep, f as fixStructuralDefaults, w as walkPathSegments, c as createAbstractSchema, b as buildFieldMetaPathMap, a as getFieldMetaListForSchema, g as getFieldMetaForSchema } from './attaform.C09fpdLS.mjs';
-import { z } from 'zod';
-
-function zodIssuesToValidationErrors(issues) {
-  return issues.map((issue) => {
-    let code;
-    if (typeof issue.code === "string" && issue.code.length > 0) {
-      code = `zod:${issue.code}`;
-    } else {
-      code = "zod:unknown";
-    }
-    return {
-      message: issue.message,
-      // Adapter-side paths stay schema-relative — the validation
-      // pipeline in `create-form-store.ts` prepends the parent path
-      // to absolutise, then routes form-level (absolute path length 0)
-      // entries to the empty-string bucket at storage time.
-      path: issue.path.map((seg) => typeof seg === "number" ? seg : String(seg)),
-      code
-    };
-  });
-}
-class UnsupportedSchemaError extends AttaformError {
-}
+import { j as humanize, c as useAbstractForm } from './attaform.DNJOWjQw.mjs';
+import { A as AttaformError, e as canonicalizePath, a as InvalidUseFormConfigError } from './attaform.CdZIEf7_.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.CUfrMK7t.mjs';
+import { c as callConsumerSchemaFn } from './attaform.BRDDQeHV.mjs';
 
 function readDef(schema) {
   if (schema === null || typeof schema !== "object") return void 0;
@@ -70,7 +48,9 @@ const IDENTITY_KINDS = /* @__PURE__ */ new Set([
   "file",
   "map",
   "symbol",
-  "function"
+  "function",
+  "nonoptional",
+  "success"
 ]);
 function kindOf(schema) {
   const def = readDef(schema);
@@ -103,6 +83,8 @@ function getRecordValueType(schema) {
   const def = readDef(schema);
   return def?.valueType;
 }
+const getMapKeyType = getRecordKeyType;
+const getMapValueType = getRecordValueType;
 function getTupleItems(schema) {
   const def = readDef(schema);
   return def?.items ?? [];
@@ -149,11 +131,7 @@ function unwrapLazy(schema) {
   const def = readDef(schema);
   const getter = def?.getter;
   if (typeof getter !== "function") return void 0;
-  return getter();
-}
-function getLazyGetter(schema) {
-  const def = readDef(schema);
-  return typeof def?.getter === "function" ? def.getter : void 0;
+  return callConsumerSchemaFn(() => getter(), void 0);
 }
 function getIntersectionLeft(schema) {
   const def = readDef(schema);
@@ -167,11 +145,9 @@ function getCatchDefault(schema) {
   const def = readDef(schema);
   const cv = def?.catchValue;
   if (typeof cv !== "function") return void 0;
-  try {
-    return cv({ error: new Error("atta:default-values"), input: void 0 });
-  } catch {
-    return void 0;
-  }
+  return callConsumerSchemaFn(
+    () => cv({ error: new Error("atta:default-values"), input: void 0 }),
+    void 0);
 }
 function hasCatchValue(schema) {
   const def = readDef(schema);
@@ -179,7 +155,7 @@ function hasCatchValue(schema) {
 }
 function getDefaultValue(schema) {
   const def = readDef(schema);
-  return def?.defaultValue;
+  return callConsumerSchemaFn(() => def?.defaultValue, void 0);
 }
 function getNativeEnumValues(_schema) {
   return void 0;
@@ -190,11 +166,6 @@ function unwrapEffectsSource(_schema) {
 function unwrapBranded(_schema) {
   return void 0;
 }
-function hasChecks(schema) {
-  const def = readDef(schema);
-  const checks = def?.checks;
-  return Array.isArray(checks) && checks.length > 0;
-}
 function getChecks(schema) {
   const def = readDef(schema);
   const checks = def?.checks;
@@ -328,123 +299,6 @@ function isAsyncCheck(check) {
   return fn.constructor.name === "AsyncFunction";
 }
 
-const UNSUPPORTED = [
-  "promise",
-  "custom",
-  "template-literal",
-  "map",
-  "symbol",
-  "function"
-];
-function labelPath(path) {
-  return path.length === 0 ? "<root>" : path.join(".");
-}
-function assertSupportedKinds(schema, path = [], lazyGetters = []) {
-  const kind = kindOf(schema);
-  if (UNSUPPORTED.includes(kind)) {
-    throw new UnsupportedSchemaError(
-      `[attaform] AF02 attaform.dev/e/af02 '${kind}' at '${labelPath(path)}'`
-    );
-  }
-  switch (kind) {
-    case "object": {
-      const shape = getObjectShape(schema);
-      for (const [key, sub] of Object.entries(shape)) {
-        assertSupportedKinds(sub, [...path, key], lazyGetters);
-      }
-      return;
-    }
-    case "array":
-      assertSupportedKinds(getArrayElement(schema), [...path, "*"], lazyGetters);
-      return;
-    case "set":
-      assertSupportedKinds(getSetValueType(schema), [...path, "*"], lazyGetters);
-      return;
-    case "record":
-      assertSupportedKinds(getRecordValueType(schema), [...path, "*"], lazyGetters);
-      return;
-    case "tuple": {
-      const items = getTupleItems(schema);
-      items.forEach((item, i) => assertSupportedKinds(item, [...path, String(i)], lazyGetters));
-      return;
-    }
-    case "union": {
-      const options = getUnionOptions(schema);
-      options.forEach((opt, i) => assertSupportedKinds(opt, [...path, `|${i}`], lazyGetters));
-      return;
-    }
-    case "discriminated-union": {
-      const options = getDiscriminatedOptions(schema);
-      options.forEach((opt, i) => assertSupportedKinds(opt, [...path, `|${i}`], lazyGetters));
-      return;
-    }
-    case "optional":
-    case "nullable":
-    case "default":
-    case "readonly":
-    case "catch": {
-      const inner = unwrapInner(schema);
-      if (inner !== void 0) assertSupportedKinds(inner, path, lazyGetters);
-      return;
-    }
-    case "pipe": {
-      const inner = unwrapPipe(schema);
-      if (inner !== void 0) assertSupportedKinds(inner, path, lazyGetters);
-      return;
-    }
-    case "lazy": {
-      const getter = getLazyGetter(schema);
-      if (getter !== void 0 && lazyGetters.includes(getter)) return;
-      const inner = unwrapLazy(schema);
-      if (inner !== void 0) {
-        assertSupportedKinds(
-          inner,
-          path,
-          getter === void 0 ? lazyGetters : [...lazyGetters, getter]
-        );
-      }
-      return;
-    }
-    case "intersection": {
-      const left = getIntersectionLeft(schema);
-      const right = getIntersectionRight(schema);
-      if (left !== void 0) assertSupportedKinds(left, [...path, "left"], lazyGetters);
-      if (right !== void 0) assertSupportedKinds(right, [...path, "right"], lazyGetters);
-      return;
-    }
-    // Leaves: nothing to descend into.
-    case "string":
-    case "number":
-    case "boolean":
-    case "bigint":
-    case "date":
-    case "enum":
-    case "literal":
-    case "null":
-    case "undefined":
-    case "nan":
-    case "any":
-    case "unknown":
-    case "void":
-    case "never":
-    case "promise":
-    case "custom":
-    case "template-literal":
-    case "transform":
-    case "file":
-    case "map":
-    case "symbol":
-    case "function":
-      return;
-    default: {
-      const _exhaustive = kind;
-      throw new Error(
-        `[attaform] AF03 attaform.dev/e/af03 '${_exhaustive}'`
-      );
-    }
-  }
-}
-
 function unwrapToDiscriminatedUnion(schema) {
   let current = schema;
   for (let i = 0; i < 64; i++) {
@@ -471,6 +325,26 @@ function unwrapToDiscriminatedUnion(schema) {
   return void 0;
 }
 
+function zodIssuesToValidationErrors(issues) {
+  return issues.map((issue) => {
+    let code;
+    if (typeof issue.code === "string" && issue.code.length > 0) {
+      code = `zod:${issue.code}`;
+    } else {
+      code = "zod:unknown";
+    }
+    return {
+      message: issue.message,
+      // Adapter-side paths stay schema-relative — the validation
+      // pipeline in `create-form-store.ts` prepends the parent path
+      // to absolutise, then routes form-level (absolute path length 0)
+      // entries to the empty-string bucket at storage time.
+      path: issue.path.map((seg) => typeof seg === "number" ? seg : String(seg)),
+      code
+    };
+  });
+}
+
 const V4_INTROSPECTOR = {
   kindOf: (schema) => kindOf(schema),
   getObjectShape: (schema) => getObjectShape(schema),
@@ -490,8 +364,9 @@ const V4_INTROSPECTOR = {
     return getArrayElement(schema);
   },
   getSetValueType: (schema) => kindOf(schema) === "set" ? getSetValueType(schema) : void 0,
-  getRecordKeyType: (schema) => kindOf(schema) === "record" ? getRecordKeyType(schema) : void 0,
   getRecordValueType: (schema) => kindOf(schema) === "record" ? getRecordValueType(schema) : void 0,
+  getMapKeyType: (schema) => kindOf(schema) === "map" ? getMapKeyType(schema) : void 0,
+  getMapValueType: (schema) => kindOf(schema) === "map" ? getMapValueType(schema) : void 0,
   getUnionOptions,
   getIntersectionLeft,
   getIntersectionRight,
@@ -503,7 +378,6 @@ const V4_INTROSPECTOR = {
   unwrapPipeIn,
   unwrapPipeOut,
   unwrapLazy,
-  getLazyGetter,
   getDefaultValue,
   getCatchDefault,
   hasCatchValue
@@ -514,15 +388,12 @@ function slimPrimitivesOf(schema, maxRecursionDepth) {
 }
 
 function deriveDefault(schema, useDefault, maxRecursionDepth) {
-  return deriveDefaultWalk(schema, useDefault, V4_INTROSPECTOR, maxRecursionDepth, {
-    // v4 has an exhaustive switch against `SchemaIntrospector.kindOf`;
-    // unknown kinds genuinely shouldn't appear, so return undefined.
-    unsupportedKindFallback: () => void 0
-  });
+  return deriveDefaultWalk(schema, useDefault, V4_INTROSPECTOR, maxRecursionDepth);
 }
 function getDefaultValuesFromZodSchema(opts) {
   const { schema, useDefaultSchemaValues, constraints, maxRecursionDepth } = opts;
   const initial = deriveDefault(schema, useDefaultSchemaValues, maxRecursionDepth);
+  if (constraints === void 0) return { data: initial, success: true };
   const merged = mergeDeep(initial, constraints);
   return fixStructuralDefaults(
     schema,
@@ -554,137 +425,6 @@ function getNestedZodSchemasAtPath(schema, path, maxRecursionDepth) {
   );
 }
 
-function carrySyncChecks(rebuilt, original) {
-  if (!hasChecks(original)) return rebuilt;
-  const checks = getChecks(original).filter((c) => !isAsyncCheck(c));
-  if (checks.length === 0) return rebuilt;
-  return rebuilt.check(
-    ...checks
-  );
-}
-function stripAsyncChecks(schema) {
-  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) ? carrySyncChecks(z.string(), s) : s;
-      case "number":
-        return hasChecks(s) ? carrySyncChecks(z.number(), s) : s;
-      case "bigint":
-        return hasChecks(s) ? carrySyncChecks(z.bigint(), s) : s;
-      case "array": {
-        const element = getArrayElement(s);
-        return carrySyncChecks(z.array(recurse(element)), s);
-      }
-      case "set": {
-        return carrySyncChecks(z.set(recurse(getSetValueType(s))), s);
-      }
-      case "tuple": {
-        const items = getTupleItems(s).map(recurse);
-        const rebuilt = z.tuple(
-          items
-        );
-        return carrySyncChecks(rebuilt, s);
-      }
-      case "object": {
-        const shape = getObjectShape(s);
-        const next = {};
-        for (const [k, v] of Object.entries(shape)) {
-          next[k] = recurse(v);
-        }
-        return carrySyncChecks(z.object(next), s);
-      }
-      case "record": {
-        const keyType = getRecordKeyType(s);
-        const valueType = recurse(getRecordValueType(s));
-        return carrySyncChecks(
-          z.record(keyType, valueType),
-          s
-        );
-      }
-      case "union": {
-        const options = getUnionOptions(s).map(recurse);
-        return carrySyncChecks(
-          z.union(options),
-          s
-        );
-      }
-      case "discriminated-union": {
-        const options = getDiscriminatedOptions(s).map((opt) => recurse(opt));
-        const discriminator = getDiscriminator(s);
-        if (discriminator === void 0) return s;
-        return z.discriminatedUnion(
-          discriminator,
-          options
-        );
-      }
-      case "optional": {
-        const inner = unwrapInner(s);
-        return inner === void 0 ? s : recurse(inner).optional();
-      }
-      case "nullable": {
-        const inner = unwrapInner(s);
-        return inner === void 0 ? s : 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);
-        return inner === void 0 ? s : recurse(inner).readonly();
-      }
-      case "lazy": {
-        const inner = unwrapLazy(s);
-        if (inner === void 0) return s;
-        const stripped = recurse(inner);
-        return z.lazy(() => stripped);
-      }
-      case "intersection": {
-        const left = getIntersectionLeft(s);
-        const right = getIntersectionRight(s);
-        if (left === void 0 || right === void 0) return s;
-        return z.intersection(recurse(left), recurse(right));
-      }
-      case "catch": {
-        const inner = unwrapInner(s);
-        if (inner === void 0) return s;
-        return recurse(inner).catch(getCatchDefault(s));
-      }
-      // Pipes pass through (see the docblock); the rest are leaves
-      // whose checks the strip walker deliberately leaves in place —
-      // an async check on one of these still poisons the sync parse
-      // and the callers' defensive catch owns that case.
-      case "pipe":
-      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":
-      case "transform":
-      case "file":
-      case "map":
-      case "symbol":
-      case "function":
-        return s;
-    }
-  }
-  return recurse(schema);
-}
-
 function unwrapStructuralWrappers(schema) {
   let current = schema;
   for (let i = 0; i < 64; i++) {
@@ -697,6 +437,13 @@ function unwrapStructuralWrappers(schema) {
   }
   return current;
 }
+function assertKeyedRoot(rootSchema) {
+  const kind = kindOf(peelAllWrappers(rootSchema));
+  if (kind === "object" || kind === "record" || kind === "discriminated-union") return;
+  throw new AttaformError(
+    `[attaform] AF15 attaform.dev/e/af15 '${kind}'`
+  );
+}
 function peelAllWrappers(schema) {
   let current = schema;
   for (let i = 0; i < 64; i++) {
@@ -770,22 +517,21 @@ function isLeafRequired(schema, depth = 0) {
 }
 function zodV4Adapter(rootSchema) {
   assertZodVersion(rootSchema);
-  assertSupportedKinds(rootSchema);
-  return (formKey, options) => createAbstractSchema(
+  assertKeyedRoot(rootSchema);
+  return (_formKey, options) => sharedV4Schemas(
     rootSchema,
-    V4_INTROSPECTOR,
-    buildV4Services(),
-    formKey,
-    options
+    options.maxRecursionDepth,
+    () => createAbstractSchema(
+      rootSchema,
+      V4_INTROSPECTOR,
+      buildV4Services(),
+      options
+    )
   );
 }
-async function lazyFingerprint(schema) {
-  const { fingerprintZodSchema } = await import('../chunks/fingerprint2.mjs');
-  return fingerprintZodSchema(schema);
-}
+const sharedV4Schemas = createSharedSchemaStore();
 function buildV4Services() {
   return {
-    fingerprint: (schema) => lazyFingerprint(schema),
     getNestedSchemasAtPath: (schema, path, maxRecursionDepth) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth),
     // v4 doesn't pre-strip for the slim-mode walk — its path walker
     // already peels every transparent wrapper inline, so the slim and
@@ -793,7 +539,7 @@ function buildV4Services() {
     getNestedSchemasInSlimMode: (schema, path, maxRecursionDepth) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth),
     slimPrimitivesOf: (schema, maxRecursionDepth) => slimPrimitivesOf(schema, maxRecursionDepth),
     deriveDefault: (schema, useDefault, maxRecursionDepth) => deriveDefault(schema, useDefault, maxRecursionDepth),
-    runStrictGetDefaults: (schema, config, fk, maxRecursionDepth) => runStrictGetDefaultsV4(schema, config, fk, maxRecursionDepth),
+    runGetDefaults: (schema, config, maxRecursionDepth) => runGetDefaultsV4(schema, config, maxRecursionDepth),
     unwrapStructuralWrappers: (schema) => unwrapStructuralWrappers(schema),
     unwrapToDiscriminatedUnion: (schema) => unwrapToDiscriminatedUnion(schema),
     peelAllWrappers: (schema) => peelAllWrappers(schema),
@@ -808,47 +554,40 @@ function buildV4Services() {
       const result = await schema.safeParseAsync(data);
       return result.success ? { success: true, data: result.data } : { success: false, issues: result.error.issues };
     },
-    makeSubSchema: (schema, fk, maxRecursionDepth) => buildSubSchemaStubV4(schema, fk, maxRecursionDepth)
+    makeSubSchema: (schema, maxRecursionDepth) => buildSubSchemaStubV4(schema, maxRecursionDepth)
   };
 }
-function runStrictGetDefaultsV4(rootSchema, config, formKey, maxRecursionDepth) {
+function runGetDefaultsV4(rootSchema, config, maxRecursionDepth) {
   const { data } = getDefaultValuesFromZodSchema({
     schema: rootSchema,
     useDefaultSchemaValues: config.useDefaultSchemaValues,
     constraints: config.constraints,
     maxRecursionDepth
   });
-  if (config.strict === false) {
-    return { data, errors: void 0, success: true, formKey };
-  }
-  if (containsAsyncTransform(rootSchema)) {
-    return { data, errors: void 0, success: true, formKey };
+  if (containsAsyncTransform(rootSchema) || containsAsyncRefine(rootSchema)) {
+    return { data, errors: void 0, success: true };
   }
-  const parseTarget = containsAsyncRefine(rootSchema) ? stripAsyncChecks(rootSchema) : rootSchema;
   try {
-    const strictResult = parseTarget.safeParse(data);
-    if (strictResult.success) {
-      return { data, errors: void 0, success: true, formKey };
+    const parseResult = rootSchema.safeParse(data);
+    if (parseResult.success) {
+      return { data, errors: void 0, success: true };
     }
     return {
       data,
-      errors: zodIssuesToValidationErrors(strictResult.error.issues),
-      success: false,
-      formKey
+      errors: zodIssuesToValidationErrors(parseResult.error.issues),
+      success: false
     };
   } catch {
-    return { data, errors: void 0, success: true, formKey };
+    return { data, errors: void 0, success: true };
   }
 }
-function buildSubSchemaStubV4(schema, formKey, maxRecursionDepth) {
+function buildSubSchemaStubV4(schema, maxRecursionDepth) {
   return {
-    fingerprint: () => lazyFingerprint(schema),
     needsAsyncValidation: () => containsAsyncRefine(schema),
     getDefaultValues: () => ({
       data: deriveDefault(schema, true, maxRecursionDepth),
       errors: void 0,
-      success: true,
-      formKey
+      success: true
     }),
     getSchemasAtPath: () => [],
     validateAtPath: async (data) => {
@@ -857,15 +596,13 @@ function buildSubSchemaStubV4(schema, formKey, maxRecursionDepth) {
         return {
           data: result.data,
           errors: void 0,
-          success: true,
-          formKey
+          success: true
         };
       }
       return {
         data: void 0,
         errors: zodIssuesToValidationErrors(result.error.issues),
-        success: false,
-        formKey
+        success: false
       };
     }
   };
@@ -917,4 +654,4 @@ function useForm(configuration) {
   });
 }
 
-export { UnsupportedSchemaError as U, assertZodVersion as a, getIntersectionRight as b, unwrapLazy as c, unwrapInner as d, unwrapPipe as e, getDiscriminator as f, getIntersectionLeft as g, getDiscriminatedOptions as h, getUnionOptions as i, getRecordKeyType as j, kindOf as k, getRecordValueType as l, getTupleItems as m, getSetValueType as n, getArrayElement as o, getObjectShape as p, getEnumValues as q, getLiteralValues as r, getChecks as s, getCatchDefault as t, useForm as u, getDefaultValue as v, zodV4Adapter as z };
+export { assertZodVersion as a, kindOf as k, useForm as u, zodV4Adapter as z };

package/dist/shared/{attaform.D6DCnnQu.mjs → attaform.ByWP6kSx.mjs}

@@ -1,7 +1,7 @@
-import { a as InvalidUseFormConfigError } from './attaform.wfY8XFvm.mjs';
-import { u as useForm$2 } from './attaform.CJP3RkGa.mjs';
-import { u as useForm$1 } from './attaform.NLmerepI.mjs';
-import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './attaform.C09fpdLS.mjs';
+import { a as InvalidUseFormConfigError } from './attaform.CdZIEf7_.mjs';
+import { u as useForm$2 } from './attaform.CJ8DpRGj.mjs';
+import { u as useForm$1 } from './attaform.BXneBxEj.mjs';
+import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './attaform.CUfrMK7t.mjs';
 
 function isZodV4SchemaShape(value) {
   if (typeof value !== "object" || value === null) return false;