@hookform/resolvers 3.4.2 → 3.6.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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hookform/resolvers",
   "amdName": "hookformResolvers",
-  "version": "3.4.2",
+  "version": "3.6.0",
   "description": "React Hook Form validation resolvers: Yup, Joi, Superstruct, Zod, Vest, Class Validator, io-ts, Nope, computed-types, TypeBox, arktype, Typanion and Effect-TS",
   "main": "dist/resolvers.js",
   "module": "dist/resolvers.module.js",
@@ -233,7 +233,7 @@
     "@vitejs/plugin-react": "^4.0.4",
     "ajv": "^8.12.0",
     "ajv-errors": "^3.0.0",
-    "arktype": "1.0.19-alpha",
+    "arktype": "2.0.0-dev.14",
     "check-export-map": "^1.3.0",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.0",
@@ -262,7 +262,7 @@
     "superstruct": "^1.0.3",
     "typanion": "^3.14.0",
     "typescript": "^5.1.6",
-    "valibot": "^0.24.1",
+    "valibot": "0.31.0-rc.12",
     "vest": "^4.6.11",
     "vite": "^4.4.9",
     "vite-tsconfig-paths": "^4.2.0",

package/valibot/dist/types.d.ts

@@ -1,6 +1,6 @@
 import { FieldValues, ResolverResult, ResolverOptions } from 'react-hook-form';
-import { BaseSchema, BaseSchemaAsync, ParseInfo } from 'valibot';
-export type Resolver = <T extends BaseSchema | BaseSchemaAsync>(schema: T, schemaOptions?: Partial<Pick<ParseInfo, 'abortEarly' | 'abortPipeEarly'>>, resolverOptions?: {
+import { BaseIssue, BaseSchema, BaseSchemaAsync, Config, InferIssue } from 'valibot';
+export type Resolver = <T extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>>(schema: T, schemaOptions?: Partial<Omit<Config<InferIssue<T>>, 'abortPipeEarly' | 'skipPipe'>>, resolverOptions?: {
     /**
      * @default async
      */