attaform 0.21.2 → 0.22.0

package/dist/shared/{attaform.BYgioWLF.d.ts → attaform.DUMWQefY.d.ts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { G as GenericForm, w as FlatPath, S as NestedType, F as FormKey, U as UseFormConfiguration, a as AbstractSchema, D as DefaultValuesInput, am as ValidateOnConfig, b as UseFormReturnType } from './attaform.ory-3WhV.js';
+import { G as GenericForm, w as FlatPath, S as NestedType, F as FormKey, U as UseFormConfiguration, a as AbstractSchema, D as DefaultValuesInput, au as ValidateOnConfig, b as UseFormReturnType } from './attaform.DvUH4a3o.js';
 
 /**
  * The shape `form.values.<key>` returns at runtime.

package/dist/shared/{attaform.CrD73S4m.mjs → attaform.DgCfLqay.mjs}

@@ -1,7 +1,6 @@
-import { z } from 'zod';
-import { f as fieldMetaStore, g as getFieldMetaForSchema, a as getFieldMetaListForSchema, s as slimPrimitivesWalk, c as createAbstractSchema, w as walkPathSegments, d as deriveDefaultWalk, b as getFieldMetaPathMap, m as mergeDeep, p as peelEmbeddedDefault, N as NO_EMBEDDED_DEFAULT } from './attaform.D6GYGshL.mjs';
-import { E as humanize, t as getAtPath, h as slimKindOf, v as setAtPath, r as useAbstractForm } from './attaform.CTheKoTc.mjs';
-import { b as AttaformError, _ as __DEV__, a as canonicalizePath, d as InvalidUseFormConfigError } from './attaform.DP-u7_tk.mjs';
+import { f as fieldMetaStore, g as getFieldMetaForSchema, a as getFieldMetaListForSchema, s as slimPrimitivesWalk, c as createAbstractSchema, w as walkPathSegments, d as deriveDefaultWalk, b as getFieldMetaPathMap, m as mergeDeep, p as peelEmbeddedDefault, N as NO_EMBEDDED_DEFAULT } from './attaform.DCjgGir_.mjs';
+import { E as humanize, t as getAtPath, h as slimKindOf, v as setAtPath, r as useAbstractForm } from './attaform.CsB-iKbU.mjs';
+import { b as AttaformError, _ as __DEV__, a as canonicalizePath, d as InvalidUseFormConfigError } from './attaform.BKFwekY2.mjs';
 
 const fieldMeta = fieldMetaStore;
 function withMeta(schema, payload) {
@@ -54,9 +53,6 @@ function clone(value, seen) {
   return copy;
 }
 
-class UnsupportedSchemaError extends AttaformError {
-}
-
 function isZodSchemaType(schema, expectedType) {
   if (typeof schema !== "object" || schema === null) return false;
   const maybeDef = schema._def;
@@ -191,6 +187,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;
@@ -471,6 +471,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 AttaformError {
+}
+
 const UNSUPPORTED_TYPE_NAMES = /* @__PURE__ */ new Set(["ZodPromise", "ZodFunction", "ZodMap", "ZodSymbol"]);
 function labelPath(path) {
   return path.length === 0 ? "<root>" : path.join(".");
@@ -614,11 +679,11 @@ function stripAsyncChecks(schema) {
     }
     if (isZodSchemaType(s, "ZodOptional")) {
       const inner = unwrapInner(s);
-      return inner === void 0 ? s : 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 : z.nullable(recurse(inner));
+      return inner === void 0 ? s : rebuildWrapperInner(s, recurse(inner));
     }
     if (isZodSchemaType(s, "ZodDefault")) {
       const inner = unwrapInner(s);
@@ -644,7 +709,7 @@ function stripAsyncChecks(schema) {
       const inner = unwrapLazy(s);
       if (inner === void 0) return s;
       const stripped = recurse(inner);
-      return z.lazy(() => stripped);
+      return rebuildLazy(s, stripped);
     }
     if (isZodSchemaType(s, "ZodPipeline")) {
       const inSide = unwrapPipeIn(s);
@@ -656,33 +721,32 @@ function stripAsyncChecks(schema) {
       for (const [k, v] of Object.entries(shape)) {
         next[k] = recurse(v);
       }
-      return carryObjectChecks(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(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(z.set(recurse(valueType)), s);
+      return carrySetChecks(rebuildSet(s, recurse(valueType)), s);
     }
     if (isZodSchemaType(s, "ZodTuple")) {
       const items = getTupleItems(s).map(recurse);
-      const rebuilt = 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 ? z.record(next) : 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 z.union(options);
+      return rebuildUnion(s, options);
     }
     if (isZodSchemaType(s, "ZodDiscriminatedUnion")) {
       const discKey = getDiscriminator(s);
@@ -690,16 +754,13 @@ function stripAsyncChecks(schema) {
         (o) => recurse(o)
       );
       if (discKey === void 0 || options.length === 0) return s;
-      return 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 z.intersection(recurse(left), recurse(right));
+      return rebuildIntersection(s, recurse(left), recurse(right));
     }
     return s;
   }
@@ -1098,15 +1159,15 @@ function stripRefinements(schema) {
   function _stripRefinements(_schema, depth) {
     if (depth >= MAX_UNWRAP_STEPS) return _schema;
     if (isZodSchemaType(_schema, "ZodString") && hasChecks(_schema)) {
-      return z.string();
+      return stripLeafChecks(_schema);
     }
     if (isZodSchemaType(_schema, "ZodNumber") && hasChecks(_schema)) {
-      return z.number();
+      return stripLeafChecks(_schema);
     }
     if (isZodSchemaType(_schema, "ZodArray")) {
       const inner = getArrayElement(_schema);
       if (!inner) return _schema;
-      return z.array(_stripRefinements(inner, depth + 1));
+      return rebuildArray(_schema, _stripRefinements(inner, depth + 1));
     }
     if (isZodSchemaType(_schema, "ZodObject")) {
       const strippedShape = Object.fromEntries(
@@ -1115,7 +1176,7 @@ function stripRefinements(schema) {
           _stripRefinements(value, depth + 1)
         ])
       );
-      return z.object(strippedShape);
+      return rebuildObject(_schema, strippedShape);
     }
     if (isZodSchemaType(_schema, "ZodEffects")) {
       const inner = unwrapEffectsSource(_schema);
@@ -1125,12 +1186,12 @@ function stripRefinements(schema) {
     if (isZodSchemaType(_schema, "ZodOptional")) {
       const inner = unwrapInner(_schema);
       if (!inner) return _schema;
-      return 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 z.nullable(_stripRefinements(inner, depth + 1));
+      return rebuildWrapperInner(_schema, _stripRefinements(inner, depth + 1));
     }
     if (isZodSchemaType(_schema, "ZodReadonly")) {
       const inner = unwrapInner(_schema);
@@ -1150,13 +1211,13 @@ function stripRefinements(schema) {
     if (isZodSchemaType(_schema, "ZodSet")) {
       const valueType = getSetValueType(_schema);
       if (!valueType) return _schema;
-      return 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 z.tuple(stripped);
+      return rebuildTuple(_schema, stripped);
     }
     if (isZodSchemaType(_schema, "ZodRecord")) {
       const valueType = getRecordValueType(_schema);
@@ -1164,15 +1225,15 @@ function stripRefinements(schema) {
       const value = _stripRefinements(valueType, depth + 1);
       const keyType = getRecordKeyType(_schema);
       if (keyType) {
-        return z.record(keyType, value);
+        return rebuildRecord(_schema, value, keyType);
       }
-      return 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 z.union(stripped);
+      return rebuildUnion(_schema, stripped);
     }
     if (isZodSchemaType(_schema, "ZodDiscriminatedUnion")) {
       const discKey = getDiscriminator(_schema);
@@ -1181,22 +1242,23 @@ function stripRefinements(schema) {
       const stripped = options.map(
         (o) => _stripRefinements(o, depth + 1)
       );
-      return 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 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 z.lazy(() => stripped);
+      return rebuildLazy(_schema, stripped);
     }
     return _schema;
   }
@@ -1236,12 +1298,12 @@ function getSlimSchema(config) {
       for (const [key, value] of Object.entries(getObjectShape(_schema))) {
         newShape[key] = _getSlimSchema(value);
       }
-      return z.object(newShape);
+      return rebuildObject(_schema, newShape);
     }
     if (isZodSchemaType(_schema, "ZodArray")) {
       const inner = getArrayElement(_schema);
       if (!inner) return _schema;
-      return z.array(_getSlimSchema(inner));
+      return rebuildArray(_schema, _getSlimSchema(inner));
     }
     if (isZodSchemaType(_schema, "ZodRecord")) {
       const keyType = getRecordKeyType(_schema);
@@ -1249,7 +1311,7 @@ function getSlimSchema(config) {
       if (!keyType || !valueType) return _schema;
       const key = _getSlimSchema(keyType);
       const value = _getSlimSchema(valueType);
-      return z.record(key, value);
+      return rebuildRecord(_schema, value, key);
     }
     if (isZodSchemaType(_schema, "ZodDiscriminatedUnion")) {
       const slimmedSchemas = [];
@@ -1260,8 +1322,8 @@ function getSlimSchema(config) {
         const deepCloneSlimmedSchema = cloneSchemaDeep(slimmedSchema);
         slimmedSchemas.push(deepCloneSlimmedSchema);
       }
-      return z.discriminatedUnion(
-        discKey,
+      return rebuildDiscriminatedUnion(
+        _schema,
         slimmedSchemas
       );
     }
@@ -1526,7 +1588,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,
@@ -1537,7 +1602,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) {
@@ -1557,4 +1626,4 @@ function useForm(configuration) {
 }
 
 export { fieldMeta as f, isZodSchemaType as i, useForm as u, withMeta as w, zodAdapter as z };
-//# sourceMappingURL=attaform.CrD73S4m.mjs.map
+//# sourceMappingURL=attaform.DgCfLqay.mjs.map