attaform 0.27.6 → 0.28.0

package/dist/shared/attaform.BJGA_UOS.mjs

@@ -34,4 +34,3 @@ function canonicalStringify(value, seen = /* @__PURE__ */ new WeakSet()) {
 }
 
 export { canonicalStringify as c };
-//# sourceMappingURL=attaform.BJGA_UOS.mjs.map

package/dist/shared/{attaform.CoR4mWfv.mjs → attaform.C09fpdLS.mjs}

@@ -1,5 +1,6 @@
-import { A as AttaformErrorCode, n as isPlainRecord, s as safeOwnRead, o as safeAssign, p as slimKindOf } from './attaform.CKH2lGdL.mjs';
-import { f as canonicalizePath } from './attaform.nMaz2C5P.mjs';
+import { A as AttaformErrorCode, n as isPlainRecord, s as slimKindOf } from './attaform.B8k8JrmK.mjs';
+import { e as canonicalizePath } from './attaform.wfY8XFvm.mjs';
+import { a as safeOwnRead, b as safeAssign } from './attaform.h0i6LijT.mjs';
 
 const PATH_SEPARATOR = ".";
 function createAbstractSchema(rootSchema, intro, services, formKey, options) {
@@ -9,6 +10,7 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
   const discriminatorCache = /* @__PURE__ */ new Map();
   let asyncValidationFlag = null;
   let containerRefineFlag = null;
+  let discriminatedUnionFlag = null;
   function computeDiscriminator(path) {
     const candidates = path.length === 0 ? [rootSchema] : services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth);
     let matchedUnion;
@@ -60,6 +62,10 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
       containerRefineFlag ?? (containerRefineFlag = intro.hasContainerOrRootRefine(rootSchema));
       return containerRefineFlag;
     },
+    hasDiscriminatedUnions() {
+      discriminatedUnionFlag ?? (discriminatedUnionFlag = intro.containsDiscriminatedUnion(rootSchema));
+      return discriminatedUnionFlag;
+    },
     getDefaultValues(config) {
       return services.runStrictGetDefaults(rootSchema, config, formKey, maxRecursionDepth);
     },
@@ -81,14 +87,12 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
       return services.deriveDefault(first, false, maxRecursionDepth, formKey);
     },
     arrayShapeAtPath(path) {
-      if (path.length === 0) return void 0;
+      if (path.length === 0) return null;
       const [first] = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth);
-      if (first === void 0) return void 0;
+      if (first === void 0) return null;
       const peeled = services.peelAllWrappers(first);
-      const kind = intro.kindOf(peeled);
-      if (kind === "tuple") return intro.getTupleItems(peeled).length;
-      if (kind === "array") return null;
-      return void 0;
+      if (intro.kindOf(peeled) === "tuple") return intro.getTupleItems(peeled).length;
+      return null;
     },
     isFixedObjectAtPath(path) {
       if (path.length === 0) {
@@ -172,7 +176,7 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
       function parseResultToResponse(result) {
         return result.success ? { data: result.data, errors: void 0, success: true, formKey } : {
           data: void 0,
-          errors: services.issuesToValidationErrors(result.issues, formKey),
+          errors: services.issuesToValidationErrors(result.issues),
           success: false,
           formKey
         };
@@ -225,7 +229,6 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
             {
               message,
               path: [...errPath],
-              formKey,
               code: AttaformErrorCode.ValidatorThrew
             }
           ],
@@ -240,7 +243,6 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
             {
               message: `Path '${p.join(PATH_SEPARATOR)}' did not resolve to any schema`,
               path: [...p],
-              formKey,
               code: AttaformErrorCode.PathNotFound
             }
           ],
@@ -357,6 +359,144 @@ function walkPathSegments(schema, segments, intro, maxDepth, lazyDepth) {
   }
 }
 
+function fixStructuralDefaults(schema, merged, useDefault, maxRecursionDepth, services) {
+  const ctx = {
+    useDefault,
+    maxDepth: maxRecursionDepth,
+    clean: true,
+    services
+  };
+  const data = fixNode(schema, merged, ctx, 0);
+  return { data, success: ctx.clean };
+}
+function fixNode(schema, value, ctx, lazyDepth) {
+  const { intro } = ctx.services;
+  if (intro.isCoercePrimitive(schema) || intro.isPreprocessNode(schema)) return value;
+  const kinds = ctx.services.slimPrimitivesOf(schema);
+  if (kinds.size > 0 && !kinds.has(slimKindOf(value))) {
+    const replacement = deriveFixValue(schema, value, ctx);
+    if (kinds.has(slimKindOf(replacement))) return replacement;
+    ctx.clean = false;
+    return replacement;
+  }
+  switch (intro.kindOf(schema)) {
+    case "optional":
+    case "nullable": {
+      if (value === void 0 || value === null) return value;
+      const inner = intro.unwrapInner(schema);
+      return inner === void 0 ? value : fixNode(inner, value, ctx, lazyDepth);
+    }
+    case "default":
+    case "readonly":
+    case "catch": {
+      const inner = intro.unwrapInner(schema);
+      return inner === void 0 ? value : fixNode(inner, value, ctx, lazyDepth);
+    }
+    case "branded": {
+      const inner = intro.unwrapBranded(schema);
+      return inner === void 0 ? value : fixNode(inner, value, ctx, lazyDepth);
+    }
+    case "effects": {
+      const inner = intro.unwrapEffectsSource(schema);
+      return inner === void 0 ? value : fixNode(inner, value, ctx, lazyDepth);
+    }
+    case "pipe":
+    case "pipeline": {
+      const pipeIn = intro.unwrapPipeIn(schema);
+      if (pipeIn === void 0 || intro.kindOf(pipeIn) === "transform") return value;
+      return fixNode(pipeIn, value, ctx, lazyDepth);
+    }
+    case "lazy": {
+      if (lazyDepth >= ctx.maxDepth) return value;
+      const inner = intro.unwrapLazy(schema);
+      return inner === void 0 ? value : fixNode(inner, value, ctx, lazyDepth + 1);
+    }
+    case "discriminated-union": {
+      if (value === null || typeof value !== "object") return value;
+      const variant = selectVariantByValue(schema, value, intro);
+      if (variant === void 0) return value;
+      const record = value;
+      const shape = intro.getObjectShape(variant);
+      for (const key of Object.keys(record)) {
+        if (!(key in shape)) delete record[key];
+      }
+      for (const [key, sub] of Object.entries(shape)) {
+        record[key] = fixNode(sub, record[key], ctx, lazyDepth);
+      }
+      return value;
+    }
+    case "object": {
+      if (value === null || typeof value !== "object") return value;
+      const record = value;
+      for (const [key, sub] of Object.entries(intro.getObjectShape(schema))) {
+        record[key] = fixNode(sub, record[key], ctx, lazyDepth);
+      }
+      return value;
+    }
+    case "array": {
+      if (!Array.isArray(value)) return value;
+      const element = intro.getArrayElement(schema);
+      if (element === void 0) return value;
+      for (let i = 0; i < value.length; i++) {
+        value[i] = fixNode(element, value[i], ctx, lazyDepth);
+      }
+      return value;
+    }
+    case "tuple": {
+      if (!Array.isArray(value)) return value;
+      const items = intro.getTupleItems(schema);
+      for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        if (item !== void 0) value[i] = fixNode(item, value[i], ctx, lazyDepth);
+      }
+      return value;
+    }
+    case "record": {
+      if (value === null || typeof value !== "object") return value;
+      const valueType = intro.getRecordValueType(schema);
+      if (valueType === void 0) return value;
+      const record = value;
+      for (const key of Object.keys(record)) {
+        record[key] = fixNode(valueType, record[key], ctx, lazyDepth);
+      }
+      return value;
+    }
+    case "intersection": {
+      const left = intro.getIntersectionLeft(schema);
+      const right = intro.getIntersectionRight(schema);
+      let out = value;
+      if (left !== void 0) out = fixNode(left, out, ctx, lazyDepth);
+      if (right !== void 0) out = fixNode(right, out, ctx, lazyDepth);
+      return out;
+    }
+    default:
+      return value;
+  }
+}
+function deriveFixValue(schema, value, ctx) {
+  const du = ctx.services.unwrapToDiscriminatedUnion(schema);
+  if (du !== void 0) {
+    const selected = selectVariantByValue(du, value, ctx.services.intro) ?? ctx.services.intro.getDiscriminatedOptions(du)[0];
+    if (selected !== void 0) {
+      return ctx.services.deriveDefault(selected, ctx.useDefault);
+    }
+  }
+  return ctx.services.deriveDefault(schema, ctx.useDefault);
+}
+function selectVariantByValue(du, value, intro) {
+  if (value === null || typeof value !== "object") return void 0;
+  const discKey = intro.getDiscriminator(du);
+  if (discKey === void 0) return void 0;
+  const discValue = value[discKey];
+  if (discValue === void 0) return void 0;
+  for (const opt of intro.getDiscriminatedOptions(du)) {
+    const litSchema = intro.getObjectShape(opt)[discKey];
+    if (litSchema === void 0 || intro.kindOf(litSchema) !== "literal") continue;
+    if (intro.getLiteralValues(litSchema).includes(discValue)) return opt;
+  }
+  return void 0;
+}
+
 const NO_EMBEDDED_DEFAULT = /* @__PURE__ */ Symbol("atta:no-embedded-default");
 function peelEmbeddedDefault(schema, intro) {
   let current = schema;
@@ -539,9 +679,6 @@ function deriveDefaultWalk(schema, useDefault, intro, maxDepth, ctx, lazyDepth =
     }
     case "catch": {
       if (useDefault) return intro.getCatchDefault(schema);
-      if (ctx.catchOnUseDefaultFalse === "preserveCatch" && intro.hasCatchValue(schema)) {
-        return intro.getCatchDefault(schema);
-      }
       const inner = intro.unwrapInner(schema);
       return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth);
     }
@@ -593,6 +730,13 @@ function getFieldMetaForSchema(schema) {
 function getFieldMetaListForSchema(schema) {
   return lists.get(schema) ?? [];
 }
+let pathMapBuilder = null;
+function installFieldMetaPathMapBuilder(builder) {
+  pathMapBuilder = builder;
+}
+function buildFieldMetaPathMap(rootSchema, services) {
+  return pathMapBuilder === null ? void 0 : pathMapBuilder(rootSchema, services);
+}
 
 const PERMISSIVE_SLIM_KINDS = /* @__PURE__ */ new Set([
   "string",
@@ -752,6 +896,19 @@ function slimPrimitivesWalk(schema, intro, maxDepth, lazyDepth = 0) {
   }
 }
 
+const installingFieldMetaStore = {
+  add(schema, payload) {
+    installFieldMetaPathMapBuilder(getFieldMetaPathMap);
+    fieldMetaStore.add(schema, payload);
+    return installingFieldMetaStore;
+  },
+  get: (schema) => fieldMetaStore.get(schema),
+  has: (schema) => fieldMetaStore.has(schema),
+  remove: (schema) => {
+    fieldMetaStore.remove(schema);
+    return installingFieldMetaStore;
+  }
+};
 const pathMetaCache = /* @__PURE__ */ new WeakMap();
 function getFieldMetaPathMap(rootSchema, services) {
   const cached = pathMetaCache.get(rootSchema);
@@ -903,5 +1060,4 @@ function walkForMeta(schema, path, map, counters, lastPathPerSchema, inProgress,
   }
 }
 
-export { NO_EMBEDDED_DEFAULT as N, getFieldMetaListForSchema as a, getFieldMetaPathMap as b, createAbstractSchema as c, deriveDefaultWalk as d, fieldMetaStore as f, getFieldMetaForSchema as g, mergeDeep as m, peelEmbeddedDefault as p, slimPrimitivesWalk as s, walkPathSegments as w };
-//# sourceMappingURL=attaform.CoR4mWfv.mjs.map
+export { getFieldMetaListForSchema as a, buildFieldMetaPathMap as b, createAbstractSchema as c, deriveDefaultWalk as d, fixStructuralDefaults as f, getFieldMetaForSchema as g, installingFieldMetaStore as i, mergeDeep as m, slimPrimitivesWalk as s, walkPathSegments as w };