@hookform/resolvers 2.0.0-beta.7 → 2.0.0

package/zod/src/zod.ts

@@ -1,70 +1,65 @@
-import { appendErrors, transformToNestObject } from 'react-hook-form';
+import { appendErrors, FieldError } from 'react-hook-form';
 import * as z from 'zod';
-// @ts-expect-error maybe fixed after the first publish ?
-import { convertArrayToPathName } from '@hookform/resolvers';
+import { toNestError } from '@hookform/resolvers';
 import type { Resolver } from './types';
 
 const parseErrorSchema = (
-  zodError: z.ZodError,
+  zodErrors: z.ZodSuberror[],
   validateAllFieldCriteria: boolean,
 ) => {
-  if (zodError.isEmpty) {
-    return {};
-  }
+  const errors: Record<string, FieldError> = {};
+  for (; zodErrors.length; ) {
+    const error = zodErrors[0];
+    const { code, message, path } = error;
+    const _path = path.join('.');
+
+    if (!errors[_path]) {
+      errors[_path] = { message, type: code };
+    }
+
+    if ('unionErrors' in error) {
+      error.unionErrors.forEach((unionError) =>
+        unionError.errors.forEach((e) => zodErrors.push(e)),
+      );
+    }
+
+    if (validateAllFieldCriteria) {
+      errors[_path] = appendErrors(
+        _path,
+        validateAllFieldCriteria,
+        errors,
+        code,
+        message,
+      ) as FieldError;
+    }
 
-  return zodError.errors.reduce<Record<string, any>>(
-    (previous, { path, message, code: type }) => {
-      const currentPath = convertArrayToPathName(path);
+    zodErrors.shift();
+  }
 
-      return {
-        ...previous,
-        ...(path
-          ? previous[currentPath] && validateAllFieldCriteria
-            ? {
-                [currentPath]: appendErrors(
-                  currentPath,
-                  validateAllFieldCriteria,
-                  previous,
-                  type,
-                  message,
-                ),
-              }
-            : {
-                [currentPath]: previous[currentPath] || {
-                  message,
-                  type,
-                  ...(validateAllFieldCriteria
-                    ? {
-                        types: { [type]: message || true },
-                      }
-                    : {}),
-                },
-              }
-          : {}),
-      };
-    },
-    {},
-  );
+  return errors;
 };
 
 export const zodResolver: Resolver = (
   schema,
   schemaOptions,
-  { mode } = { mode: 'async' },
-) => async (values, _, { criteriaMode }) => {
+  resolverOptions = {},
+) => async (values, _, options) => {
   try {
-    const result =
-      mode === 'async'
-        ? await schema.parseAsync(values, schemaOptions)
-        : schema.parse(values, schemaOptions);
-
-    return { values: result, errors: {} };
+    return {
+      errors: {},
+      values: await schema[
+        resolverOptions.mode === 'sync' ? 'parse' : 'parseAsync'
+      ](values, schemaOptions),
+    };
   } catch (error) {
     return {
       values: {},
-      errors: transformToNestObject(
-        parseErrorSchema(error, criteriaMode === 'all'),
-      ),
+      errors: error.isEmpty
+        ? {}
+        : toNestError(
+            parseErrorSchema(error.errors, options.criteriaMode === 'all'),
+            options.fields,
+          ),
     };
   }
 };

package/dist/convertArrayToPathName.d.ts

@@ -1 +0,0 @@
-export declare const convertArrayToPathName: (paths: (string | number)[]) => string;