@hookform/resolvers 3.4.1 → 3.5.0

package/arktype/dist/types.d.ts

@@ -1,6 +1,6 @@
 import { FieldValues, ResolverResult, ResolverOptions } from 'react-hook-form';
 import { Type } from 'arktype';
-export type Resolver = <T extends Type<any>>(schema: T, schemaOptions?: never, factoryOptions?: {
+export type Resolver = <T extends Type<any>>(schema: T, schemaOptions?: undefined, factoryOptions?: {
     /**
      * Return the raw input values rather than the parsed values.
      * @default false

package/arktype/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hookform/resolvers/arktype",
   "amdName": "hookformResolversArktype",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "private": true,
   "description": "React Hook Form validation resolver: arktype",
   "main": "dist/arktype.js",

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

@@ -57,14 +57,14 @@ test("form's native validation with Zod", async () => {
   usernameField = screen.getByPlaceholderText(/username/i) as HTMLInputElement;
   expect(usernameField.validity.valid).toBe(false);
   expect(usernameField.validationMessage).toBe(
-    'username must be more than 1 characters (was 0)',
+    'username must be more than length 1 (was 0)',
   );
 
   // password
   passwordField = screen.getByPlaceholderText(/password/i) as HTMLInputElement;
   expect(passwordField.validity.valid).toBe(false);
   expect(passwordField.validationMessage).toBe(
-    'password must be more than 1 characters (was 0)',
+    'password must be more than length 1 (was 0)',
   );
 
   await user.type(screen.getByPlaceholderText(/username/i), 'joe');

package/arktype/src/__tests__/Form.tsx

@@ -47,10 +47,10 @@ test("form's validation with arkType and TypeScript's integration", async () =>
   await user.click(screen.getByText(/submit/i));
 
   expect(
-    screen.getByText('username must be more than 1 characters (was 0)'),
+    screen.getByText('username must be more than length 1 (was 0)'),
   ).toBeInTheDocument();
   expect(
-    screen.getByText('password must be more than 1 characters (was 0)'),
+    screen.getByText('password must be more than length 1 (was 0)'),
   ).toBeInTheDocument();
   expect(handleSubmit).not.toHaveBeenCalled();
 });

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

@@ -1,22 +1,20 @@
 import { Field, InternalFieldName } from 'react-hook-form';
-import { type, arrayOf, union } from 'arktype';
+import { type } from 'arktype';
 
 export const schema = type({
   username: 'string>2',
-  password: union(['string>8', '&', '/.*[A-Za-z].*/'], ['/.*\\d.*/']),
+  password: '/.*[A-Za-z].*/>8|/.*\\d.*/',
   repeatPassword: 'string>1',
-  accessToken: union('string', 'number'),
+  accessToken: 'string|number',
   birthYear: '1900<number<2013',
   email: 'email',
-  tags: arrayOf('string'),
+  tags: 'string[]',
   enabled: 'boolean',
   url: 'string>1',
-  'like?': arrayOf(
-    type({
-      id: 'number',
-      name: 'string>3',
-    }),
-  ),
+  'like?': type({
+    id: 'number',
+    name: 'string>3',
+  }).array(),
   dateStr: 'Date',
 });
 

package/arktype/src/__tests__/__snapshots__/arktype.ts.snap

@@ -3,72 +3,463 @@
 exports[`arktypeResolver > should return a single error from arktypeResolver when validation fails 1`] = `
 {
   "errors": {
-    "accessToken": {
-      "message": "accessToken must be defined",
+    "accessToken": ArkError {
+      "code": "required",
+      "data": {
+        "birthYear": "birthYear",
+        "email": "",
+        "like": [
+          {
+            "id": "z",
+          },
+        ],
+        "password": "___",
+        "url": "abc",
+      },
+      "input": {
+        "code": "required",
+        "missingValueDescription": "a number or a string",
+        "relativePath": [
+          "accessToken",
+        ],
+      },
+      "missingValueDescription": "a number or a string",
+      "nodeConfig": {
+        "actual": [Function],
+        "description": [Function],
+        "expected": [Function],
+        "message": [Function],
+        "problem": [Function],
+      },
+      "path": [
+        "accessToken",
+      ],
       "ref": undefined,
-      "type": "missing",
+      "relativePath": [
+        "accessToken",
+      ],
+      "type": "required",
+      Symbol(ArkTypeInternalKind): "error",
     },
-    "birthYear": {
-      "message": "birthYear must be a number (was string)",
+    "birthYear": ArkError {
+      "code": "domain",
+      "data": "birthYear",
+      "description": "a number",
+      "domain": "number",
+      "input": {
+        "code": "domain",
+        "description": "a number",
+        "domain": "number",
+      },
+      "nodeConfig": {
+        "actual": [Function],
+        "description": [Function],
+        "expected": [Function],
+        "message": [Function],
+        "problem": [Function],
+      },
+      "path": [
+        "birthYear",
+      ],
       "ref": undefined,
       "type": "domain",
+      Symbol(ArkTypeInternalKind): "error",
     },
-    "dateStr": {
-      "message": "dateStr must be defined",
+    "dateStr": ArkError {
+      "code": "required",
+      "data": {
+        "birthYear": "birthYear",
+        "email": "",
+        "like": [
+          {
+            "id": "z",
+          },
+        ],
+        "password": "___",
+        "url": "abc",
+      },
+      "input": {
+        "code": "required",
+        "missingValueDescription": "a Date",
+        "relativePath": [
+          "dateStr",
+        ],
+      },
+      "missingValueDescription": "a Date",
+      "nodeConfig": {
+        "actual": [Function],
+        "description": [Function],
+        "expected": [Function],
+        "message": [Function],
+        "problem": [Function],
+      },
+      "path": [
+        "dateStr",
+      ],
       "ref": undefined,
-      "type": "missing",
+      "relativePath": [
+        "dateStr",
+      ],
+      "type": "required",
+      Symbol(ArkTypeInternalKind): "error",
     },
-    "email": {
-      "message": "email must be a valid email (was '')",
+    "email": ArkError {
+      "code": "regex",
+      "data": "",
+      "description": "a valid email",
+      "flags": "",
+      "input": {
+        "code": "regex",
+        "description": "a valid email",
+        "flags": "",
+        "rule": "^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\\\.[A-Za-z]{2,}$",
+      },
+      "nodeConfig": {
+        "actual": [Function],
+        "description": [Function],
+        "expected": [Function],
+        "message": [Function],
+        "problem": [Function],
+      },
+      "path": [
+        "email",
+      ],
       "ref": {
         "name": "email",
       },
+      "rule": "^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\\\.[A-Za-z]{2,}$",
       "type": "regex",
+      Symbol(ArkTypeInternalKind): "error",
     },
-    "enabled": {
-      "message": "enabled must be defined",
+    "enabled": ArkError {
+      "code": "required",
+      "data": {
+        "birthYear": "birthYear",
+        "email": "",
+        "like": [
+          {
+            "id": "z",
+          },
+        ],
+        "password": "___",
+        "url": "abc",
+      },
+      "input": {
+        "code": "required",
+        "missingValueDescription": "boolean",
+        "relativePath": [
+          "enabled",
+        ],
+      },
+      "missingValueDescription": "boolean",
+      "nodeConfig": {
+        "actual": [Function],
+        "description": [Function],
+        "expected": [Function],
+        "message": [Function],
+        "problem": [Function],
+      },
+      "path": [
+        "enabled",
+      ],
       "ref": undefined,
-      "type": "missing",
+      "relativePath": [
+        "enabled",
+      ],
+      "type": "required",
+      Symbol(ArkTypeInternalKind): "error",
     },
     "like": [
       {
-        "id": {
-          "message": "like/0/id must be a number (was string)",
+        "id": ArkError {
+          "code": "domain",
+          "data": "z",
+          "description": "a number",
+          "domain": "number",
+          "input": {
+            "code": "domain",
+            "description": "a number",
+            "domain": "number",
+          },
+          "nodeConfig": {
+            "actual": [Function],
+            "description": [Function],
+            "expected": [Function],
+            "message": [Function],
+            "problem": [Function],
+          },
+          "path": [
+            "like",
+            0,
+            "id",
+          ],
           "ref": undefined,
           "type": "domain",
+          Symbol(ArkTypeInternalKind): "error",
         },
-        "name": {
-          "message": "like/0/name must be defined",
+        "name": ArkError {
+          "code": "required",
+          "data": {
+            "id": "z",
+          },
+          "input": {
+            "code": "required",
+            "missingValueDescription": "a string and more than length 3",
+            "relativePath": [
+              "name",
+            ],
+          },
+          "missingValueDescription": "a string and more than length 3",
+          "nodeConfig": {
+            "actual": [Function],
+            "description": [Function],
+            "expected": [Function],
+            "message": [Function],
+            "problem": [Function],
+          },
+          "path": [
+            "like",
+            0,
+            "name",
+          ],
           "ref": undefined,
-          "type": "missing",
+          "relativePath": [
+            "name",
+          ],
+          "type": "required",
+          Symbol(ArkTypeInternalKind): "error",
         },
       },
     ],
-    "password": {
-      "message": "At password, '___' must be...
-• more than 8 characters
-• a string matching /.*[A-Za-z].*/",
+    "password": ArkError {
+      "code": "union",
+      "data": "___",
+      "errors": [
+        ArkError {
+          "code": "regex",
+          "data": "___",
+          "description": "matched by .*[A-Za-z].*",
+          "input": {
+            "code": "regex",
+            "description": "matched by .*[A-Za-z].*",
+            "rule": ".*[A-Za-z].*",
+          },
+          "nodeConfig": {
+            "actual": [Function],
+            "description": [Function],
+            "expected": [Function],
+            "message": [Function],
+            "problem": [Function],
+          },
+          "path": [
+            "password",
+          ],
+          "rule": ".*[A-Za-z].*",
+          Symbol(ArkTypeInternalKind): "error",
+        },
+        ArkError {
+          "code": "regex",
+          "data": "___",
+          "description": "matched by .*\\\\d.*",
+          "input": {
+            "code": "regex",
+            "description": "matched by .*\\\\d.*",
+            "rule": ".*\\\\d.*",
+          },
+          "nodeConfig": {
+            "actual": [Function],
+            "description": [Function],
+            "expected": [Function],
+            "message": [Function],
+            "problem": [Function],
+          },
+          "path": [
+            "password",
+          ],
+          "rule": ".*\\\\d.*",
+          Symbol(ArkTypeInternalKind): "error",
+        },
+      ],
+      "input": {
+        "code": "union",
+        "errors": [
+          ArkError {
+            "code": "regex",
+            "data": "___",
+            "description": "matched by .*[A-Za-z].*",
+            "input": {
+              "code": "regex",
+              "description": "matched by .*[A-Za-z].*",
+              "rule": ".*[A-Za-z].*",
+            },
+            "nodeConfig": {
+              "actual": [Function],
+              "description": [Function],
+              "expected": [Function],
+              "message": [Function],
+              "problem": [Function],
+            },
+            "path": [
+              "password",
+            ],
+            "rule": ".*[A-Za-z].*",
+            Symbol(ArkTypeInternalKind): "error",
+          },
+          ArkError {
+            "code": "regex",
+            "data": "___",
+            "description": "matched by .*\\\\d.*",
+            "input": {
+              "code": "regex",
+              "description": "matched by .*\\\\d.*",
+              "rule": ".*\\\\d.*",
+            },
+            "nodeConfig": {
+              "actual": [Function],
+              "description": [Function],
+              "expected": [Function],
+              "message": [Function],
+              "problem": [Function],
+            },
+            "path": [
+              "password",
+            ],
+            "rule": ".*\\\\d.*",
+            Symbol(ArkTypeInternalKind): "error",
+          },
+        ],
+      },
+      "nodeConfig": {
+        "actual": [Function],
+        "description": [Function],
+        "expected": [Function],
+        "message": [Function],
+        "problem": [Function],
+      },
+      "path": [
+        "password",
+      ],
       "ref": {
         "name": "password",
       },
-      "type": "multi",
+      "type": "union",
+      Symbol(ArkTypeInternalKind): "error",
     },
-    "repeatPassword": {
-      "message": "repeatPassword must be defined",
+    "repeatPassword": ArkError {
+      "code": "required",
+      "data": {
+        "birthYear": "birthYear",
+        "email": "",
+        "like": [
+          {
+            "id": "z",
+          },
+        ],
+        "password": "___",
+        "url": "abc",
+      },
+      "input": {
+        "code": "required",
+        "missingValueDescription": "a string and more than length 1",
+        "relativePath": [
+          "repeatPassword",
+        ],
+      },
+      "missingValueDescription": "a string and more than length 1",
+      "nodeConfig": {
+        "actual": [Function],
+        "description": [Function],
+        "expected": [Function],
+        "message": [Function],
+        "problem": [Function],
+      },
+      "path": [
+        "repeatPassword",
+      ],
       "ref": undefined,
-      "type": "missing",
+      "relativePath": [
+        "repeatPassword",
+      ],
+      "type": "required",
+      Symbol(ArkTypeInternalKind): "error",
     },
-    "tags": {
-      "message": "tags must be defined",
+    "tags": ArkError {
+      "code": "required",
+      "data": {
+        "birthYear": "birthYear",
+        "email": "",
+        "like": [
+          {
+            "id": "z",
+          },
+        ],
+        "password": "___",
+        "url": "abc",
+      },
+      "input": {
+        "code": "required",
+        "missingValueDescription": "string[]",
+        "relativePath": [
+          "tags",
+        ],
+      },
+      "missingValueDescription": "string[]",
+      "nodeConfig": {
+        "actual": [Function],
+        "description": [Function],
+        "expected": [Function],
+        "message": [Function],
+        "problem": [Function],
+      },
+      "path": [
+        "tags",
+      ],
       "ref": undefined,
-      "type": "missing",
+      "relativePath": [
+        "tags",
+      ],
+      "type": "required",
+      Symbol(ArkTypeInternalKind): "error",
     },
-    "username": {
-      "message": "username must be defined",
+    "username": ArkError {
+      "code": "required",
+      "data": {
+        "birthYear": "birthYear",
+        "email": "",
+        "like": [
+          {
+            "id": "z",
+          },
+        ],
+        "password": "___",
+        "url": "abc",
+      },
+      "input": {
+        "code": "required",
+        "missingValueDescription": "a string and more than length 2",
+        "relativePath": [
+          "username",
+        ],
+      },
+      "missingValueDescription": "a string and more than length 2",
+      "nodeConfig": {
+        "actual": [Function],
+        "description": [Function],
+        "expected": [Function],
+        "message": [Function],
+        "problem": [Function],
+      },
+      "path": [
+        "username",
+      ],
       "ref": {
         "name": "username",
       },
-      "type": "missing",
+      "relativePath": [
+        "username",
+      ],
+      "type": "required",
+      Symbol(ArkTypeInternalKind): "error",
     },
   },
   "values": {},

package/arktype/src/arktype.ts

@@ -1,34 +1,24 @@
 import { FieldError, FieldErrors } from 'react-hook-form';
 import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';
 import type { Resolver } from './types';
-import { Problems } from 'arktype';
+import { ArkErrors } from 'arktype';
 
-const parseErrorSchema = (e: Problems) => {
-  const errors: Record<string, FieldError> = {};
-  for (; e.length; ) {
-    const error = e[0];
-    const _path = error.path.join('.');
-
-    if (!errors[_path]) {
-      errors[_path] = { message: error.message, type: error.code };
-    }
-
-    // @ts-expect-error - false positive Property 'shift' does not exist on type 'Problems'.
-    e.shift();
-  }
-
-  return errors;
+const parseErrorSchema = (e: ArkErrors): Record<string, FieldError> => {
+  // copy code to type to match FieldError shape
+  e.forEach((e) => Object.assign(e, { type: e.code }));
+  // need to cast here because TS doesn't understand we added the type field
+  return e.byPath as never;
 };
 
 export const arktypeResolver: Resolver =
   (schema, _schemaOptions, resolverOptions = {}) =>
   (values, _, options) => {
-    const result = schema(values);
+    const out = schema(values);
 
-    if (result.problems) {
+    if (out instanceof ArkErrors) {
       return {
         values: {},
-        errors: toNestErrors(parseErrorSchema(result.problems), options),
+        errors: toNestErrors(parseErrorSchema(out), options),
       };
     }
 
@@ -36,6 +26,6 @@ export const arktypeResolver: Resolver =
 
     return {
       errors: {} as FieldErrors,
-      values: resolverOptions.raw ? values : result.data,
+      values: resolverOptions.raw ? values : out,
     };
   };

package/arktype/src/types.ts

@@ -3,7 +3,7 @@ import { Type } from 'arktype';
 
 export type Resolver = <T extends Type<any>>(
   schema: T,
-  schemaOptions?: never,
+  schemaOptions?: undefined,
   factoryOptions?: {
     /**
      * Return the raw input values rather than the parsed values.

package/dist/resolvers.js

@@ -1,2 +1,2 @@
-var e=require("react-hook-form");function r(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var t=/*#__PURE__*/r(require("lodash.set")),i=function(r,t,i){if(r&&"reportValidity"in r){var a=e.get(i,t);r.setCustomValidity(a&&a.message||""),r.reportValidity()}},a=function(e,r){var t=function(t){var a=r.fields[t];a&&a.ref&&"reportValidity"in a.ref?i(a.ref,t,e):a.refs&&a.refs.forEach(function(r){return i(r,t,e)})};for(var a in r.fields)t(a)},f=function(e,r){return e.some(function(e){return e.startsWith(r+".")})};exports.toNestErrors=function(r,i){i.shouldUseNativeValidation&&a(r,i);var n={};for(var o in r){var s=e.get(i.fields,o),u=Object.assign(r[o]||{},{ref:s&&s.ref});if(f(i.names||Object.keys(r),o)){var l=Object.assign({},e.get(n,o));t.default(l,"root",u),t.default(n,o,l)}else t.default(n,o,u)}return n},exports.validateFieldsNatively=a;
+var r=require("react-hook-form"),e=function(e,t,i){if(e&&"reportValidity"in e){var n=r.get(i,t);e.setCustomValidity(n&&n.message||""),e.reportValidity()}},t=function(r,t){var i=function(i){var n=t.fields[i];n&&n.ref&&"reportValidity"in n.ref?e(n.ref,i,r):n.refs&&n.refs.forEach(function(t){return e(t,i,r)})};for(var n in t.fields)i(n)},i=function(r){return r instanceof Date},n=function(r){return null==r},o=function(r){return"object"==typeof r},s=function(r){return!n(r)&&!Array.isArray(r)&&o(r)&&!i(r)},a=function(r){return/^\w*$/.test(r)},f=function(r,e,t){for(var i=-1,n=a(e)?[e]:function(r){return e=r.replace(/["|']|\]/g,"").split(/\.|\[/),Array.isArray(e)?e.filter(Boolean):[];var e}(e),o=n.length,f=o-1;++i<o;){var u=n[i],c=t;if(i!==f){var l=r[u];c=s(l)||Array.isArray(l)?l:isNaN(+n[i+1])?{}:[]}r[u]=c,r=r[u]}return r},u=function(r,e){return r.some(function(r){return r.startsWith(e+".")})};exports.isDateObject=i,exports.isKey=a,exports.isNullOrUndefined=n,exports.isObject=s,exports.isObjectType=o,exports.toNestErrors=function(e,i){i.shouldUseNativeValidation&&t(e,i);var n={};for(var o in e){var s=r.get(i.fields,o),a=Object.assign(e[o]||{},{ref:s&&s.ref});if(u(i.names||Object.keys(e),o)){var c=Object.assign({},r.get(n,o));f(c,"root",a),f(n,o,c)}else f(n,o,a)}return n},exports.validateFieldsNatively=t;
 //# sourceMappingURL=resolvers.js.map