@hookform/resolvers 2.8.1

package/joi/src/joi.ts

@@ -0,0 +1,81 @@
+import { appendErrors, FieldError } from 'react-hook-form';
+import { toNestError, validateFieldsNatively } from '@hookform/resolvers';
+import type { ValidationError } from 'joi';
+import { Resolver } from './types';
+
+const parseErrorSchema = (
+  error: ValidationError,
+  validateAllFieldCriteria: boolean,
+) =>
+  error.details.length
+    ? error.details.reduce<Record<string, FieldError>>((previous, error) => {
+        const _path = error.path.join('.');
+
+        if (!previous[_path]) {
+          previous[_path] = { message: error.message, type: error.type };
+        }
+
+        if (validateAllFieldCriteria) {
+          const types = previous[_path].types;
+          const messages = types && types[error.type!];
+
+          previous[_path] = appendErrors(
+            _path,
+            validateAllFieldCriteria,
+            previous,
+            error.type,
+            messages
+              ? ([] as string[]).concat(messages as string[], error.message)
+              : error.message,
+          ) as FieldError;
+        }
+
+        return previous;
+      }, {})
+    : {};
+
+export const joiResolver: Resolver =
+  (
+    schema,
+    schemaOptions = {
+      abortEarly: false,
+    },
+    resolverOptions = {},
+  ) =>
+  async (values, context, options) => {
+    const _schemaOptions = Object.assign({}, schemaOptions, {
+      context,
+    });
+
+    let result: Record<string, any> = {};
+    if (resolverOptions.mode === 'sync') {
+      result = schema.validate(values, _schemaOptions);
+    } else {
+      try {
+        result.value = await schema.validateAsync(values, _schemaOptions);
+      } catch (e) {
+        result.error = e;
+      }
+    }
+
+    if (result.error) {
+      return {
+        values: {},
+        errors: toNestError(
+          parseErrorSchema(
+            result.error,
+            !options.shouldUseNativeValidation &&
+              options.criteriaMode === 'all',
+          ),
+          options,
+        ),
+      };
+    }
+
+    options.shouldUseNativeValidation && validateFieldsNatively({}, options);
+
+    return {
+      errors: {},
+      values: result.value,
+    };
+  };

package/joi/src/types.ts

@@ -0,0 +1,16 @@
+import {
+  ResolverOptions,
+  ResolverResult,
+  UnpackNestedValue,
+} from 'react-hook-form';
+import type { AsyncValidationOptions, Schema } from 'joi';
+
+export type Resolver = <T extends Schema, TFieldValues, TContext>(
+  schema: T,
+  schemaOptions?: AsyncValidationOptions,
+  factoryOptions?: { mode?: 'async' | 'sync' },
+) => (
+  values: UnpackNestedValue<TFieldValues>,
+  context: TContext | undefined,
+  options: ResolverOptions<TFieldValues>,
+) => Promise<ResolverResult<TFieldValues>>;

package/nope/dist/index.d.ts

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

package/nope/dist/nope.d.ts

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

package/nope/dist/nope.js

@@ -0,0 +1,2 @@
+var r=require("@hookform/resolvers"),e=function r(e,o,t){return void 0===o&&(o={}),void 0===t&&(t=""),Object.keys(e).reduce(function(o,a){var i=t?t+"."+a:a,s=e[a];return"string"==typeof s?o[i]={message:s}:r(s,o,i),o},o)};exports.nopeResolver=function(o,t){return void 0===t&&(t={abortEarly:!1}),function(a,i,s){var n=o.validate(a,i,t);return n?{values:{},errors:r.toNestError(e(n),s)}:(s.shouldUseNativeValidation&&r.validateFieldsNatively({},s),{values:a,errors:{}})}};
+//# sourceMappingURL=nope.js.map

package/nope/dist/nope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nope.js","sources":["../src/nope.ts"],"sourcesContent":["import type { FieldErrors } from 'react-hook-form';\nimport { toNestError, validateFieldsNatively } from '@hookform/resolvers';\nimport type { ShapeErrors } from 'nope-validator/lib/cjs/types';\nimport type { Resolver } from './types';\n\nconst parseErrors = (\n  errors: ShapeErrors,\n  parsedErrors: FieldErrors = {},\n  path = '',\n) => {\n  return Object.keys(errors).reduce((acc, key) => {\n    const _path = path ? `${path}.${key}` : key;\n    const error = errors[key];\n\n    if (typeof error === 'string') {\n      acc[_path] = {\n        message: error,\n      };\n    } else {\n      parseErrors(error, acc, _path);\n    }\n\n    return acc;\n  }, parsedErrors);\n};\n\nexport const nopeResolver: Resolver =\n  (\n    schema,\n    schemaOptions = {\n      abortEarly: false,\n    },\n  ) =>\n  (values, context, options) => {\n    const result = schema.validate(values, context, schemaOptions) as\n      | ShapeErrors\n      | undefined;\n\n    if (result) {\n      return { values: {}, errors: toNestError(parseErrors(result), options) };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return { values, errors: {} };\n  };\n"],"names":["parseErrors","errors","parsedErrors","path","Object","keys","reduce","acc","key","_path","error","message","schema","schemaOptions","abortEarly","values","context","options","result","validate","toNestError","shouldUseNativeValidation","validateFieldsNatively"],"mappings":"qCAKMA,EAAc,SAAdA,EACJC,EACAC,EACAC,GAEA,gBAHAD,IAAAA,EAA4B,aAC5BC,IAAAA,EAAO,IAEAC,OAAOC,KAAKJ,GAAQK,OAAO,SAACC,EAAKC,GACtC,IAAMC,EAAQN,EAAUA,MAAQK,EAAQA,EAClCE,EAAQT,EAAOO,GAUrB,MARqB,iBAAVE,EACTH,EAAIE,GAAS,CACXE,QAASD,GAGXV,EAAYU,EAAOH,EAAKE,GAGnBF,GACNL,yBAIH,SACEU,EACAC,mBAAAA,IAAAA,EAAgB,CACdC,YAAY,aAGfC,EAAQC,EAASC,GAChB,IAAMC,EAASN,EAAOO,SAASJ,EAAQC,EAASH,GAIhD,OAAIK,EACK,CAAEH,OAAQ,GAAId,OAAQmB,cAAYpB,EAAYkB,GAASD,KAGhEA,EAAQI,2BAA6BC,yBAAuB,GAAIL,GAEzD,CAAEF,OAAAA,EAAQd,OAAQ"}

package/nope/dist/nope.mjs

@@ -0,0 +1,2 @@
+import{toNestError as r,validateFieldsNatively as e}from"@hookform/resolvers";var o=function r(e,o,t){return void 0===o&&(o={}),void 0===t&&(t=""),Object.keys(e).reduce(function(o,n){var a=t?t+"."+n:n,i=e[n];return"string"==typeof i?o[a]={message:i}:r(i,o,a),o},o)},t=function(t,n){return void 0===n&&(n={abortEarly:!1}),function(a,i,s){var u=t.validate(a,i,n);return u?{values:{},errors:r(o(u),s)}:(s.shouldUseNativeValidation&&e({},s),{values:a,errors:{}})}};export{t as nopeResolver};
+//# sourceMappingURL=nope.module.js.map

package/nope/dist/nope.modern.js

@@ -0,0 +1,2 @@
+import{toNestError as r,validateFieldsNatively as e}from"@hookform/resolvers";const o=(r,e={},s="")=>Object.keys(r).reduce((e,t)=>{const a=s?`${s}.${t}`:t,l=r[t];return"string"==typeof l?e[a]={message:l}:o(l,e,a),e},e),s=(s,t={abortEarly:!1})=>(a,l,n)=>{const i=s.validate(a,l,t);return i?{values:{},errors:r(o(i),n)}:(n.shouldUseNativeValidation&&e({},n),{values:a,errors:{}})};export{s as nopeResolver};
+//# sourceMappingURL=nope.modern.js.map

package/nope/dist/nope.modern.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nope.modern.js","sources":["../src/nope.ts"],"sourcesContent":["import type { FieldErrors } from 'react-hook-form';\nimport { toNestError, validateFieldsNatively } from '@hookform/resolvers';\nimport type { ShapeErrors } from 'nope-validator/lib/cjs/types';\nimport type { Resolver } from './types';\n\nconst parseErrors = (\n  errors: ShapeErrors,\n  parsedErrors: FieldErrors = {},\n  path = '',\n) => {\n  return Object.keys(errors).reduce((acc, key) => {\n    const _path = path ? `${path}.${key}` : key;\n    const error = errors[key];\n\n    if (typeof error === 'string') {\n      acc[_path] = {\n        message: error,\n      };\n    } else {\n      parseErrors(error, acc, _path);\n    }\n\n    return acc;\n  }, parsedErrors);\n};\n\nexport const nopeResolver: Resolver =\n  (\n    schema,\n    schemaOptions = {\n      abortEarly: false,\n    },\n  ) =>\n  (values, context, options) => {\n    const result = schema.validate(values, context, schemaOptions) as\n      | ShapeErrors\n      | undefined;\n\n    if (result) {\n      return { values: {}, errors: toNestError(parseErrors(result), options) };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return { values, errors: {} };\n  };\n"],"names":["parseErrors","errors","parsedErrors","path","Object","keys","reduce","acc","key","_path","error","message","nopeResolver","schema","schemaOptions","abortEarly","values","context","options","result","validate","toNestError","shouldUseNativeValidation","validateFieldsNatively"],"mappings":"8EAKA,MAAMA,EAAc,CAClBC,EACAC,EAA4B,GAC5BC,EAAO,KAEAC,OAAOC,KAAKJ,GAAQK,OAAO,CAACC,EAAKC,KACtC,MAAMC,EAAQN,KAAUA,KAAQK,IAAQA,EAClCE,EAAQT,EAAOO,GAUrB,MARqB,iBAAVE,EACTH,EAAIE,GAAS,CACXE,QAASD,GAGXV,EAAYU,EAAOH,EAAKE,GAGnBF,GACNL,GAGQU,EACX,CACEC,EACAC,EAAgB,CACdC,YAAY,KAGhB,CAACC,EAAQC,EAASC,KAChB,MAAMC,EAASN,EAAOO,SAASJ,EAAQC,EAASH,GAIhD,OAAIK,EACK,CAAEH,OAAQ,GAAIf,OAAQoB,EAAYrB,EAAYmB,GAASD,KAGhEA,EAAQI,2BAA6BC,EAAuB,GAAIL,GAEzD,CAAEF,OAAAA,EAAQf,OAAQ"}

package/nope/dist/nope.module.js

@@ -0,0 +1,2 @@
+import{toNestError as r,validateFieldsNatively as e}from"@hookform/resolvers";var o=function r(e,o,t){return void 0===o&&(o={}),void 0===t&&(t=""),Object.keys(e).reduce(function(o,n){var a=t?t+"."+n:n,i=e[n];return"string"==typeof i?o[a]={message:i}:r(i,o,a),o},o)},t=function(t,n){return void 0===n&&(n={abortEarly:!1}),function(a,i,s){var u=t.validate(a,i,n);return u?{values:{},errors:r(o(u),s)}:(s.shouldUseNativeValidation&&e({},s),{values:a,errors:{}})}};export{t as nopeResolver};
+//# sourceMappingURL=nope.module.js.map

package/nope/dist/nope.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nope.module.js","sources":["../src/nope.ts"],"sourcesContent":["import type { FieldErrors } from 'react-hook-form';\nimport { toNestError, validateFieldsNatively } from '@hookform/resolvers';\nimport type { ShapeErrors } from 'nope-validator/lib/cjs/types';\nimport type { Resolver } from './types';\n\nconst parseErrors = (\n  errors: ShapeErrors,\n  parsedErrors: FieldErrors = {},\n  path = '',\n) => {\n  return Object.keys(errors).reduce((acc, key) => {\n    const _path = path ? `${path}.${key}` : key;\n    const error = errors[key];\n\n    if (typeof error === 'string') {\n      acc[_path] = {\n        message: error,\n      };\n    } else {\n      parseErrors(error, acc, _path);\n    }\n\n    return acc;\n  }, parsedErrors);\n};\n\nexport const nopeResolver: Resolver =\n  (\n    schema,\n    schemaOptions = {\n      abortEarly: false,\n    },\n  ) =>\n  (values, context, options) => {\n    const result = schema.validate(values, context, schemaOptions) as\n      | ShapeErrors\n      | undefined;\n\n    if (result) {\n      return { values: {}, errors: toNestError(parseErrors(result), options) };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return { values, errors: {} };\n  };\n"],"names":["parseErrors","errors","parsedErrors","path","Object","keys","reduce","acc","key","_path","error","message","nopeResolver","schema","schemaOptions","abortEarly","values","context","options","result","validate","toNestError","shouldUseNativeValidation","validateFieldsNatively"],"mappings":"8EAKA,IAAMA,EAAc,SAAdA,EACJC,EACAC,EACAC,GAEA,gBAHAD,IAAAA,EAA4B,aAC5BC,IAAAA,EAAO,IAEAC,OAAOC,KAAKJ,GAAQK,OAAO,SAACC,EAAKC,GACtC,IAAMC,EAAQN,EAAUA,MAAQK,EAAQA,EAClCE,EAAQT,EAAOO,GAUrB,MARqB,iBAAVE,EACTH,EAAIE,GAAS,CACXE,QAASD,GAGXV,EAAYU,EAAOH,EAAKE,GAGnBF,GACNL,IAGQU,EACX,SACEC,EACAC,mBAAAA,IAAAA,EAAgB,CACdC,YAAY,aAGfC,EAAQC,EAASC,GAChB,IAAMC,EAASN,EAAOO,SAASJ,EAAQC,EAASH,GAIhD,OAAIK,EACK,CAAEH,OAAQ,GAAIf,OAAQoB,EAAYrB,EAAYmB,GAASD,KAGhEA,EAAQI,2BAA6BC,EAAuB,GAAIL,GAEzD,CAAEF,OAAAA,EAAQf,OAAQ"}

package/nope/dist/nope.umd.js

@@ -0,0 +1,2 @@
+!function(e,o){"object"==typeof exports&&"undefined"!=typeof module?o(exports,require("@hookform/resolvers")):"function"==typeof define&&define.amd?define(["exports","@hookform/resolvers"],o):o((e||self).hookformResolversNope={},e.hookformResolvers)}(this,function(e,o){var r=function e(o,r,t){return void 0===r&&(r={}),void 0===t&&(t=""),Object.keys(o).reduce(function(r,n){var s=t?t+"."+n:n,i=o[n];return"string"==typeof i?r[s]={message:i}:e(i,r,s),r},r)};e.nopeResolver=function(e,t){return void 0===t&&(t={abortEarly:!1}),function(n,s,i){var f=e.validate(n,s,t);return f?{values:{},errors:o.toNestError(r(f),i)}:(i.shouldUseNativeValidation&&o.validateFieldsNatively({},i),{values:n,errors:{}})}}});
+//# sourceMappingURL=nope.umd.js.map

package/nope/dist/nope.umd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nope.umd.js","sources":["../src/nope.ts"],"sourcesContent":["import type { FieldErrors } from 'react-hook-form';\nimport { toNestError, validateFieldsNatively } from '@hookform/resolvers';\nimport type { ShapeErrors } from 'nope-validator/lib/cjs/types';\nimport type { Resolver } from './types';\n\nconst parseErrors = (\n  errors: ShapeErrors,\n  parsedErrors: FieldErrors = {},\n  path = '',\n) => {\n  return Object.keys(errors).reduce((acc, key) => {\n    const _path = path ? `${path}.${key}` : key;\n    const error = errors[key];\n\n    if (typeof error === 'string') {\n      acc[_path] = {\n        message: error,\n      };\n    } else {\n      parseErrors(error, acc, _path);\n    }\n\n    return acc;\n  }, parsedErrors);\n};\n\nexport const nopeResolver: Resolver =\n  (\n    schema,\n    schemaOptions = {\n      abortEarly: false,\n    },\n  ) =>\n  (values, context, options) => {\n    const result = schema.validate(values, context, schemaOptions) as\n      | ShapeErrors\n      | undefined;\n\n    if (result) {\n      return { values: {}, errors: toNestError(parseErrors(result), options) };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return { values, errors: {} };\n  };\n"],"names":["parseErrors","errors","parsedErrors","path","Object","keys","reduce","acc","key","_path","error","message","schema","schemaOptions","abortEarly","values","context","options","result","validate","toNestError","shouldUseNativeValidation","validateFieldsNatively"],"mappings":"0TAKA,IAAMA,EAAc,SAAdA,EACJC,EACAC,EACAC,GAEA,gBAHAD,IAAAA,EAA4B,aAC5BC,IAAAA,EAAO,IAEAC,OAAOC,KAAKJ,GAAQK,OAAO,SAACC,EAAKC,GACtC,IAAMC,EAAQN,EAAUA,MAAQK,EAAQA,EAClCE,EAAQT,EAAOO,GAUrB,MARqB,iBAAVE,EACTH,EAAIE,GAAS,CACXE,QAASD,GAGXV,EAAYU,EAAOH,EAAKE,GAGnBF,GACNL,mBAIH,SACEU,EACAC,mBAAAA,IAAAA,EAAgB,CACdC,YAAY,aAGfC,EAAQC,EAASC,GAChB,IAAMC,EAASN,EAAOO,SAASJ,EAAQC,EAASH,GAIhD,OAAIK,EACK,CAAEH,OAAQ,GAAId,OAAQmB,cAAYpB,EAAYkB,GAASD,KAGhEA,EAAQI,2BAA6BC,yBAAuB,GAAIL,GAEzD,CAAEF,OAAAA,EAAQd,OAAQ"}

package/nope/dist/types.d.ts

@@ -0,0 +1,6 @@
+import type { ResolverOptions, ResolverResult, UnpackNestedValue } from 'react-hook-form';
+import type { NopeObject } from 'nope-validator/lib/cjs/NopeObject';
+declare type ValidateOptions = Parameters<NopeObject['validate']>[2];
+declare type Context = Parameters<NopeObject['validate']>[1];
+export declare type Resolver = <T extends NopeObject, TFieldValues, TContext extends Context>(schema: T, schemaOptions?: ValidateOptions) => (values: UnpackNestedValue<TFieldValues>, context: TContext | undefined, options: ResolverOptions<TFieldValues>) => ResolverResult<TFieldValues>;
+export {};

package/nope/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "nope",
+  "amdName": "hookformResolversNope",
+  "version": "1.0.0",
+  "private": true,
+  "description": "React Hook Form validation resolver: nope",
+  "main": "dist/nope.js",
+  "module": "dist/nope.module.js",
+  "umd:main": "dist/nope.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",
+    "nope-validator": "^0.12.0"
+  }
+}

package/nope/src/__tests__/Form-native-validation.tsx

@@ -0,0 +1,89 @@
+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 Nope from 'nope-validator';
+import { nopeResolver } from '..';
+
+const USERNAME_REQUIRED_MESSAGE = 'username field is required';
+const PASSWORD_REQUIRED_MESSAGE = 'password field is required';
+
+const schema = Nope.object().shape({
+  username: Nope.string().required(USERNAME_REQUIRED_MESSAGE),
+  password: Nope.string().required(PASSWORD_REQUIRED_MESSAGE),
+});
+
+interface FormData {
+  unusedProperty: string;
+  username: string;
+  password: string;
+}
+
+interface Props {
+  onSubmit: (data: FormData) => void;
+}
+
+function TestComponent({ onSubmit }: Props) {
+  const { register, handleSubmit } = useForm<FormData>({
+    resolver: nopeResolver(schema),
+    shouldUseNativeValidation: true,
+  });
+
+  return (
+    <form onSubmit={handleSubmit(onSubmit)}>
+      <input {...register('username')} placeholder="username" />
+
+      <input {...register('password')} placeholder="password" />
+
+      <button type="submit">submit</button>
+    </form>
+  );
+}
+
+test("form's native validation with Nope", async () => {
+  const handleSubmit = jest.fn();
+  render(<TestComponent onSubmit={handleSubmit} />);
+
+  // username
+  let usernameField = screen.getByPlaceholderText(
+    /username/i,
+  ) as HTMLInputElement;
+  expect(usernameField.validity.valid).toBe(true);
+  expect(usernameField.validationMessage).toBe('');
+
+  // password
+  let passwordField = screen.getByPlaceholderText(
+    /password/i,
+  ) as HTMLInputElement;
+  expect(passwordField.validity.valid).toBe(true);
+  expect(passwordField.validationMessage).toBe('');
+
+  await act(async () => {
+    user.click(screen.getByText(/submit/i));
+  });
+
+  // username
+  usernameField = screen.getByPlaceholderText(/username/i) as HTMLInputElement;
+  expect(usernameField.validity.valid).toBe(false);
+  expect(usernameField.validationMessage).toBe(USERNAME_REQUIRED_MESSAGE);
+
+  // password
+  passwordField = screen.getByPlaceholderText(/password/i) as HTMLInputElement;
+  expect(passwordField.validity.valid).toBe(false);
+  expect(passwordField.validationMessage).toBe(PASSWORD_REQUIRED_MESSAGE);
+
+  await act(async () => {
+    user.type(screen.getByPlaceholderText(/username/i), 'joe');
+    user.type(screen.getByPlaceholderText(/password/i), 'password');
+  });
+
+  // username
+  usernameField = screen.getByPlaceholderText(/username/i) as HTMLInputElement;
+  expect(usernameField.validity.valid).toBe(true);
+  expect(usernameField.validationMessage).toBe('');
+
+  // password
+  passwordField = screen.getByPlaceholderText(/password/i) as HTMLInputElement;
+  expect(passwordField.validity.valid).toBe(true);
+  expect(passwordField.validationMessage).toBe('');
+});

package/nope/src/__tests__/Form.tsx

@@ -0,0 +1,57 @@
+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 Nope from 'nope-validator';
+import { nopeResolver } from '..';
+
+const schema = Nope.object().shape({
+  username: Nope.string().required(),
+  password: Nope.string().required(),
+});
+
+interface FormData {
+  unusedProperty: string;
+  username: string;
+  password: string;
+}
+
+interface Props {
+  onSubmit: (data: FormData) => void;
+}
+
+function TestComponent({ onSubmit }: Props) {
+  const {
+    register,
+    formState: { errors },
+    handleSubmit,
+  } = useForm<FormData>({
+    resolver: nopeResolver(schema), // Useful to check TypeScript regressions
+  });
+
+  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 Yup 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.getAllByText(/This field is required/i)).toHaveLength(2);
+  expect(handleSubmit).not.toHaveBeenCalled();
+});

package/nope/src/__tests__/__fixtures__/data.ts

@@ -0,0 +1,70 @@
+import { Field, InternalFieldName } from 'react-hook-form';
+import Nope from 'nope-validator';
+
+export const schema = Nope.object().shape({
+  username: Nope.string().regex(/^\w+$/).min(2).max(30).required(),
+  password: Nope.string()
+    .regex(new RegExp('.*[A-Z].*'), 'One uppercase character')
+    .regex(new RegExp('.*[a-z].*'), 'One lowercase character')
+    .regex(new RegExp('.*\\d.*'), 'One number')
+    .regex(
+      new RegExp('.*[`~<>?,./!@#$%^&*()\\-_+="\'|{}\\[\\];:\\\\].*'),
+      'One special character',
+    )
+    .min(8, 'Must be at least 8 characters in length')
+    .required('New Password is required'),
+  repeatPassword: Nope.string()
+    .oneOf([Nope.ref('password')], "Passwords don't match")
+    .required(),
+  accessToken: Nope.string(),
+  birthYear: Nope.number().min(1900).max(2013),
+  email: Nope.string().email(),
+  tags: Nope.array().of(Nope.string()).required(),
+  enabled: Nope.boolean(),
+  like: Nope.object().shape({
+    id: Nope.number().required(),
+    name: Nope.string().atLeast(4).required(),
+  }),
+});
+
+export const validData = {
+  username: 'Doe',
+  password: 'Password123_',
+  repeatPassword: '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' },
+  tags: [1, 2, 3],
+};
+
+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/nope/src/__tests__/__snapshots__/nope.ts.snap

@@ -0,0 +1,43 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`nopeResolver should return a single error from nopeResolver when validation fails 1`] = `
+Object {
+  "errors": Object {
+    "birthYear": Object {
+      "message": "The field is not a valid number",
+      "ref": undefined,
+    },
+    "like": Object {
+      "id": Object {
+        "message": "The field is not a valid number",
+        "ref": undefined,
+      },
+      "name": Object {
+        "message": "This field is required",
+        "ref": undefined,
+      },
+    },
+    "password": Object {
+      "message": "One uppercase character",
+      "ref": Object {
+        "name": "password",
+      },
+    },
+    "repeatPassword": Object {
+      "message": "This field is required",
+      "ref": undefined,
+    },
+    "tags": Object {
+      "message": "One or more elements are of invalid type",
+      "ref": undefined,
+    },
+    "username": Object {
+      "message": "This field is required",
+      "ref": Object {
+        "name": "username",
+      },
+    },
+  },
+  "values": Object {},
+}
+`;

package/nope/src/__tests__/nope.ts

@@ -0,0 +1,28 @@
+/* eslint-disable no-console, @typescript-eslint/ban-ts-comment */
+import { nopeResolver } from '..';
+import { schema, validData, fields, invalidData } from './__fixtures__/data';
+
+const shouldUseNativeValidation = false;
+
+describe('nopeResolver', () => {
+  it('should return values from nopeResolver when validation pass', async () => {
+    const schemaSpy = jest.spyOn(schema, 'validate');
+
+    const result = await nopeResolver(schema)(validData, undefined, {
+      fields,
+      shouldUseNativeValidation,
+    });
+
+    expect(schemaSpy).toHaveBeenCalledTimes(1);
+    expect(result).toEqual({ errors: {}, values: validData });
+  });
+
+  it('should return a single error from nopeResolver when validation fails', async () => {
+    const result = await nopeResolver(schema)(invalidData, undefined, {
+      fields,
+      shouldUseNativeValidation,
+    });
+
+    expect(result).toMatchSnapshot();
+  });
+});

package/nope/src/index.ts

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

package/nope/src/nope.ts

@@ -0,0 +1,46 @@
+import type { FieldErrors } from 'react-hook-form';
+import { toNestError, validateFieldsNatively } from '@hookform/resolvers';
+import type { ShapeErrors } from 'nope-validator/lib/cjs/types';
+import type { Resolver } from './types';
+
+const parseErrors = (
+  errors: ShapeErrors,
+  parsedErrors: FieldErrors = {},
+  path = '',
+) => {
+  return Object.keys(errors).reduce((acc, key) => {
+    const _path = path ? `${path}.${key}` : key;
+    const error = errors[key];
+
+    if (typeof error === 'string') {
+      acc[_path] = {
+        message: error,
+      };
+    } else {
+      parseErrors(error, acc, _path);
+    }
+
+    return acc;
+  }, parsedErrors);
+};
+
+export const nopeResolver: Resolver =
+  (
+    schema,
+    schemaOptions = {
+      abortEarly: false,
+    },
+  ) =>
+  (values, context, options) => {
+    const result = schema.validate(values, context, schemaOptions) as
+      | ShapeErrors
+      | undefined;
+
+    if (result) {
+      return { values: {}, errors: toNestError(parseErrors(result), options) };
+    }
+
+    options.shouldUseNativeValidation && validateFieldsNatively({}, options);
+
+    return { values, errors: {} };
+  };

package/nope/src/types.ts

@@ -0,0 +1,22 @@
+import type {
+  ResolverOptions,
+  ResolverResult,
+  UnpackNestedValue,
+} from 'react-hook-form';
+import type { NopeObject } from 'nope-validator/lib/cjs/NopeObject';
+
+type ValidateOptions = Parameters<NopeObject['validate']>[2];
+type Context = Parameters<NopeObject['validate']>[1];
+
+export type Resolver = <
+  T extends NopeObject,
+  TFieldValues,
+  TContext extends Context,
+>(
+  schema: T,
+  schemaOptions?: ValidateOptions,
+) => (
+  values: UnpackNestedValue<TFieldValues>,
+  context: TContext | undefined,
+  options: ResolverOptions<TFieldValues>,
+) => ResolverResult<TFieldValues>;