attaform 0.21.2 → 0.22.0

package/dist/shared/{attaform.CcnF1AKJ.cjs → attaform.C-RtnCJM.cjs}

@@ -1,9 +1,8 @@
 'use strict';
 
-const zod = require('zod');
-const walkFieldMeta = require('./attaform.BwrowMp2.cjs');
-const injectWizard = require('./attaform.D2ZuIOCf.cjs');
-const paths = require('./attaform.B5LNzqQh.cjs');
+const walkFieldMeta = require('./attaform.Q3eAD2wD.cjs');
+const injectWizard = require('./attaform.CjMcwV7W.cjs');
+const paths = require('./attaform.01iKS_lz.cjs');
 
 const fieldMeta = walkFieldMeta.fieldMetaStore;
 function withMeta(schema, payload) {
@@ -56,9 +55,6 @@ function clone(value, seen) {
   return copy;
 }
 
-class UnsupportedSchemaError extends paths.AttaformError {
-}
-
 function isZodSchemaType(schema, expectedType) {
   if (typeof schema !== "object" || schema === null) return false;
   const maybeDef = schema._def;
@@ -193,6 +189,10 @@ function getDiscriminator(schema) {
   const def = readDef(schema);
   return def?.discriminator;
 }
+function getDiscriminatedOptionsMap(schema) {
+  const map = readDef(schema)?.optionsMap;
+  return map instanceof Map ? map : void 0;
+}
 function getIntersectionLeft(schema) {
   const def = readDef(schema);
   return def?.left;
@@ -473,6 +473,71 @@ function isContainerAfterWrapperPeel(schema) {
   return isZodSchemaType(cur, "ZodObject") || isZodSchemaType(cur, "ZodArray") || isZodSchemaType(cur, "ZodTuple") || isZodSchemaType(cur, "ZodIntersection") || isZodSchemaType(cur, "ZodUnion") || isZodSchemaType(cur, "ZodDiscriminatedUnion") || isZodSchemaType(cur, "ZodRecord") || isZodSchemaType(cur, "ZodSet");
 }
 
+function rebuildWithDef(original, defPatch) {
+  const node = Object.create(Object.getPrototypeOf(original));
+  node._def = { ...original._def, ...defPatch };
+  return node;
+}
+function rebuildObject(original, shape) {
+  const node = rebuildWithDef(original, { shape: () => shape, unknownKeys: "strip" });
+  node._cached = null;
+  return node;
+}
+function rebuildArray(original, element) {
+  return rebuildWithDef(original, {
+    type: element,
+    minLength: null,
+    maxLength: null,
+    exactLength: null
+  });
+}
+function rebuildSet(original, valueType) {
+  return rebuildWithDef(original, {
+    valueType,
+    minSize: null,
+    maxSize: null
+  });
+}
+function rebuildRecord(original, valueType, keyType) {
+  const patch = { valueType };
+  if (keyType !== void 0) patch["keyType"] = keyType;
+  return rebuildWithDef(original, patch);
+}
+function rebuildTuple(original, items) {
+  return rebuildWithDef(original, { items, rest: null });
+}
+function rebuildUnion(original, options) {
+  return rebuildWithDef(original, { options });
+}
+function rebuildIntersection(original, left, right) {
+  return rebuildWithDef(original, { left, right });
+}
+function rebuildWrapperInner(original, inner) {
+  return rebuildWithDef(original, { innerType: inner });
+}
+function rebuildLazy(original, target) {
+  return rebuildWithDef(original, { getter: () => target });
+}
+function stripLeafChecks(original) {
+  return rebuildWithDef(original, { checks: [] });
+}
+function rebuildDiscriminatedUnion(original, options) {
+  const originalOptions = getDiscriminatedOptions(original);
+  const originalMap = getDiscriminatedOptionsMap(original);
+  const optionsMap = /* @__PURE__ */ new Map();
+  if (originalMap !== void 0) {
+    for (const [value, originalOption] of originalMap) {
+      const index = originalOptions.indexOf(originalOption);
+      const replacement = index >= 0 ? options[index] : void 0;
+      if (replacement !== void 0) optionsMap.set(value, replacement);
+    }
+  }
+  return rebuildWithDef(original, { options, optionsMap });
+}
+
+class UnsupportedSchemaError extends paths.AttaformError {
+}
+
 const UNSUPPORTED_TYPE_NAMES = /* @__PURE__ */ new Set(["ZodPromise", "ZodFunction", "ZodMap", "ZodSymbol"]);
 function labelPath(path) {
   return path.length === 0 ? "<root>" : path.join(".");
@@ -616,11 +681,11 @@ function stripAsyncChecks(schema) {
     }
     if (isZodSchemaType(s, "ZodOptional")) {
       const inner = unwrapInner(s);
-      return inner === void 0 ? s : zod.z.optional(recurse(inner));
+      return inner === void 0 ? s : rebuildWrapperInner(s, recurse(inner));
     }
     if (isZodSchemaType(s, "ZodNullable")) {
       const inner = unwrapInner(s);
-      return inner === void 0 ? s : zod.z.nullable(recurse(inner));
+      return inner === void 0 ? s : rebuildWrapperInner(s, recurse(inner));
     }
     if (isZodSchemaType(s, "ZodDefault")) {
       const inner = unwrapInner(s);
@@ -646,7 +711,7 @@ function stripAsyncChecks(schema) {
       const inner = unwrapLazy(s);
       if (inner === void 0) return s;
       const stripped = recurse(inner);
-      return zod.z.lazy(() => stripped);
+      return rebuildLazy(s, stripped);
     }
     if (isZodSchemaType(s, "ZodPipeline")) {
       const inSide = unwrapPipeIn(s);
@@ -658,33 +723,32 @@ function stripAsyncChecks(schema) {
       for (const [k, v] of Object.entries(shape)) {
         next[k] = recurse(v);
       }
-      return carryObjectChecks(zod.z.object(next), s);
+      return carryObjectChecks(rebuildObject(s, next), s);
     }
     if (isZodSchemaType(s, "ZodArray")) {
       const element = getArrayElement(s);
       if (element === void 0) return s;
-      return carryArrayChecks(zod.z.array(recurse(element)), s);
+      return carryArrayChecks(rebuildArray(s, recurse(element)), s);
     }
     if (isZodSchemaType(s, "ZodSet")) {
       const valueType = getSetValueType(s);
       if (valueType === void 0) return s;
-      return carrySetChecks(zod.z.set(recurse(valueType)), s);
+      return carrySetChecks(rebuildSet(s, recurse(valueType)), s);
     }
     if (isZodSchemaType(s, "ZodTuple")) {
       const items = getTupleItems(s).map(recurse);
-      const rebuilt = zod.z.tuple(items);
-      return rebuilt;
+      return rebuildTuple(s, items);
     }
     if (isZodSchemaType(s, "ZodRecord")) {
       const keyType = getRecordKeyType(s);
       const valueType = getRecordValueType(s);
       if (valueType === void 0) return s;
       const next = recurse(valueType);
-      return keyType === void 0 ? zod.z.record(next) : zod.z.record(keyType, next);
+      return keyType === void 0 ? rebuildRecord(s, next) : rebuildRecord(s, next, keyType);
     }
     if (isZodSchemaType(s, "ZodUnion")) {
       const options = getUnionOptions(s).map(recurse);
-      return zod.z.union(options);
+      return rebuildUnion(s, options);
     }
     if (isZodSchemaType(s, "ZodDiscriminatedUnion")) {
       const discKey = getDiscriminator(s);
@@ -692,16 +756,13 @@ function stripAsyncChecks(schema) {
         (o) => recurse(o)
       );
       if (discKey === void 0 || options.length === 0) return s;
-      return zod.z.discriminatedUnion(
-        discKey,
-        options
-      );
+      return rebuildDiscriminatedUnion(s, options);
     }
     if (isZodSchemaType(s, "ZodIntersection")) {
       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));
+      return rebuildIntersection(s, recurse(left), recurse(right));
     }
     return s;
   }
@@ -1100,15 +1161,15 @@ function stripRefinements(schema) {
   function _stripRefinements(_schema, depth) {
     if (depth >= MAX_UNWRAP_STEPS) return _schema;
     if (isZodSchemaType(_schema, "ZodString") && hasChecks(_schema)) {
-      return zod.z.string();
+      return stripLeafChecks(_schema);
     }
     if (isZodSchemaType(_schema, "ZodNumber") && hasChecks(_schema)) {
-      return zod.z.number();
+      return stripLeafChecks(_schema);
     }
     if (isZodSchemaType(_schema, "ZodArray")) {
       const inner = getArrayElement(_schema);
       if (!inner) return _schema;
-      return zod.z.array(_stripRefinements(inner, depth + 1));
+      return rebuildArray(_schema, _stripRefinements(inner, depth + 1));
     }
     if (isZodSchemaType(_schema, "ZodObject")) {
       const strippedShape = Object.fromEntries(
@@ -1117,7 +1178,7 @@ function stripRefinements(schema) {
           _stripRefinements(value, depth + 1)
         ])
       );
-      return zod.z.object(strippedShape);
+      return rebuildObject(_schema, strippedShape);
     }
     if (isZodSchemaType(_schema, "ZodEffects")) {
       const inner = unwrapEffectsSource(_schema);
@@ -1127,12 +1188,12 @@ function stripRefinements(schema) {
     if (isZodSchemaType(_schema, "ZodOptional")) {
       const inner = unwrapInner(_schema);
       if (!inner) return _schema;
-      return zod.z.optional(_stripRefinements(inner, depth + 1));
+      return rebuildWrapperInner(_schema, _stripRefinements(inner, depth + 1));
     }
     if (isZodSchemaType(_schema, "ZodNullable")) {
       const inner = unwrapInner(_schema);
       if (!inner) return _schema;
-      return zod.z.nullable(_stripRefinements(inner, depth + 1));
+      return rebuildWrapperInner(_schema, _stripRefinements(inner, depth + 1));
     }
     if (isZodSchemaType(_schema, "ZodReadonly")) {
       const inner = unwrapInner(_schema);
@@ -1152,13 +1213,13 @@ function stripRefinements(schema) {
     if (isZodSchemaType(_schema, "ZodSet")) {
       const valueType = getSetValueType(_schema);
       if (!valueType) return _schema;
-      return zod.z.set(_stripRefinements(valueType, depth + 1));
+      return rebuildSet(_schema, _stripRefinements(valueType, depth + 1));
     }
     if (isZodSchemaType(_schema, "ZodTuple")) {
       const items = getTupleItems(_schema);
       if (items.length === 0) return _schema;
       const stripped = items.map((it) => _stripRefinements(it, depth + 1));
-      return zod.z.tuple(stripped);
+      return rebuildTuple(_schema, stripped);
     }
     if (isZodSchemaType(_schema, "ZodRecord")) {
       const valueType = getRecordValueType(_schema);
@@ -1166,15 +1227,15 @@ function stripRefinements(schema) {
       const value = _stripRefinements(valueType, depth + 1);
       const keyType = getRecordKeyType(_schema);
       if (keyType) {
-        return zod.z.record(keyType, value);
+        return rebuildRecord(_schema, value, keyType);
       }
-      return zod.z.record(value);
+      return rebuildRecord(_schema, value);
     }
     if (isZodSchemaType(_schema, "ZodUnion")) {
       const options = getUnionOptions(_schema);
       if (options.length === 0) return _schema;
       const stripped = options.map((o) => _stripRefinements(o, depth + 1));
-      return zod.z.union(stripped);
+      return rebuildUnion(_schema, stripped);
     }
     if (isZodSchemaType(_schema, "ZodDiscriminatedUnion")) {
       const discKey = getDiscriminator(_schema);
@@ -1183,22 +1244,23 @@ function stripRefinements(schema) {
       const stripped = options.map(
         (o) => _stripRefinements(o, depth + 1)
       );
-      return zod.z.discriminatedUnion(
-        discKey,
-        stripped
-      );
+      return rebuildDiscriminatedUnion(_schema, stripped);
     }
     if (isZodSchemaType(_schema, "ZodIntersection")) {
       const left = getIntersectionLeft(_schema);
       const right = getIntersectionRight(_schema);
       if (!left || !right) return _schema;
-      return zod.z.intersection(_stripRefinements(left, depth + 1), _stripRefinements(right, depth + 1));
+      return rebuildIntersection(
+        _schema,
+        _stripRefinements(left, depth + 1),
+        _stripRefinements(right, depth + 1)
+      );
     }
     if (isZodSchemaType(_schema, "ZodLazy")) {
       const inner = unwrapLazy(_schema);
       if (!inner) return _schema;
       const stripped = _stripRefinements(inner, depth + 1);
-      return zod.z.lazy(() => stripped);
+      return rebuildLazy(_schema, stripped);
     }
     return _schema;
   }
@@ -1238,12 +1300,12 @@ function getSlimSchema(config) {
       for (const [key, value] of Object.entries(getObjectShape(_schema))) {
         newShape[key] = _getSlimSchema(value);
       }
-      return zod.z.object(newShape);
+      return rebuildObject(_schema, newShape);
     }
     if (isZodSchemaType(_schema, "ZodArray")) {
       const inner = getArrayElement(_schema);
       if (!inner) return _schema;
-      return zod.z.array(_getSlimSchema(inner));
+      return rebuildArray(_schema, _getSlimSchema(inner));
     }
     if (isZodSchemaType(_schema, "ZodRecord")) {
       const keyType = getRecordKeyType(_schema);
@@ -1251,7 +1313,7 @@ function getSlimSchema(config) {
       if (!keyType || !valueType) return _schema;
       const key = _getSlimSchema(keyType);
       const value = _getSlimSchema(valueType);
-      return zod.z.record(key, value);
+      return rebuildRecord(_schema, value, key);
     }
     if (isZodSchemaType(_schema, "ZodDiscriminatedUnion")) {
       const slimmedSchemas = [];
@@ -1262,8 +1324,8 @@ function getSlimSchema(config) {
         const deepCloneSlimmedSchema = cloneSchemaDeep(slimmedSchema);
         slimmedSchemas.push(deepCloneSlimmedSchema);
       }
-      return zod.z.discriminatedUnion(
-        discKey,
+      return rebuildDiscriminatedUnion(
+        _schema,
         slimmedSchemas
       );
     }
@@ -1528,7 +1590,10 @@ function runStrictGetDefaultsV3(rootSchema, config, formKey, maxRecursionDepth)
     formKey
   };
 }
-function getNestedSchemasInSlimModeV3(rootSchema, path, maxRecursionDepth) {
+const slimRootCacheV3 = /* @__PURE__ */ new WeakMap();
+function getSlimRootV3(rootSchema) {
+  const cached = slimRootCacheV3.get(rootSchema);
+  if (cached !== void 0) return cached;
   const [strippedSchema] = stripRootSchema(rootSchema, {
     stripDefaultValues: true,
     stripNullable: true,
@@ -1539,7 +1604,11 @@ function getNestedSchemasInSlimModeV3(rootSchema, path, maxRecursionDepth) {
     schema: strippedSchema,
     stripConfig: { stripDefaultValues: true, stripZodEffects: true }
   });
-  return getNestedZodSchemasAtPath(slimSchema, path, maxRecursionDepth);
+  slimRootCacheV3.set(rootSchema, slimSchema);
+  return slimSchema;
+}
+function getNestedSchemasInSlimModeV3(rootSchema, path, maxRecursionDepth) {
+  return getNestedZodSchemasAtPath(getSlimRootV3(rootSchema), path, maxRecursionDepth);
 }
 
 function useForm(configuration) {
@@ -1563,4 +1632,4 @@ exports.isZodSchemaType = isZodSchemaType;
 exports.useForm = useForm;
 exports.withMeta = withMeta;
 exports.zodAdapter = zodAdapter;
-//# sourceMappingURL=attaform.CcnF1AKJ.cjs.map
+//# sourceMappingURL=attaform.C-RtnCJM.cjs.map