@hookform/resolvers 2.8.1

package/class-validator/src/__tests__/Form.tsx

@@ -0,0 +1,55 @@
+import React from 'react';
+import { render, screen, act } from '@testing-library/react';
+import user from '@testing-library/user-event';
+import { useForm } from 'react-hook-form';
+import { classValidatorResolver } from '..';
+import { IsNotEmpty } from 'class-validator';
+
+class Schema {
+  @IsNotEmpty()
+  username: string;
+
+  @IsNotEmpty()
+  password: string;
+}
+
+interface Props {
+  onSubmit: (data: Schema) => void;
+}
+
+function TestComponent({ onSubmit }: Props) {
+  const {
+    register,
+    formState: { errors },
+    handleSubmit,
+  } = useForm<Schema>({
+    resolver: classValidatorResolver(Schema),
+  });
+
+  return (
+    <form onSubmit={handleSubmit(onSubmit)}>
+      <input {...register('username')} />
+      {errors.username && <span role="alert">{errors.username.message}</span>}
+
+      <input {...register('password')} />
+      {errors.password && <span role="alert">{errors.password.message}</span>}
+
+      <button type="submit">submit</button>
+    </form>
+  );
+}
+
+test("form's validation with Class Validator and TypeScript's integration", async () => {
+  const handleSubmit = jest.fn();
+  render(<TestComponent onSubmit={handleSubmit} />);
+
+  expect(screen.queryAllByRole(/alert/i)).toHaveLength(0);
+
+  await act(async () => {
+    user.click(screen.getByText(/submit/i));
+  });
+
+  expect(screen.getByText(/username should not be empty/i)).toBeInTheDocument();
+  expect(screen.getByText(/password should not be empty/i)).toBeInTheDocument();
+  expect(handleSubmit).not.toHaveBeenCalled();
+});

package/class-validator/src/__tests__/__fixtures__/data.ts

@@ -0,0 +1,88 @@
+import 'reflect-metadata';
+import { Type } from 'class-transformer';
+import {
+  IsEmail,
+  IsNotEmpty,
+  Length,
+  Matches,
+  Max,
+  Min,
+  ValidateNested,
+} from 'class-validator';
+import { Field, InternalFieldName } from 'react-hook-form';
+
+class Like {
+  @IsNotEmpty()
+  id: number;
+
+  @Length(4)
+  name: string;
+}
+
+export class Schema {
+  @Matches(/^\w+$/)
+  @Length(3, 30)
+  username: string;
+
+  @Matches(/^[a-zA-Z0-9]{3,30}/)
+  password: string;
+
+  @Min(1900)
+  @Max(2013)
+  birthYear: number;
+
+  @IsEmail()
+  email: string;
+
+  accessToken: string;
+
+  tags: string[];
+
+  enabled: boolean;
+
+  @ValidateNested({ each: true })
+  @Type(() => Like)
+  like: Like[];
+}
+
+export const validData: Schema = {
+  username: 'Doe',
+  password: 'Password123',
+  birthYear: 2000,
+  email: 'john@doe.com',
+  tags: ['tag1', 'tag2'],
+  enabled: true,
+  accessToken: 'accessToken',
+  like: [
+    {
+      id: 1,
+      name: 'name',
+    },
+  ],
+};
+
+export const invalidData = {
+  password: '___',
+  email: '',
+  birthYear: 'birthYear',
+  like: [{ id: 'z' }],
+};
+
+export const fields: Record<InternalFieldName, Field['_f']> = {
+  username: {
+    ref: { name: 'username' },
+    name: 'username',
+  },
+  password: {
+    ref: { name: 'password' },
+    name: 'password',
+  },
+  email: {
+    ref: { name: 'email' },
+    name: 'email',
+  },
+  birthday: {
+    ref: { name: 'birthday' },
+    name: 'birthday',
+  },
+};

package/class-validator/src/__tests__/__snapshots__/class-validator.ts.snap

@@ -0,0 +1,207 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`classValidatorResolver should return a single error from classValidatorResolver when validation fails 1`] = `
+Object {
+  "errors": Object {
+    "birthYear": Object {
+      "message": "birthYear must not be greater than 2013",
+      "ref": undefined,
+      "type": "max",
+    },
+    "email": Object {
+      "message": "email must be an email",
+      "ref": Object {
+        "name": "email",
+      },
+      "type": "isEmail",
+    },
+    "like": Array [
+      Object {
+        "name": Object {
+          "message": "name must be longer than or equal to 4 characters",
+          "ref": undefined,
+          "type": "isLength",
+        },
+      },
+    ],
+    "password": Object {
+      "message": "password must match /^[a-zA-Z0-9]{3,30}/ regular expression",
+      "ref": Object {
+        "name": "password",
+      },
+      "type": "matches",
+    },
+    "username": Object {
+      "message": "username must be longer than or equal to 3 characters",
+      "ref": Object {
+        "name": "username",
+      },
+      "type": "isLength",
+    },
+  },
+  "values": Object {},
+}
+`;
+
+exports[`classValidatorResolver should return a single error from classValidatorResolver with \`mode: sync\` when validation fails 1`] = `
+Object {
+  "errors": Object {
+    "birthYear": Object {
+      "message": "birthYear must not be greater than 2013",
+      "ref": undefined,
+      "type": "max",
+    },
+    "email": Object {
+      "message": "email must be an email",
+      "ref": Object {
+        "name": "email",
+      },
+      "type": "isEmail",
+    },
+    "like": Array [
+      Object {
+        "name": Object {
+          "message": "name must be longer than or equal to 4 characters",
+          "ref": undefined,
+          "type": "isLength",
+        },
+      },
+    ],
+    "password": Object {
+      "message": "password must match /^[a-zA-Z0-9]{3,30}/ regular expression",
+      "ref": Object {
+        "name": "password",
+      },
+      "type": "matches",
+    },
+    "username": Object {
+      "message": "username must be longer than or equal to 3 characters",
+      "ref": Object {
+        "name": "username",
+      },
+      "type": "isLength",
+    },
+  },
+  "values": Object {},
+}
+`;
+
+exports[`classValidatorResolver should return all the errors from classValidatorResolver when validation fails with \`validateAllFieldCriteria\` set to true 1`] = `
+Object {
+  "errors": Object {
+    "birthYear": Object {
+      "message": "birthYear must not be greater than 2013",
+      "ref": undefined,
+      "type": "max",
+      "types": Object {
+        "max": "birthYear must not be greater than 2013",
+        "min": "birthYear must not be less than 1900",
+      },
+    },
+    "email": Object {
+      "message": "email must be an email",
+      "ref": Object {
+        "name": "email",
+      },
+      "type": "isEmail",
+      "types": Object {
+        "isEmail": "email must be an email",
+      },
+    },
+    "like": Array [
+      Object {
+        "name": Object {
+          "message": "name must be longer than or equal to 4 characters",
+          "ref": undefined,
+          "type": "isLength",
+          "types": Object {
+            "isLength": "name must be longer than or equal to 4 characters",
+          },
+        },
+      },
+    ],
+    "password": Object {
+      "message": "password must match /^[a-zA-Z0-9]{3,30}/ regular expression",
+      "ref": Object {
+        "name": "password",
+      },
+      "type": "matches",
+      "types": Object {
+        "matches": "password must match /^[a-zA-Z0-9]{3,30}/ regular expression",
+      },
+    },
+    "username": Object {
+      "message": "username must be longer than or equal to 3 characters",
+      "ref": Object {
+        "name": "username",
+      },
+      "type": "isLength",
+      "types": Object {
+        "isLength": "username must be longer than or equal to 3 characters",
+        "matches": "username must match /^\\\\w+$/ regular expression",
+      },
+    },
+  },
+  "values": Object {},
+}
+`;
+
+exports[`classValidatorResolver should return all the errors from classValidatorResolver when validation fails with \`validateAllFieldCriteria\` set to true and \`mode: sync\` 1`] = `
+Object {
+  "errors": Object {
+    "birthYear": Object {
+      "message": "birthYear must not be greater than 2013",
+      "ref": undefined,
+      "type": "max",
+      "types": Object {
+        "max": "birthYear must not be greater than 2013",
+        "min": "birthYear must not be less than 1900",
+      },
+    },
+    "email": Object {
+      "message": "email must be an email",
+      "ref": Object {
+        "name": "email",
+      },
+      "type": "isEmail",
+      "types": Object {
+        "isEmail": "email must be an email",
+      },
+    },
+    "like": Array [
+      Object {
+        "name": Object {
+          "message": "name must be longer than or equal to 4 characters",
+          "ref": undefined,
+          "type": "isLength",
+          "types": Object {
+            "isLength": "name must be longer than or equal to 4 characters",
+          },
+        },
+      },
+    ],
+    "password": Object {
+      "message": "password must match /^[a-zA-Z0-9]{3,30}/ regular expression",
+      "ref": Object {
+        "name": "password",
+      },
+      "type": "matches",
+      "types": Object {
+        "matches": "password must match /^[a-zA-Z0-9]{3,30}/ regular expression",
+      },
+    },
+    "username": Object {
+      "message": "username must be longer than or equal to 3 characters",
+      "ref": Object {
+        "name": "username",
+      },
+      "type": "isLength",
+      "types": Object {
+        "isLength": "username must be longer than or equal to 3 characters",
+        "matches": "username must match /^\\\\w+$/ regular expression",
+      },
+    },
+  },
+  "values": Object {},
+}
+`;

package/class-validator/src/__tests__/class-validator.ts

@@ -0,0 +1,87 @@
+/* eslint-disable no-console, @typescript-eslint/ban-ts-comment */
+import { classValidatorResolver } from '..';
+import { Schema, validData, fields, invalidData } from './__fixtures__/data';
+import * as classValidator from 'class-validator';
+
+const shouldUseNativeValidation = false;
+
+describe('classValidatorResolver', () => {
+  it('should return values from classValidatorResolver when validation pass', async () => {
+    const schemaSpy = jest.spyOn(classValidator, 'validate');
+    const schemaSyncSpy = jest.spyOn(classValidator, 'validateSync');
+
+    const result = await classValidatorResolver(Schema)(validData, undefined, {
+      fields,
+      shouldUseNativeValidation,
+    });
+
+    expect(schemaSpy).toHaveBeenCalledTimes(1);
+    expect(schemaSyncSpy).not.toHaveBeenCalled();
+    expect(result).toEqual({ errors: {}, values: validData });
+  });
+
+  it('should return values from classValidatorResolver with `mode: sync` when validation pass', async () => {
+    const validateSyncSpy = jest.spyOn(classValidator, 'validateSync');
+    const validateSpy = jest.spyOn(classValidator, 'validate');
+
+    const result = await classValidatorResolver(Schema, undefined, {
+      mode: 'sync',
+    })(validData, undefined, { fields, shouldUseNativeValidation });
+
+    expect(validateSyncSpy).toHaveBeenCalledTimes(1);
+    expect(validateSpy).not.toHaveBeenCalled();
+    expect(result).toEqual({ errors: {}, values: validData });
+  });
+
+  it('should return a single error from classValidatorResolver when validation fails', async () => {
+    const result = await classValidatorResolver(Schema)(
+      invalidData,
+      undefined,
+      {
+        fields,
+        shouldUseNativeValidation,
+      },
+    );
+
+    expect(result).toMatchSnapshot();
+  });
+
+  it('should return a single error from classValidatorResolver with `mode: sync` when validation fails', async () => {
+    const validateSyncSpy = jest.spyOn(classValidator, 'validateSync');
+    const validateSpy = jest.spyOn(classValidator, 'validate');
+
+    const result = await classValidatorResolver(Schema, undefined, {
+      mode: 'sync',
+    })(invalidData, undefined, { fields, shouldUseNativeValidation });
+
+    expect(validateSyncSpy).toHaveBeenCalledTimes(1);
+    expect(validateSpy).not.toHaveBeenCalled();
+    expect(result).toMatchSnapshot();
+  });
+
+  it('should return all the errors from classValidatorResolver when validation fails with `validateAllFieldCriteria` set to true', async () => {
+    const result = await classValidatorResolver(Schema)(
+      invalidData,
+      undefined,
+      {
+        fields,
+        criteriaMode: 'all',
+        shouldUseNativeValidation,
+      },
+    );
+
+    expect(result).toMatchSnapshot();
+  });
+
+  it('should return all the errors from classValidatorResolver when validation fails with `validateAllFieldCriteria` set to true and `mode: sync`', async () => {
+    const result = await classValidatorResolver(Schema, undefined, {
+      mode: 'sync',
+    })(invalidData, undefined, {
+      fields,
+      criteriaMode: 'all',
+      shouldUseNativeValidation,
+    });
+
+    expect(result).toMatchSnapshot();
+  });
+});

package/class-validator/src/class-validator.ts

@@ -0,0 +1,62 @@
+import { FieldErrors } from 'react-hook-form';
+import { toNestError, validateFieldsNatively } from '@hookform/resolvers';
+import { plainToClass } from 'class-transformer';
+import { validate, validateSync, ValidationError } from 'class-validator';
+import type { Resolver } from './types';
+
+const parseErrors = (
+  errors: ValidationError[],
+  validateAllFieldCriteria: boolean,
+  parsedErrors: FieldErrors = {},
+  path = '',
+) => {
+  return errors.reduce((acc, error) => {
+    const _path = path ? `${path}.${error.property}` : error.property;
+
+    if (error.constraints) {
+      const key = Object.keys(error.constraints)[0];
+      acc[_path] = {
+        type: key,
+        message: error.constraints[key],
+      };
+
+      if (validateAllFieldCriteria && acc[_path]) {
+        Object.assign(acc[_path], { types: error.constraints });
+      }
+    }
+
+    if (error.children && error.children.length) {
+      parseErrors(error.children, validateAllFieldCriteria, acc, _path);
+    }
+
+    return acc;
+  }, parsedErrors);
+};
+
+export const classValidatorResolver: Resolver =
+  (schema, schemaOptions = {}, resolverOptions = {}) =>
+  async (values, _, options) => {
+    const user = plainToClass(schema, values);
+
+    const rawErrors = await (resolverOptions.mode === 'sync'
+      ? validateSync
+      : validate)(user, schemaOptions);
+
+    if (rawErrors.length) {
+      return {
+        values: {},
+        errors: toNestError(
+          parseErrors(
+            rawErrors,
+            !options.shouldUseNativeValidation &&
+              options.criteriaMode === 'all',
+          ),
+          options,
+        ),
+      };
+    }
+
+    options.shouldUseNativeValidation && validateFieldsNatively({}, options);
+
+    return { values, errors: {} };
+  };

package/class-validator/src/index.ts

@@ -0,0 +1,2 @@
+export * from './class-validator';
+export * from './types';

package/class-validator/src/types.ts

@@ -0,0 +1,22 @@
+import {
+  FieldValues,
+  ResolverOptions,
+  ResolverResult,
+  UnpackNestedValue,
+} from 'react-hook-form';
+import { ValidatorOptions } from 'class-validator';
+import { ClassConstructor } from 'class-transformer';
+
+export type Resolver = <
+  T extends { [_: string]: any },
+  TFieldValues extends FieldValues,
+  TContext,
+>(
+  schema: ClassConstructor<T>,
+  schemaOptions?: ValidatorOptions,
+  resolverOptions?: { mode?: 'async' | 'sync' },
+) => (
+  values: UnpackNestedValue<TFieldValues>,
+  context: TContext | undefined,
+  options: ResolverOptions<TFieldValues>,
+) => Promise<ResolverResult<TFieldValues>>;

package/computed-types/dist/computed-types.d.ts

@@ -0,0 +1,2 @@
+import type { Resolver } from './types';
+export declare const computedTypesResolver: Resolver;

package/computed-types/dist/computed-types.js

@@ -0,0 +1,2 @@
+var r=require("@hookform/resolvers"),e=function r(e,t,o){return void 0===t&&(t={}),void 0===o&&(o=""),(e.errors||[]).reduce(function(e,t){var n=String(t.path[0]),s=o?o+"."+n:n;return e[s]={type:t.error.name,message:t.error.message},r(t.error,e,s),e},t)};exports.computedTypesResolver=function(t){return function(o,n,s){try{return Promise.resolve(function(e,n){try{var u=Promise.resolve(t(o)).then(function(e){return s.shouldUseNativeValidation&&r.validateFieldsNatively({},s),{errors:{},values:e}})}catch(r){return n(r)}return u&&u.then?u.then(void 0,n):u}(0,function(t){return{values:{},errors:r.toNestError(e(t),s)}}))}catch(r){return Promise.reject(r)}}};
+//# sourceMappingURL=computed-types.js.map

package/computed-types/dist/computed-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"computed-types.js","sources":["../src/computed-types.ts"],"sourcesContent":["import type { FieldErrors } from 'react-hook-form';\nimport { toNestError, validateFieldsNatively } from '@hookform/resolvers';\nimport type { ValidationError } from 'computed-types';\nimport type { Resolver } from './types';\n\nconst parseErrorSchema = (\n  computedTypesError: ValidationError,\n  parsedErrors: FieldErrors = {},\n  path = '',\n) => {\n  return (computedTypesError.errors || []).reduce((acc, error) => {\n    const _currentPath = String(error.path[0]);\n    const _path = path ? `${path}.${_currentPath}` : _currentPath;\n\n    acc[_path] = {\n      type: error.error.name,\n      message: error.error.message,\n    };\n\n    parseErrorSchema(error.error, acc, _path);\n\n    return acc;\n  }, parsedErrors);\n};\n\nexport const computedTypesResolver: Resolver =\n  (schema) => async (values, _, options) => {\n    try {\n      const data = await schema(values);\n\n      options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n      return {\n        errors: {},\n        values: data,\n      };\n    } catch (error) {\n      return {\n        values: {},\n        errors: toNestError(parseErrorSchema(error), options),\n      };\n    }\n  };\n"],"names":["parseErrorSchema","computedTypesError","parsedErrors","path","errors","reduce","acc","error","_currentPath","String","_path","type","name","message","schema","values","_","options","data","shouldUseNativeValidation","validateFieldsNatively","toNestError"],"mappings":"qCAKMA,EAAmB,SAAnBA,EACJC,EACAC,EACAC,GAEA,gBAHAD,IAAAA,EAA4B,aAC5BC,IAAAA,EAAO,KAECF,EAAmBG,QAAU,IAAIC,OAAO,SAACC,EAAKC,GACpD,IAAMC,EAAeC,OAAOF,EAAMJ,KAAK,IACjCO,EAAQP,EAAUA,MAAQK,EAAiBA,EASjD,OAPAF,EAAII,GAAS,CACXC,KAAMJ,EAAMA,MAAMK,KAClBC,QAASN,EAAMA,MAAMM,SAGvBb,EAAiBO,EAAMA,MAAOD,EAAKI,GAE5BJ,GACNJ,kCAIH,SAACY,mBAAkBC,EAAQC,EAAGC,sEAEPH,EAAOC,kBAApBG,GAIN,OAFAD,EAAQE,2BAA6BC,yBAAuB,GAAIH,GAEzD,CACLb,OAAQ,GACRW,OAAQG,0EAEHX,GACP,MAAO,CACLQ,OAAQ,GACRX,OAAQiB,cAAYrB,EAAiBO,GAAQU,OAbnD"}

package/computed-types/dist/computed-types.mjs

@@ -0,0 +1,2 @@
+import{validateFieldsNatively as r,toNestError as e}from"@hookform/resolvers";var t=function r(e,t,o){return void 0===t&&(t={}),void 0===o&&(o=""),(e.errors||[]).reduce(function(e,t){var n=String(t.path[0]),u=o?o+"."+n:n;return e[u]={type:t.error.name,message:t.error.message},r(t.error,e,u),e},t)},o=function(o){return function(n,u,i){try{return Promise.resolve(function(e,t){try{var u=Promise.resolve(o(n)).then(function(e){return i.shouldUseNativeValidation&&r({},i),{errors:{},values:e}})}catch(r){return t(r)}return u&&u.then?u.then(void 0,t):u}(0,function(r){return{values:{},errors:e(t(r),i)}}))}catch(r){return Promise.reject(r)}}};export{o as computedTypesResolver};
+//# sourceMappingURL=computed-types.module.js.map

package/computed-types/dist/computed-types.modern.js

@@ -0,0 +1,2 @@
+import{validateFieldsNatively as r,toNestError as e}from"@hookform/resolvers";const o=(r,e={},s="")=>(r.errors||[]).reduce((r,e)=>{const t=String(e.path[0]),a=s?`${s}.${t}`:t;return r[a]={type:e.error.name,message:e.error.message},o(e.error,r,a),r},e),s=s=>async(t,a,n)=>{try{const e=await s(t);return n.shouldUseNativeValidation&&r({},n),{errors:{},values:e}}catch(r){return{values:{},errors:e(o(r),n)}}};export{s as computedTypesResolver};
+//# sourceMappingURL=computed-types.modern.js.map

package/computed-types/dist/computed-types.modern.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"computed-types.modern.js","sources":["../src/computed-types.ts"],"sourcesContent":["import type { FieldErrors } from 'react-hook-form';\nimport { toNestError, validateFieldsNatively } from '@hookform/resolvers';\nimport type { ValidationError } from 'computed-types';\nimport type { Resolver } from './types';\n\nconst parseErrorSchema = (\n  computedTypesError: ValidationError,\n  parsedErrors: FieldErrors = {},\n  path = '',\n) => {\n  return (computedTypesError.errors || []).reduce((acc, error) => {\n    const _currentPath = String(error.path[0]);\n    const _path = path ? `${path}.${_currentPath}` : _currentPath;\n\n    acc[_path] = {\n      type: error.error.name,\n      message: error.error.message,\n    };\n\n    parseErrorSchema(error.error, acc, _path);\n\n    return acc;\n  }, parsedErrors);\n};\n\nexport const computedTypesResolver: Resolver =\n  (schema) => async (values, _, options) => {\n    try {\n      const data = await schema(values);\n\n      options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n      return {\n        errors: {},\n        values: data,\n      };\n    } catch (error) {\n      return {\n        values: {},\n        errors: toNestError(parseErrorSchema(error), options),\n      };\n    }\n  };\n"],"names":["parseErrorSchema","computedTypesError","parsedErrors","path","errors","reduce","acc","error","_currentPath","String","_path","type","name","message","computedTypesResolver","schema","async","values","_","options","data","shouldUseNativeValidation","validateFieldsNatively","toNestError"],"mappings":"8EAKA,MAAMA,EAAmB,CACvBC,EACAC,EAA4B,GAC5BC,EAAO,MAECF,EAAmBG,QAAU,IAAIC,OAAO,CAACC,EAAKC,KACpD,MAAMC,EAAeC,OAAOF,EAAMJ,KAAK,IACjCO,EAAQP,KAAUA,KAAQK,IAAiBA,EASjD,OAPAF,EAAII,GAAS,CACXC,KAAMJ,EAAMA,MAAMK,KAClBC,QAASN,EAAMA,MAAMM,SAGvBb,EAAiBO,EAAMA,MAAOD,EAAKI,GAE5BJ,GACNJ,GAGQY,EACVC,GAAWC,MAAOC,EAAQC,EAAGC,KAC5B,IACE,MAAMC,QAAaL,EAAOE,GAI1B,OAFAE,EAAQE,2BAA6BC,EAAuB,GAAIH,GAEzD,CACLf,OAAQ,GACRa,OAAQG,GAEV,MAAOb,GACP,MAAO,CACLU,OAAQ,GACRb,OAAQmB,EAAYvB,EAAiBO,GAAQY"}

package/computed-types/dist/computed-types.module.js

@@ -0,0 +1,2 @@
+import{validateFieldsNatively as r,toNestError as e}from"@hookform/resolvers";var t=function r(e,t,o){return void 0===t&&(t={}),void 0===o&&(o=""),(e.errors||[]).reduce(function(e,t){var n=String(t.path[0]),u=o?o+"."+n:n;return e[u]={type:t.error.name,message:t.error.message},r(t.error,e,u),e},t)},o=function(o){return function(n,u,i){try{return Promise.resolve(function(e,t){try{var u=Promise.resolve(o(n)).then(function(e){return i.shouldUseNativeValidation&&r({},i),{errors:{},values:e}})}catch(r){return t(r)}return u&&u.then?u.then(void 0,t):u}(0,function(r){return{values:{},errors:e(t(r),i)}}))}catch(r){return Promise.reject(r)}}};export{o as computedTypesResolver};
+//# sourceMappingURL=computed-types.module.js.map

package/computed-types/dist/computed-types.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"computed-types.module.js","sources":["../src/computed-types.ts"],"sourcesContent":["import type { FieldErrors } from 'react-hook-form';\nimport { toNestError, validateFieldsNatively } from '@hookform/resolvers';\nimport type { ValidationError } from 'computed-types';\nimport type { Resolver } from './types';\n\nconst parseErrorSchema = (\n  computedTypesError: ValidationError,\n  parsedErrors: FieldErrors = {},\n  path = '',\n) => {\n  return (computedTypesError.errors || []).reduce((acc, error) => {\n    const _currentPath = String(error.path[0]);\n    const _path = path ? `${path}.${_currentPath}` : _currentPath;\n\n    acc[_path] = {\n      type: error.error.name,\n      message: error.error.message,\n    };\n\n    parseErrorSchema(error.error, acc, _path);\n\n    return acc;\n  }, parsedErrors);\n};\n\nexport const computedTypesResolver: Resolver =\n  (schema) => async (values, _, options) => {\n    try {\n      const data = await schema(values);\n\n      options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n      return {\n        errors: {},\n        values: data,\n      };\n    } catch (error) {\n      return {\n        values: {},\n        errors: toNestError(parseErrorSchema(error), options),\n      };\n    }\n  };\n"],"names":["parseErrorSchema","computedTypesError","parsedErrors","path","errors","reduce","acc","error","_currentPath","String","_path","type","name","message","computedTypesResolver","schema","values","_","options","data","shouldUseNativeValidation","validateFieldsNatively","toNestError"],"mappings":"8EAKA,IAAMA,EAAmB,SAAnBA,EACJC,EACAC,EACAC,GAEA,gBAHAD,IAAAA,EAA4B,aAC5BC,IAAAA,EAAO,KAECF,EAAmBG,QAAU,IAAIC,OAAO,SAACC,EAAKC,GACpD,IAAMC,EAAeC,OAAOF,EAAMJ,KAAK,IACjCO,EAAQP,EAAUA,MAAQK,EAAiBA,EASjD,OAPAF,EAAII,GAAS,CACXC,KAAMJ,EAAMA,MAAMK,KAClBC,QAASN,EAAMA,MAAMM,SAGvBb,EAAiBO,EAAMA,MAAOD,EAAKI,GAE5BJ,GACNJ,IAGQY,EACX,SAACC,mBAAkBC,EAAQC,EAAGC,sEAEPH,EAAOC,kBAApBG,GAIN,OAFAD,EAAQE,2BAA6BC,EAAuB,GAAIH,GAEzD,CACLd,OAAQ,GACRY,OAAQG,0EAEHZ,GACP,MAAO,CACLS,OAAQ,GACRZ,OAAQkB,EAAYtB,EAAiBO,GAAQW,OAbnD"}

package/computed-types/dist/computed-types.umd.js

@@ -0,0 +1,2 @@
+!function(e,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports,require("@hookform/resolvers")):"function"==typeof define&&define.amd?define(["exports","@hookform/resolvers"],r):r((e||self).hookformResolversComputedTypes={},e.hookformResolvers)}(this,function(e,r){var o=function e(r,o,t){return void 0===o&&(o={}),void 0===t&&(t=""),(r.errors||[]).reduce(function(r,o){var n=String(o.path[0]),s=t?t+"."+n:n;return r[s]={type:o.error.name,message:o.error.message},e(o.error,r,s),r},o)};e.computedTypesResolver=function(e){return function(t,n,s){try{return Promise.resolve(function(o,n){try{var i=Promise.resolve(e(t)).then(function(e){return s.shouldUseNativeValidation&&r.validateFieldsNatively({},s),{errors:{},values:e}})}catch(e){return n(e)}return i&&i.then?i.then(void 0,n):i}(0,function(e){return{values:{},errors:r.toNestError(o(e),s)}}))}catch(e){return Promise.reject(e)}}}});
+//# sourceMappingURL=computed-types.umd.js.map

package/computed-types/dist/computed-types.umd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"computed-types.umd.js","sources":["../src/computed-types.ts"],"sourcesContent":["import type { FieldErrors } from 'react-hook-form';\nimport { toNestError, validateFieldsNatively } from '@hookform/resolvers';\nimport type { ValidationError } from 'computed-types';\nimport type { Resolver } from './types';\n\nconst parseErrorSchema = (\n  computedTypesError: ValidationError,\n  parsedErrors: FieldErrors = {},\n  path = '',\n) => {\n  return (computedTypesError.errors || []).reduce((acc, error) => {\n    const _currentPath = String(error.path[0]);\n    const _path = path ? `${path}.${_currentPath}` : _currentPath;\n\n    acc[_path] = {\n      type: error.error.name,\n      message: error.error.message,\n    };\n\n    parseErrorSchema(error.error, acc, _path);\n\n    return acc;\n  }, parsedErrors);\n};\n\nexport const computedTypesResolver: Resolver =\n  (schema) => async (values, _, options) => {\n    try {\n      const data = await schema(values);\n\n      options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n      return {\n        errors: {},\n        values: data,\n      };\n    } catch (error) {\n      return {\n        values: {},\n        errors: toNestError(parseErrorSchema(error), options),\n      };\n    }\n  };\n"],"names":["parseErrorSchema","computedTypesError","parsedErrors","path","errors","reduce","acc","error","_currentPath","String","_path","type","name","message","schema","values","_","options","data","shouldUseNativeValidation","validateFieldsNatively","toNestError"],"mappings":"mUAKA,IAAMA,EAAmB,SAAnBA,EACJC,EACAC,EACAC,GAEA,gBAHAD,IAAAA,EAA4B,aAC5BC,IAAAA,EAAO,KAECF,EAAmBG,QAAU,IAAIC,OAAO,SAACC,EAAKC,GACpD,IAAMC,EAAeC,OAAOF,EAAMJ,KAAK,IACjCO,EAAQP,EAAUA,MAAQK,EAAiBA,EASjD,OAPAF,EAAII,GAAS,CACXC,KAAMJ,EAAMA,MAAMK,KAClBC,QAASN,EAAMA,MAAMM,SAGvBb,EAAiBO,EAAMA,MAAOD,EAAKI,GAE5BJ,GACNJ,4BAIH,SAACY,mBAAkBC,EAAQC,EAAGC,sEAEPH,EAAOC,kBAApBG,GAIN,OAFAD,EAAQE,2BAA6BC,yBAAuB,GAAIH,GAEzD,CACLb,OAAQ,GACRW,OAAQG,0EAEHX,GACP,MAAO,CACLQ,OAAQ,GACRX,OAAQiB,cAAYrB,EAAiBO,GAAQU,OAbnD"}

package/computed-types/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './computed-types';
+export * from './types';

package/computed-types/dist/types.d.ts

@@ -0,0 +1,2 @@
+import type { FieldValues, ResolverResult, UnpackNestedValue, ResolverOptions } from 'react-hook-form';
+export declare type Resolver = (schema: any) => <TFieldValues extends FieldValues, TContext>(values: UnpackNestedValue<TFieldValues>, context: TContext | undefined, options: ResolverOptions<TFieldValues>) => Promise<ResolverResult<TFieldValues>>;

package/computed-types/package.json

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