@hookform/resolvers 1.3.4 → 1.3.8

package/yup/src/__tests__/yup.ts

@@ -0,0 +1,311 @@
+/* eslint-disable no-console, @typescript-eslint/ban-ts-comment */
+import * as yup from 'yup';
+import { yupResolver } from '..';
+
+const errors = {
+  name: 'ValidationError',
+  value: { createdOn: '2019-03-27T04:05:51.503Z' },
+  path: undefined,
+  type: undefined,
+  errors: ['name is a required field', 'age is a required field'],
+  inner: [
+    {
+      name: 'ValidationError',
+      value: undefined,
+      path: 'name',
+      type: 'required',
+      errors: [],
+      inner: [],
+      message: 'name is a required field',
+      params: [],
+    },
+    {
+      name: 'ValidationError',
+      value: undefined,
+      path: 'name',
+      type: 'min',
+      errors: [],
+      inner: [],
+      message: 'name is a min field',
+      params: [],
+    },
+    {
+      name: 'ValidationError',
+      value: undefined,
+      path: 'age',
+      type: 'required',
+      errors: [],
+      inner: [],
+      message: 'age is a required field',
+      params: [],
+    },
+  ],
+};
+
+const schema = yup.object({
+  name: yup.string().required(),
+  age: yup.number().required().positive().integer(),
+  email: yup.string().email(),
+  password: yup
+    .string()
+    .required()
+    .min(8)
+    .matches(RegExp('(.*[a-z].*)'), 'Lowercase')
+    .matches(RegExp('(.*[A-Z].*)'), 'Uppercase')
+    .matches(RegExp('(.*\\d.*)'), 'Number')
+    .matches(RegExp('[!@#$%^&*(),.?":{}|<>]'), 'Special'),
+  website: yup.string().url(),
+  createdOn: yup.date().default(function () {
+    return new Date();
+  }),
+  foo: yup
+    .array()
+    .required()
+    .of(
+      yup.object({
+        loose: yup.boolean(),
+      }),
+    ),
+});
+
+describe('yupResolver', () => {
+  it('should get values', async () => {
+    const data = {
+      name: 'jimmy',
+      age: 24,
+      email: 'jimmy@mail.com',
+      password: '[}tehk6Uor',
+      website: 'https://react-hook-form.com/',
+      createdOn: new Date('2014-09-23T19:25:25Z'),
+      foo: [{ loose: true }],
+    };
+    expect(await yupResolver(schema)(data)).toEqual({
+      errors: {},
+      values: data,
+    });
+  });
+
+  it('should pass down the yup context', async () => {
+    const data = { name: 'eric' };
+    const context = { min: true };
+    const schemaWithContext = yup.object({
+      name: yup
+        .string()
+        .required()
+        .when('$min', (min: boolean, schema: yup.StringSchema) => {
+          return min ? schema.min(6) : schema;
+        }),
+    });
+
+    const schemaSpyValidate = jest.spyOn(schemaWithContext, 'validate');
+
+    const output = await yupResolver(schemaWithContext)(data, context);
+    expect(schemaSpyValidate).toHaveBeenCalledTimes(1);
+    expect(schemaSpyValidate).toHaveBeenCalledWith(
+      data,
+      expect.objectContaining({
+        abortEarly: false,
+        context,
+      }),
+    );
+    expect(output).toMatchSnapshot();
+  });
+
+  describe('errors', () => {
+    it('should get errors with validate all criteria fields', async () => {
+      const data = {
+        name: 2,
+        age: 'test',
+        password: '',
+        createdOn: null,
+        foo: [{ loose: null }],
+      };
+
+      const output = await yupResolver(schema)(data, {}, true);
+      expect(output).toMatchSnapshot();
+      expect(output.errors['foo']?.[0]?.['loose']).toBeDefined();
+      expect(output.errors['foo']?.[0]?.['loose']?.types)
+        .toMatchInlineSnapshot(`
+        Object {
+          "typeError": "foo[0].loose must be a \`boolean\` type, but the final value was: \`null\`.
+         If \\"null\\" is intended as an empty value be sure to mark the schema as \`.nullable()\`",
+        }
+      `);
+      expect(output.errors.age?.types).toMatchInlineSnapshot(`
+        Object {
+          "typeError": "age must be a \`number\` type, but the final value was: \`NaN\` (cast from the value \`\\"test\\"\`).",
+        }
+      `);
+      expect(output.errors.createdOn?.types).toMatchInlineSnapshot(`
+        Object {
+          "typeError": "createdOn must be a \`date\` type, but the final value was: \`Invalid Date\`.",
+        }
+      `);
+      expect(output.errors.password?.types).toMatchInlineSnapshot(`
+        Object {
+          "matches": Array [
+            "Lowercase",
+            "Uppercase",
+            "Number",
+            "Special",
+          ],
+          "min": "password must be at least 8 characters",
+          "required": "password is a required field",
+        }
+      `);
+    });
+
+    it('should get errors without validate all criteria fields', async () => {
+      const data = {
+        name: 2,
+        age: 'test',
+        createdOn: null,
+        foo: [{ loose: null }],
+      };
+
+      const output = await yupResolver(schema)(data);
+      expect(output).toMatchSnapshot();
+      expect(output.errors.age?.types).toBeUndefined();
+      expect(output.errors.createdOn?.types).toBeUndefined();
+      expect(output.errors.password?.types).toBeUndefined();
+    });
+
+    it('should get error if yup errors has no inner errors', async () => {
+      const data = {
+        name: 2,
+        age: 'test',
+        createdOn: null,
+        foo: [{ loose: null }],
+      };
+      const output = await yupResolver(schema, {
+        abortEarly: true,
+      })(data, undefined, true);
+
+      expect(output.errors).toMatchInlineSnapshot(`
+        Object {
+          "createdOn": Object {
+            "message": "createdOn must be a \`date\` type, but the final value was: \`Invalid Date\`.",
+            "type": "typeError",
+          },
+        }
+      `);
+    });
+
+    it('should return an error result if inner yup validation error has no path', async () => {
+      const data = { name: '' };
+      const schemaWithContext = yup.object().shape({
+        name: yup.string().required(),
+      });
+
+      jest.spyOn(schemaWithContext, 'validate').mockRejectedValueOnce({
+        inner: [{ path: '', message: 'error1', type: 'required' }],
+      });
+
+      const output = await yupResolver(schemaWithContext)(data);
+      expect(output).toMatchSnapshot();
+    });
+  });
+});
+
+describe('validateWithSchema', () => {
+  it('should return undefined when no error reported', async () => {
+    const schema = yup.object();
+    jest.spyOn(schema, 'validate').mockRejectedValueOnce(errors);
+
+    expect(await yupResolver(schema)({})).toMatchSnapshot();
+  });
+
+  it('should return empty object when validate pass', async () => {
+    const schema = yup.object();
+
+    expect(await yupResolver(schema)({})).toMatchInlineSnapshot(`
+      Object {
+        "errors": Object {},
+        "values": Object {},
+      }
+    `);
+  });
+
+  it('should return an error based on the user context', async () => {
+    const data = { name: 'eric' };
+    const schemaWithContext = yup.object().shape({
+      name: yup
+        .string()
+        .required()
+        .when('$min', (min: boolean, schema: yup.StringSchema) => {
+          return min ? schema.min(6) : schema;
+        }),
+    });
+
+    expect(await yupResolver(schemaWithContext)(data, { min: true }))
+      .toMatchInlineSnapshot(`
+      Object {
+        "errors": Object {
+          "name": Object {
+            "message": "name must be at least 6 characters",
+            "type": "min",
+          },
+        },
+        "values": Object {},
+      }
+    `);
+  });
+
+  it('should show a warning log if yup context is used instead only on dev environment', async () => {
+    jest.spyOn(console, 'warn').mockImplementation(jest.fn);
+    process.env.NODE_ENV = 'development';
+
+    await yupResolver(yup.object(), { context: { noContext: true } })({});
+    expect(console.warn).toHaveBeenCalledWith(
+      "You should not used the yup options context. Please, use the 'useForm' context object instead",
+    );
+    process.env.NODE_ENV = 'test';
+  });
+
+  it('should not show warning log if yup context is used instead only on production environment', async () => {
+    jest.spyOn(console, 'warn').mockImplementation(jest.fn);
+    process.env.NODE_ENV = 'production';
+
+    await yupResolver(yup.object(), { context: { noContext: true } })({});
+    expect(console.warn).not.toHaveBeenCalled();
+    process.env.NODE_ENV = 'test';
+  });
+
+  it('should return correct error message with using yup.test', async () => {
+    const output = await yupResolver(
+      yup
+        .object({
+          name: yup.string(),
+          email: yup.string(),
+        })
+        .test(
+          'name',
+          'Email or name are required',
+          (value) => !!(value && (value.name || value.email)),
+        ),
+    )({ name: '', email: '' });
+
+    expect(output).toEqual({
+      values: {},
+      errors: { name: { message: 'Email or name are required', type: 'name' } },
+    });
+  });
+
+  it('should throw an error without inner property', (done) => {
+    const schemaWithWhen = yup.object({
+      name: yup.string().required(),
+      value: yup.string().when('name', {
+        is: 'test',
+        then: yup.number().required(),
+      }),
+    });
+
+    // @ts-expect-error
+    yupResolver(schemaWithWhen)({ name: 'test', value: '' }).catch((e) => {
+      expect(e).toMatchInlineSnapshot(
+        `[TypeError: You cannot \`concat()\` schema's of different types: string and number]`,
+      );
+      done();
+    });
+  });
+});

package/yup/src/index.ts

@@ -0,0 +1 @@
+export * from './yup';

package/yup/src/yup.ts

@@ -0,0 +1,96 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { Resolver, transformToNestObject, FieldValues } from 'react-hook-form';
+import Yup from 'yup';
+import Lazy from 'yup/lib/Lazy';
+
+/**
+ * From 0.32.0, Yup add TypeScript support and `path` typing is optional that's why we have `@ts-expect-error`
+ * FYI: `path`: a string, indicating where there error was thrown. `path` is empty at the root level.
+ * react-hook-form's values are object so path is defined
+ * https://github.com/jquense/yup#validationerrorerrors-string--arraystring-value-any-path-string
+ */
+const parseErrorSchema = (
+  error: Yup.ValidationError,
+  validateAllFieldCriteria: boolean,
+) => {
+  return Array.isArray(error.inner) && error.inner.length
+    ? error.inner.reduce(
+        (previous: Record<string, any>, { path, message, type }) => {
+          // @ts-expect-error
+          const previousTypes = (previous[path] && previous[path].types) || {};
+          const key = path || type;
+
+          return {
+            ...previous,
+            ...(key
+              ? {
+                  [key]: {
+                    ...(previous[key] || {
+                      message,
+                      type,
+                    }),
+                    ...(validateAllFieldCriteria
+                      ? {
+                          types: {
+                            ...previousTypes,
+                            // @ts-expect-error
+                            [type]: previousTypes[type]
+                              ? // @ts-expect-error
+                                [...[].concat(previousTypes[type]), message]
+                              : message,
+                          },
+                        }
+                      : {}),
+                  },
+                }
+              : {}),
+          };
+        },
+        {},
+      )
+    : {
+        // @ts-expect-error
+        [error.path]: { message: error.message, type: error.type },
+      };
+};
+
+type ValidateOptions<T extends Yup.AnyObjectSchema> = Parameters<
+  T['validate']
+>[1];
+
+export const yupResolver = <TFieldValues extends FieldValues>(
+  schema: Yup.AnyObjectSchema | Lazy<any, any>,
+  options: ValidateOptions<Yup.AnyObjectSchema> = {
+    abortEarly: false,
+  },
+): Resolver<TFieldValues> => async (
+  values,
+  context,
+  validateAllFieldCriteria = false,
+) => {
+  try {
+    if (options.context && process.env.NODE_ENV === 'development') {
+      // eslint-disable-next-line no-console
+      console.warn(
+        "You should not used the yup options context. Please, use the 'useForm' context object instead",
+      );
+    }
+    return {
+      values: await schema.validate(values, {
+        ...options,
+        context,
+      }),
+      errors: {},
+    };
+  } catch (e: any) {
+    if (!e.inner) {
+      throw e;
+    }
+
+    const parsedErrors = parseErrorSchema(e, validateAllFieldCriteria);
+    return {
+      values: {},
+      errors: transformToNestObject(parsedErrors),
+    };
+  }
+};

package/zod/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './zod';

package/{dist → zod/dist}/zod.d.ts

@@ -1,4 +1,4 @@
-import { Resolver } from 'react-hook-form';
-import * as z from 'zod';
-import { ParseParams } from 'zod/lib/src/parser';
-export declare const zodResolver: <T extends z.ZodType<any, any>>(schema: T, options?: ParseParams | undefined) => Resolver<z.TypeOf<T>, object>;
+import { Resolver } from 'react-hook-form';
+import * as z from 'zod';
+import { ParseParams } from 'zod/lib/src/parser';
+export declare const zodResolver: <T extends z.ZodType<any, any>>(schema: T, options?: ParseParams | undefined) => Resolver<z.TypeOf<T>, object>;

package/zod/dist/zod.js

@@ -0,0 +1,2 @@
+var r=require("react-hook-form"),e=require("@hookform/resolvers");function t(){return(t=Object.assign||function(r){for(var e=1;e<arguments.length;e++){var t=arguments[e];for(var n in t)Object.prototype.hasOwnProperty.call(t,n)&&(r[n]=t[n])}return r}).apply(this,arguments)}function n(r,e){(null==e||e>r.length)&&(e=r.length);for(var t=0,n=new Array(e);t<e;t++)n[t]=r[t];return n}function o(r,e){var t;if("undefined"==typeof Symbol||null==r[Symbol.iterator]){if(Array.isArray(r)||(t=function(r,e){if(r){if("string"==typeof r)return n(r,e);var t=Object.prototype.toString.call(r).slice(8,-1);return"Object"===t&&r.constructor&&(t=r.constructor.name),"Map"===t||"Set"===t?Array.from(r):"Arguments"===t||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t)?n(r,e):void 0}}(r))||e&&r&&"number"==typeof r.length){t&&(r=t);var o=0;return function(){return o>=r.length?{done:!0}:{done:!1,value:r[o++]}}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}return(t=r[Symbol.iterator]()).next.bind(t)}var a=function(n,a){if(n.isEmpty)return{};for(var i,s=[].concat(n.errors),u={},c=o(s);!(i=c()).done;){var l,f,v,p=i.value,y=p.path,m=p.message,d=p.code,h=e.convertArrayToPathName(y);if("unionErrors"in p)for(var b,g=o(p.unionErrors.map(function(r){return r.errors}));!(b=g()).done;)s.push.apply(s,b.value);u=t({},u,y?u[h]&&a?((l={})[h]=r.appendErrors(h,a,u,d,m),l):((v={})[h]=u[h]||t({message:m,type:d},a?{types:(f={},f[d]=m||!0,f)}:{}),v):{})}return u};exports.zodResolver=function(e,t){return function(n,o,i){void 0===i&&(i=!1);try{var s=e.safeParse(n,t);return Promise.resolve(s.success?{values:s.data,errors:{}}:{values:{},errors:r.transformToNestObject(a(s.error,i))})}catch(r){return Promise.reject(r)}}};
+//# sourceMappingURL=zod.js.map

package/zod/dist/zod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod.js","sources":["../src/zod.ts"],"sourcesContent":["import {\n  appendErrors,\n  Resolver,\n  ResolverError,\n  ResolverSuccess,\n  transformToNestObject,\n} from 'react-hook-form';\nimport * as z from 'zod';\nimport { ParseParams } from 'zod/lib/src/parser';\nimport { convertArrayToPathName } from '@hookform/resolvers';\n\nconst parseErrorSchema = (\n  zodError: z.ZodError,\n  validateAllFieldCriteria: boolean,\n) => {\n  if (zodError.isEmpty) {\n    return {};\n  }\n\n  const errors = [...zodError.errors];\n  let previous: Record<string, any> = {};\n\n  for (const error of errors) {\n    const { path, message, code: type } = error;\n    const currentPath = convertArrayToPathName(path);\n\n    if ('unionErrors' in error) {\n      for (const subErrors of error.unionErrors.map((e) => e.errors)) {\n        errors.push(...subErrors);\n      }\n    }\n\n    previous = {\n      ...previous,\n      ...(path\n        ? previous[currentPath] && validateAllFieldCriteria\n          ? {\n              [currentPath]: appendErrors(\n                currentPath,\n                validateAllFieldCriteria,\n                previous,\n                type,\n                message,\n              ),\n            }\n          : {\n              [currentPath]: previous[currentPath] || {\n                message,\n                type,\n                ...(validateAllFieldCriteria\n                  ? {\n                      types: { [type]: message || true },\n                    }\n                  : {}),\n              },\n            }\n        : {}),\n    };\n  }\n\n  return previous;\n};\n\nexport const zodResolver = <T extends z.ZodSchema<any, any>>(\n  schema: T,\n  options?: ParseParams,\n): Resolver<z.infer<T>> => async (\n  values,\n  _,\n  validateAllFieldCriteria = false,\n) => {\n  const result = schema.safeParse(values, options);\n\n  if (result.success) {\n    return { values: result.data, errors: {} } as ResolverSuccess<z.infer<T>>;\n  }\n\n  return {\n    values: {},\n    errors: transformToNestObject(\n      parseErrorSchema(result.error, validateAllFieldCriteria),\n    ),\n  } as ResolverError<z.infer<T>>;\n};\n"],"names":["parseErrorSchema","zodError","validateAllFieldCriteria","isEmpty","errors","previous","error","path","message","type","code","currentPath","convertArrayToPathName","unionErrors","map","e","push","appendErrors","types","schema","options","values","_","result","safeParse","success","data","transformToNestObject"],"mappings":"skCAWA,IAAMA,EAAmB,SACvBC,EACAC,GAEA,GAAID,EAASE,QACX,MAAO,GAMT,IAHA,MAAMC,YAAaH,EAASG,QACxBC,EAAgC,OAEhBD,kBAAQ,WAAjBE,UACDC,EAA8BD,EAA9BC,KAAMC,EAAwBF,EAAxBE,QAAeC,EAASH,EAAfI,KACjBC,EAAcC,yBAAuBL,GAE3C,GAAI,gBAAiBD,EACnB,cAAwBA,EAAMO,YAAYC,IAAI,SAACC,UAAMA,EAAEX,yBACrDA,EAAOY,WAAPZ,WAIJC,OACKA,EACCE,EACAF,EAASM,IAAgBT,UAEpBS,GAAcM,eACbN,EACAT,EACAG,EACAI,EACAD,cAIDG,GAAcN,EAASM,OACtBH,QAAAA,EACAC,KAAAA,GACIP,EACA,CACEgB,cAAUT,GAAOD,IAAW,MAE9B,OAGV,IAIR,OAAOH,uBAGkB,SACzBc,EACAC,mBAEAC,EACAC,EACApB,YAAAA,IAAAA,GAA2B,OAE3B,IAAMqB,EAASJ,EAAOK,UAAUH,EAAQD,GAExC,uBAAIG,EAAOE,QACF,CAAEJ,OAAQE,EAAOG,KAAMtB,OAAQ,IAGjC,CACLiB,OAAQ,GACRjB,OAAQuB,wBACN3B,EAAiBuB,EAAOjB,MAAOJ,MAjBV"}

package/zod/dist/zod.mjs

@@ -0,0 +1,2 @@
+import{transformToNestObject as r,appendErrors as e}from"react-hook-form";import{convertArrayToPathName as t}from"@hookform/resolvers";function n(){return(n=Object.assign||function(r){for(var e=1;e<arguments.length;e++){var t=arguments[e];for(var n in t)Object.prototype.hasOwnProperty.call(t,n)&&(r[n]=t[n])}return r}).apply(this,arguments)}function o(r,e){(null==e||e>r.length)&&(e=r.length);for(var t=0,n=new Array(e);t<e;t++)n[t]=r[t];return n}function a(r,e){var t;if("undefined"==typeof Symbol||null==r[Symbol.iterator]){if(Array.isArray(r)||(t=function(r,e){if(r){if("string"==typeof r)return o(r,e);var t=Object.prototype.toString.call(r).slice(8,-1);return"Object"===t&&r.constructor&&(t=r.constructor.name),"Map"===t||"Set"===t?Array.from(r):"Arguments"===t||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t)?o(r,e):void 0}}(r))||e&&r&&"number"==typeof r.length){t&&(r=t);var n=0;return function(){return n>=r.length?{done:!0}:{done:!1,value:r[n++]}}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}return(t=r[Symbol.iterator]()).next.bind(t)}var i=function(r,o){if(r.isEmpty)return{};for(var i,u=[].concat(r.errors),s={},c=a(u);!(i=c()).done;){var f,l,p,m=i.value,v=m.path,y=m.message,d=m.code,h=t(v);if("unionErrors"in m)for(var b,g=a(m.unionErrors.map(function(r){return r.errors}));!(b=g()).done;)u.push.apply(u,b.value);s=n({},s,v?s[h]&&o?((f={})[h]=e(h,o,s,d,y),f):((p={})[h]=s[h]||n({message:y,type:d},o?{types:(l={},l[d]=y||!0,l)}:{}),p):{})}return s},u=function(e,t){return function(n,o,a){void 0===a&&(a=!1);try{var u=e.safeParse(n,t);return Promise.resolve(u.success?{values:u.data,errors:{}}:{values:{},errors:r(i(u.error,a))})}catch(r){return Promise.reject(r)}}};export{u as zodResolver};
+//# sourceMappingURL=zod.module.js.map

package/zod/dist/zod.modern.js

@@ -0,0 +1,2 @@
+import{transformToNestObject as r,appendErrors as o}from"react-hook-form";import{convertArrayToPathName as s}from"@hookform/resolvers";function e(){return(e=Object.assign||function(r){for(var o=1;o<arguments.length;o++){var s=arguments[o];for(var e in s)Object.prototype.hasOwnProperty.call(s,e)&&(r[e]=s[e])}return r}).apply(this,arguments)}const t=(r,t)=>{if(r.isEmpty)return{};const n=[...r.errors];let a={};for(const r of n){const{path:c,message:f,code:p}=r,i=s(c);if("unionErrors"in r)for(const o of r.unionErrors.map(r=>r.errors))n.push(...o);a=e({},a,c?a[i]&&t?{[i]:o(i,t,a,p,f)}:{[i]:a[i]||e({message:f,type:p},t?{types:{[p]:f||!0}}:{})}:{})}return a},n=(o,s)=>async(e,n,a=!1)=>{const c=o.safeParse(e,s);return c.success?{values:c.data,errors:{}}:{values:{},errors:r(t(c.error,a))}};export{n as zodResolver};
+//# sourceMappingURL=zod.modern.js.map

package/zod/dist/zod.modern.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod.modern.js","sources":["../src/zod.ts"],"sourcesContent":["import {\n  appendErrors,\n  Resolver,\n  ResolverError,\n  ResolverSuccess,\n  transformToNestObject,\n} from 'react-hook-form';\nimport * as z from 'zod';\nimport { ParseParams } from 'zod/lib/src/parser';\nimport { convertArrayToPathName } from '@hookform/resolvers';\n\nconst parseErrorSchema = (\n  zodError: z.ZodError,\n  validateAllFieldCriteria: boolean,\n) => {\n  if (zodError.isEmpty) {\n    return {};\n  }\n\n  const errors = [...zodError.errors];\n  let previous: Record<string, any> = {};\n\n  for (const error of errors) {\n    const { path, message, code: type } = error;\n    const currentPath = convertArrayToPathName(path);\n\n    if ('unionErrors' in error) {\n      for (const subErrors of error.unionErrors.map((e) => e.errors)) {\n        errors.push(...subErrors);\n      }\n    }\n\n    previous = {\n      ...previous,\n      ...(path\n        ? previous[currentPath] && validateAllFieldCriteria\n          ? {\n              [currentPath]: appendErrors(\n                currentPath,\n                validateAllFieldCriteria,\n                previous,\n                type,\n                message,\n              ),\n            }\n          : {\n              [currentPath]: previous[currentPath] || {\n                message,\n                type,\n                ...(validateAllFieldCriteria\n                  ? {\n                      types: { [type]: message || true },\n                    }\n                  : {}),\n              },\n            }\n        : {}),\n    };\n  }\n\n  return previous;\n};\n\nexport const zodResolver = <T extends z.ZodSchema<any, any>>(\n  schema: T,\n  options?: ParseParams,\n): Resolver<z.infer<T>> => async (\n  values,\n  _,\n  validateAllFieldCriteria = false,\n) => {\n  const result = schema.safeParse(values, options);\n\n  if (result.success) {\n    return { values: result.data, errors: {} } as ResolverSuccess<z.infer<T>>;\n  }\n\n  return {\n    values: {},\n    errors: transformToNestObject(\n      parseErrorSchema(result.error, validateAllFieldCriteria),\n    ),\n  } as ResolverError<z.infer<T>>;\n};\n"],"names":["parseErrorSchema","zodError","validateAllFieldCriteria","isEmpty","errors","previous","error","path","message","code","type","currentPath","convertArrayToPathName","subErrors","unionErrors","map","e","push","[object Object]","appendErrors","types","zodResolver","schema","options","async","values","_","result","safeParse","success","data","transformToNestObject"],"mappings":"sVAWA,MAAMA,EAAmB,CACvBC,EACAC,KAEA,GAAID,EAASE,QACX,MAAO,GAGT,MAAMC,EAAS,IAAIH,EAASG,QAC5B,IAAIC,EAAgC,GAEpC,IAAK,MAAMC,KAASF,EAAQ,CAC1B,MAAMG,KAAEA,EAAFC,QAAQA,EAASC,KAAMC,GAASJ,EAChCK,EAAcC,EAAuBL,GAE3C,GAAI,gBAAiBD,EACnB,IAAK,MAAMO,KAAaP,EAAMQ,YAAYC,IAAKC,GAAMA,EAAEZ,QACrDA,EAAOa,QAAQJ,GAInBR,OACKA,EACCE,EACAF,EAASM,IAAgBT,EACvB,CACEgB,CAACP,GAAcQ,EACbR,EACAT,EACAG,EACAK,EACAF,IAGJ,CACEU,CAACP,GAAcN,EAASM,OACtBH,QAAAA,EACAE,KAAAA,GACIR,EACA,CACEkB,MAAO,CAAEF,CAACR,GAAOF,IAAW,IAE9B,KAGV,IAIR,OAAOH,GAGIgB,EAAc,CACzBC,EACAC,IACyBC,MACzBC,EACAC,EACAxB,GAA2B,KAE3B,MAAMyB,EAASL,EAAOM,UAAUH,EAAQF,GAExC,OAAII,EAAOE,QACF,CAAEJ,OAAQE,EAAOG,KAAM1B,OAAQ,IAGjC,CACLqB,OAAQ,GACRrB,OAAQ2B,EACN/B,EAAiB2B,EAAOrB,MAAOJ"}

package/zod/dist/zod.module.js

@@ -0,0 +1,2 @@
+import{transformToNestObject as r,appendErrors as e}from"react-hook-form";import{convertArrayToPathName as t}from"@hookform/resolvers";function n(){return(n=Object.assign||function(r){for(var e=1;e<arguments.length;e++){var t=arguments[e];for(var n in t)Object.prototype.hasOwnProperty.call(t,n)&&(r[n]=t[n])}return r}).apply(this,arguments)}function o(r,e){(null==e||e>r.length)&&(e=r.length);for(var t=0,n=new Array(e);t<e;t++)n[t]=r[t];return n}function a(r,e){var t;if("undefined"==typeof Symbol||null==r[Symbol.iterator]){if(Array.isArray(r)||(t=function(r,e){if(r){if("string"==typeof r)return o(r,e);var t=Object.prototype.toString.call(r).slice(8,-1);return"Object"===t&&r.constructor&&(t=r.constructor.name),"Map"===t||"Set"===t?Array.from(r):"Arguments"===t||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t)?o(r,e):void 0}}(r))||e&&r&&"number"==typeof r.length){t&&(r=t);var n=0;return function(){return n>=r.length?{done:!0}:{done:!1,value:r[n++]}}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}return(t=r[Symbol.iterator]()).next.bind(t)}var i=function(r,o){if(r.isEmpty)return{};for(var i,u=[].concat(r.errors),s={},c=a(u);!(i=c()).done;){var f,l,p,m=i.value,v=m.path,y=m.message,d=m.code,h=t(v);if("unionErrors"in m)for(var b,g=a(m.unionErrors.map(function(r){return r.errors}));!(b=g()).done;)u.push.apply(u,b.value);s=n({},s,v?s[h]&&o?((f={})[h]=e(h,o,s,d,y),f):((p={})[h]=s[h]||n({message:y,type:d},o?{types:(l={},l[d]=y||!0,l)}:{}),p):{})}return s},u=function(e,t){return function(n,o,a){void 0===a&&(a=!1);try{var u=e.safeParse(n,t);return Promise.resolve(u.success?{values:u.data,errors:{}}:{values:{},errors:r(i(u.error,a))})}catch(r){return Promise.reject(r)}}};export{u as zodResolver};
+//# sourceMappingURL=zod.module.js.map

package/zod/dist/zod.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod.module.js","sources":["../src/zod.ts"],"sourcesContent":["import {\n  appendErrors,\n  Resolver,\n  ResolverError,\n  ResolverSuccess,\n  transformToNestObject,\n} from 'react-hook-form';\nimport * as z from 'zod';\nimport { ParseParams } from 'zod/lib/src/parser';\nimport { convertArrayToPathName } from '@hookform/resolvers';\n\nconst parseErrorSchema = (\n  zodError: z.ZodError,\n  validateAllFieldCriteria: boolean,\n) => {\n  if (zodError.isEmpty) {\n    return {};\n  }\n\n  const errors = [...zodError.errors];\n  let previous: Record<string, any> = {};\n\n  for (const error of errors) {\n    const { path, message, code: type } = error;\n    const currentPath = convertArrayToPathName(path);\n\n    if ('unionErrors' in error) {\n      for (const subErrors of error.unionErrors.map((e) => e.errors)) {\n        errors.push(...subErrors);\n      }\n    }\n\n    previous = {\n      ...previous,\n      ...(path\n        ? previous[currentPath] && validateAllFieldCriteria\n          ? {\n              [currentPath]: appendErrors(\n                currentPath,\n                validateAllFieldCriteria,\n                previous,\n                type,\n                message,\n              ),\n            }\n          : {\n              [currentPath]: previous[currentPath] || {\n                message,\n                type,\n                ...(validateAllFieldCriteria\n                  ? {\n                      types: { [type]: message || true },\n                    }\n                  : {}),\n              },\n            }\n        : {}),\n    };\n  }\n\n  return previous;\n};\n\nexport const zodResolver = <T extends z.ZodSchema<any, any>>(\n  schema: T,\n  options?: ParseParams,\n): Resolver<z.infer<T>> => async (\n  values,\n  _,\n  validateAllFieldCriteria = false,\n) => {\n  const result = schema.safeParse(values, options);\n\n  if (result.success) {\n    return { values: result.data, errors: {} } as ResolverSuccess<z.infer<T>>;\n  }\n\n  return {\n    values: {},\n    errors: transformToNestObject(\n      parseErrorSchema(result.error, validateAllFieldCriteria),\n    ),\n  } as ResolverError<z.infer<T>>;\n};\n"],"names":["parseErrorSchema","zodError","validateAllFieldCriteria","isEmpty","errors","previous","error","path","message","type","code","currentPath","convertArrayToPathName","unionErrors","map","e","push","appendErrors","types","zodResolver","schema","options","values","_","result","safeParse","success","data","transformToNestObject"],"mappings":"2oCAWA,IAAMA,EAAmB,SACvBC,EACAC,GAEA,GAAID,EAASE,QACX,MAAO,GAMT,IAHA,MAAMC,YAAaH,EAASG,QACxBC,EAAgC,OAEhBD,kBAAQ,WAAjBE,UACDC,EAA8BD,EAA9BC,KAAMC,EAAwBF,EAAxBE,QAAeC,EAASH,EAAfI,KACjBC,EAAcC,EAAuBL,GAE3C,GAAI,gBAAiBD,EACnB,cAAwBA,EAAMO,YAAYC,IAAI,SAACC,UAAMA,EAAEX,yBACrDA,EAAOY,WAAPZ,WAIJC,OACKA,EACCE,EACAF,EAASM,IAAgBT,UAEpBS,GAAcM,EACbN,EACAT,EACAG,EACAI,EACAD,cAIDG,GAAcN,EAASM,OACtBH,QAAAA,EACAC,KAAAA,GACIP,EACA,CACEgB,cAAUT,GAAOD,IAAW,MAE9B,OAGV,IAIR,OAAOH,GAGIc,EAAc,SACzBC,EACAC,mBAEAC,EACAC,EACArB,YAAAA,IAAAA,GAA2B,OAE3B,IAAMsB,EAASJ,EAAOK,UAAUH,EAAQD,GAExC,uBAAIG,EAAOE,QACF,CAAEJ,OAAQE,EAAOG,KAAMvB,OAAQ,IAGjC,CACLkB,OAAQ,GACRlB,OAAQwB,EACN5B,EAAiBwB,EAAOlB,MAAOJ,MAjBV"}

package/zod/dist/zod.umd.js

@@ -0,0 +1,2 @@
+!function(r,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports,require("react-hook-form"),require("@hookform/resolvers")):"function"==typeof define&&define.amd?define(["exports","react-hook-form","@hookform/resolvers"],e):e((r||self).hookformResolversZod={},r.reactHookForm,r.hookformResolvers)}(this,function(r,e,o){function t(){return(t=Object.assign||function(r){for(var e=1;e<arguments.length;e++){var o=arguments[e];for(var t in o)Object.prototype.hasOwnProperty.call(o,t)&&(r[t]=o[t])}return r}).apply(this,arguments)}function n(r,e){(null==e||e>r.length)&&(e=r.length);for(var o=0,t=new Array(e);o<e;o++)t[o]=r[o];return t}function a(r,e){var o;if("undefined"==typeof Symbol||null==r[Symbol.iterator]){if(Array.isArray(r)||(o=function(r,e){if(r){if("string"==typeof r)return n(r,e);var o=Object.prototype.toString.call(r).slice(8,-1);return"Object"===o&&r.constructor&&(o=r.constructor.name),"Map"===o||"Set"===o?Array.from(r):"Arguments"===o||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(o)?n(r,e):void 0}}(r))||e&&r&&"number"==typeof r.length){o&&(r=o);var t=0;return function(){return t>=r.length?{done:!0}:{done:!1,value:r[t++]}}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}return(o=r[Symbol.iterator]()).next.bind(o)}var s=function(r,n){if(r.isEmpty)return{};for(var s,i=[].concat(r.errors),u={},f=a(i);!(s=f()).done;){var l,c,p,m=s.value,v=m.path,y=m.message,d=m.code,h=o.convertArrayToPathName(v);if("unionErrors"in m)for(var b,g=a(m.unionErrors.map(function(r){return r.errors}));!(b=g()).done;)i.push.apply(i,b.value);u=t({},u,v?u[h]&&n?((l={})[h]=e.appendErrors(h,n,u,d,y),l):((p={})[h]=u[h]||t({message:y,type:d},n?{types:(c={},c[d]=y||!0,c)}:{}),p):{})}return u};r.zodResolver=function(r,o){return function(t,n,a){void 0===a&&(a=!1);try{var i=r.safeParse(t,o);return Promise.resolve(i.success?{values:i.data,errors:{}}:{values:{},errors:e.transformToNestObject(s(i.error,a))})}catch(r){return Promise.reject(r)}}}});
+//# sourceMappingURL=zod.umd.js.map

package/zod/dist/zod.umd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod.umd.js","sources":["../src/zod.ts"],"sourcesContent":["import {\n  appendErrors,\n  Resolver,\n  ResolverError,\n  ResolverSuccess,\n  transformToNestObject,\n} from 'react-hook-form';\nimport * as z from 'zod';\nimport { ParseParams } from 'zod/lib/src/parser';\nimport { convertArrayToPathName } from '@hookform/resolvers';\n\nconst parseErrorSchema = (\n  zodError: z.ZodError,\n  validateAllFieldCriteria: boolean,\n) => {\n  if (zodError.isEmpty) {\n    return {};\n  }\n\n  const errors = [...zodError.errors];\n  let previous: Record<string, any> = {};\n\n  for (const error of errors) {\n    const { path, message, code: type } = error;\n    const currentPath = convertArrayToPathName(path);\n\n    if ('unionErrors' in error) {\n      for (const subErrors of error.unionErrors.map((e) => e.errors)) {\n        errors.push(...subErrors);\n      }\n    }\n\n    previous = {\n      ...previous,\n      ...(path\n        ? previous[currentPath] && validateAllFieldCriteria\n          ? {\n              [currentPath]: appendErrors(\n                currentPath,\n                validateAllFieldCriteria,\n                previous,\n                type,\n                message,\n              ),\n            }\n          : {\n              [currentPath]: previous[currentPath] || {\n                message,\n                type,\n                ...(validateAllFieldCriteria\n                  ? {\n                      types: { [type]: message || true },\n                    }\n                  : {}),\n              },\n            }\n        : {}),\n    };\n  }\n\n  return previous;\n};\n\nexport const zodResolver = <T extends z.ZodSchema<any, any>>(\n  schema: T,\n  options?: ParseParams,\n): Resolver<z.infer<T>> => async (\n  values,\n  _,\n  validateAllFieldCriteria = false,\n) => {\n  const result = schema.safeParse(values, options);\n\n  if (result.success) {\n    return { values: result.data, errors: {} } as ResolverSuccess<z.infer<T>>;\n  }\n\n  return {\n    values: {},\n    errors: transformToNestObject(\n      parseErrorSchema(result.error, validateAllFieldCriteria),\n    ),\n  } as ResolverError<z.infer<T>>;\n};\n"],"names":["parseErrorSchema","zodError","validateAllFieldCriteria","isEmpty","errors","previous","error","path","message","type","code","currentPath","convertArrayToPathName","unionErrors","map","e","push","appendErrors","types","schema","options","values","_","result","safeParse","success","data","transformToNestObject"],"mappings":"43CAWA,IAAMA,EAAmB,SACvBC,EACAC,GAEA,GAAID,EAASE,QACX,MAAO,GAMT,IAHA,MAAMC,YAAaH,EAASG,QACxBC,EAAgC,OAEhBD,kBAAQ,WAAjBE,UACDC,EAA8BD,EAA9BC,KAAMC,EAAwBF,EAAxBE,QAAeC,EAASH,EAAfI,KACjBC,EAAcC,yBAAuBL,GAE3C,GAAI,gBAAiBD,EACnB,cAAwBA,EAAMO,YAAYC,IAAI,SAACC,UAAMA,EAAEX,yBACrDA,EAAOY,WAAPZ,WAIJC,OACKA,EACCE,EACAF,EAASM,IAAgBT,UAEpBS,GAAcM,eACbN,EACAT,EACAG,EACAI,EACAD,cAIDG,GAAcN,EAASM,OACtBH,QAAAA,EACAC,KAAAA,GACIP,EACA,CACEgB,cAAUT,GAAOD,IAAW,MAE9B,OAGV,IAIR,OAAOH,iBAGkB,SACzBc,EACAC,mBAEAC,EACAC,EACApB,YAAAA,IAAAA,GAA2B,OAE3B,IAAMqB,EAASJ,EAAOK,UAAUH,EAAQD,GAExC,uBAAIG,EAAOE,QACF,CAAEJ,OAAQE,EAAOG,KAAMtB,OAAQ,IAGjC,CACLiB,OAAQ,GACRjB,OAAQuB,wBACN3B,EAAiBuB,EAAOjB,MAAOJ,MAjBV"}

package/zod/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "zod",
+  "amdName": "hookformResolversZod",
+  "version": "1.0.0",
+  "private": true,
+  "description": "React Hook Form validation resolver: zod",
+  "main": "dist/zod.js",
+  "module": "dist/zod.module.js",
+  "umd:main": "dist/zod.umd.js",
+  "source": "src/index.ts",
+  "types": "dist/index.d.ts",
+  "license": "MIT",
+  "peerDependencies": {
+    "react-hook-form": ">=6.6.0",
+    "@hookform/resolvers": "^1.0.0"
+  }
+}