@hookform/resolvers 5.4.2 → 5.4.3

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

@@ -6,41 +6,41 @@ exports[`arktypeResolver > should return a single error from arktypeResolver whe
     "accessToken": {
       "message": "accessToken must be a number or a string (was missing)",
       "ref": undefined,
-      "type": "required",
+      "type": "",
     },
     "birthYear": {
       "message": "birthYear must be a number (was a string)",
       "ref": undefined,
-      "type": "domain",
+      "type": "",
     },
     "dateStr": {
       "message": "dateStr must be a Date (was missing)",
       "ref": undefined,
-      "type": "required",
+      "type": "",
     },
     "email": {
       "message": "email must be an email address (was "")",
       "ref": {
         "name": "email",
       },
-      "type": "pattern",
+      "type": "",
     },
     "enabled": {
       "message": "enabled must be boolean (was missing)",
       "ref": undefined,
-      "type": "required",
+      "type": "",
     },
     "like": [
       {
         "id": {
           "message": "like[0].id must be a number (was a string)",
           "ref": undefined,
-          "type": "domain",
+          "type": "",
         },
         "name": {
           "message": "like[0].name must be a string (was missing)",
           "ref": undefined,
-          "type": "required",
+          "type": "",
         },
       },
     ],
@@ -49,24 +49,24 @@ exports[`arktypeResolver > should return a single error from arktypeResolver whe
       "ref": {
         "name": "password",
       },
-      "type": "union",
+      "type": "",
     },
     "repeatPassword": {
       "message": "repeatPassword must be a string (was missing)",
       "ref": undefined,
-      "type": "required",
+      "type": "",
     },
     "tags": {
       "message": "tags must be an array (was missing)",
       "ref": undefined,
-      "type": "required",
+      "type": "",
     },
     "username": {
       "message": "username must be a string (was missing)",
       "ref": {
         "name": "username",
       },
-      "type": "required",
+      "type": "",
     },
   },
   "values": {},

package/arktype/src/__tests__/arktype.ts

@@ -1,3 +1,4 @@
+import { renderHook } from '@testing-library/react';
 import { type } from 'arktype';
 import { Resolver, useForm } from 'react-hook-form';
 import { SubmitHandler } from 'react-hook-form';
@@ -51,9 +52,13 @@ describe('arktypeResolver', () => {
   it('should correctly infer the output type from a arktype schema for the handleSubmit function in useForm', () => {
     const schema = type({ id: 'number' });
 
-    const form = useForm({
-      resolver: arktypeResolver(schema),
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        resolver: arktypeResolver(schema),
+      }),
+    );
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
 
@@ -67,9 +72,13 @@ describe('arktypeResolver', () => {
   it('should correctly infer the output type from a arktype schema with a transform for the handleSubmit function in useForm', () => {
     const schema = type({ id: type('string').pipe((s) => Number.parseInt(s)) });
 
-    const form = useForm({
-      resolver: arktypeResolver(schema),
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        resolver: arktypeResolver(schema),
+      }),
+    );
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<string>();
 

package/computed-types/src/__tests__/computed-types.ts

@@ -1,3 +1,4 @@
+import { renderHook } from '@testing-library/react';
 import Schema, { number } from 'computed-types';
 import { Resolver, SubmitHandler, useForm } from 'react-hook-form';
 import { computedTypesResolver } from '..';
@@ -65,9 +66,13 @@ describe('computedTypesResolver', () => {
   it('should correctly infer the output type from a computedTypes schema for the handleSubmit function in useForm', () => {
     const schema = Schema({ id: number });
 
-    const form = useForm({
-      resolver: computedTypesResolver(schema),
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        resolver: computedTypesResolver(schema),
+      }),
+    );
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
 
@@ -81,9 +86,13 @@ describe('computedTypesResolver', () => {
   it('should correctly infer the output type from a computedTypes schema with a transform for the handleSubmit function in useForm', () => {
     const schema = Schema({ id: number.transform((val) => String(val)) });
 
-    const form = useForm({
-      resolver: computedTypesResolver(schema),
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        resolver: computedTypesResolver(schema),
+      }),
+    );
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
 

package/effect-ts/src/__tests__/effect-ts.ts

@@ -1,3 +1,4 @@
+import { renderHook } from '@testing-library/react';
 import { Schema } from 'effect';
 import { Resolver, useForm } from 'react-hook-form';
 import { SubmitHandler } from 'react-hook-form';
@@ -114,9 +115,13 @@ describe('effectTsResolver', () => {
   it('should correctly infer the output type from a effectTs schema for the handleSubmit function in useForm', () => {
     const schema = Schema.Struct({ id: Schema.Number });
 
-    const form = useForm({
-      resolver: effectTsResolver(schema),
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        resolver: effectTsResolver(schema),
+      }),
+    );
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
 
@@ -133,9 +138,13 @@ describe('effectTsResolver', () => {
       }),
     });
 
-    const form = useForm({
-      resolver: effectTsResolver(schema),
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        resolver: effectTsResolver(schema),
+      }),
+    );
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
 

package/io-ts/src/__tests__/io-ts.ts

@@ -1,3 +1,4 @@
+import { renderHook } from '@testing-library/react';
 import * as t from 'io-ts';
 import * as tt from 'io-ts-types';
 import { Resolver, SubmitHandler, useForm } from 'react-hook-form';
@@ -60,9 +61,13 @@ describe('ioTsResolver', () => {
   it('should correctly infer the output type from a io-ts schema for the handleSubmit function in useForm', () => {
     const schema = t.type({ id: t.number });
 
-    const form = useForm({
-      resolver: ioTsResolver(schema),
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        resolver: ioTsResolver(schema),
+      }),
+    );
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
 
@@ -76,9 +81,13 @@ describe('ioTsResolver', () => {
   it('should correctly infer the output type from a io-ts schema with a transform for the handleSubmit function in useForm', () => {
     const schema = t.type({ id: tt.NumberFromString });
 
-    const form = useForm({
-      resolver: ioTsResolver(schema),
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        resolver: ioTsResolver(schema),
+      }),
+    );
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<string>();
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hookform/resolvers",
   "amdName": "hookformResolvers",
-  "version": "5.4.2",
+  "version": "5.4.3",
   "description": "React Hook Form validation resolvers: Yup, Joi, Superstruct, Zod, Vest, Class Validator, io-ts, Nope, computed-types, TypeBox, arktype, Typanion, Effect-TS and VineJS",
   "main": "dist/resolvers.js",
   "module": "dist/resolvers.module.js",

package/standard-schema/src/__tests__/__snapshots__/standard-schema.ts.snap

@@ -1,5 +1,23 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
+exports[`standardSchemaResolver > should collect all root errors when validateAllFieldCriteria is true 1`] = `
+{
+  "errors": {
+    "root": {
+      "message": "Invalid union
+Missing discriminator",
+      "ref": undefined,
+      "type": "",
+      "types": {
+        "0": "Invalid union",
+        "1": "Missing discriminator",
+      },
+    },
+  },
+  "values": {},
+}
+`;
+
 exports[`standardSchemaResolver > should correctly handle path segments that are objects 1`] = `
 {
   "errors": {
@@ -24,6 +42,19 @@ exports[`standardSchemaResolver > should correctly handle path segments that are
 }
 `;
 
+exports[`standardSchemaResolver > should return a root error when a standard schema issue has no path 1`] = `
+{
+  "errors": {
+    "root": {
+      "message": "Invalid input",
+      "ref": undefined,
+      "type": "",
+    },
+  },
+  "values": {},
+}
+`;
+
 exports[`standardSchemaResolver > should return a single error from standardSchemaResolver when validation fails 1`] = `
 {
   "errors": {

package/standard-schema/src/__tests__/standard-schema.ts

@@ -1,3 +1,4 @@
+import { renderHook } from '@testing-library/react';
 import { Resolver, SubmitHandler, useForm } from 'react-hook-form';
 import { z } from 'zod/v3';
 import { standardSchemaResolver } from '..';
@@ -218,13 +219,16 @@ describe('standardSchemaResolver', () => {
 
   it('should correctly infer the output type from a standardSchema schema for the handleSubmit function in useForm', () => {
     const schema = z.object({ id: z.number() });
-
-    const form = useForm({
-      resolver: standardSchemaResolver(schema),
-      defaultValues: {
-        id: 3,
-      },
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        resolver: standardSchemaResolver(schema),
+        defaultValues: {
+          id: 3,
+        },
+      }),
+    );
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
 
@@ -238,12 +242,16 @@ describe('standardSchemaResolver', () => {
   it('should correctly infer the output type from a standardSchema schema with a transform for the handleSubmit function in useForm', () => {
     const schema = z.object({ id: z.number().transform((val) => String(val)) });
 
-    const form = useForm({
-      resolver: standardSchemaResolver(schema),
-      defaultValues: {
-        id: 3,
-      },
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        resolver: standardSchemaResolver(schema),
+        defaultValues: {
+          id: 3,
+        },
+      }),
+    );
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
 

package/superstruct/dist/superstruct.d.ts

@@ -1,5 +1,10 @@
 import { FieldValues, Resolver } from 'react-hook-form';
 import { Infer, Struct, validate } from 'superstruct';
+export declare function superstructResolver<Input extends FieldValues, Context, Output>(schema: Struct<Output, any>, schemaOptions: Omit<Parameters<typeof validate>[2], 'coerce'> & {
+    coerce: true;
+}, resolverOptions?: {
+    raw?: boolean;
+}): Resolver<Input, Context, Output>;
 export declare function superstructResolver<Input extends FieldValues, Context, Output>(schema: Struct<Input, any>, schemaOptions?: Parameters<typeof validate>[2], resolverOptions?: {
     raw?: false;
 }): Resolver<Input, Context, Infer<typeof schema>>;

package/superstruct/dist/superstruct.js.map

@@ -1 +1 @@
-{"version":3,"file":"superstruct.js","sources":["../src/superstruct.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { FieldError, FieldValues, Resolver } from 'react-hook-form';\nimport { Infer, Struct, StructError, validate } from 'superstruct';\n\nfunction parseErrorSchema(error: StructError) {\n  return error.failures().reduce<Record<string, FieldError>>(\n    (previous, error) =>\n      (previous[error.path.join('.')] = {\n        message: error.message,\n        type: error.type,\n      }) && previous,\n    {},\n  );\n}\n\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Input, any>,\n  schemaOptions?: Parameters<typeof validate>[2],\n  resolverOptions?: {\n    raw?: false;\n  },\n): Resolver<Input, Context, Infer<typeof schema>>;\n\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Input, any>,\n  schemaOptions: Parameters<typeof validate>[2] | undefined,\n  resolverOptions: {\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Superstruct schema validation\n * @param {Struct<TFieldValues, any>} schema - The Superstruct schema to validate against\n * @param {Parameters<typeof validate>[2]} [schemaOptions] - Optional Superstruct validation options\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {boolean} [resolverOptions.raw=false] - If true, returns raw values rather than validated results\n * @returns {Resolver<Infer<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = struct({\n *   name: string(),\n *   age: number()\n * });\n *\n * useForm({\n *   resolver: superstructResolver(schema)\n * });\n */\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Input, any>,\n  schemaOptions?: Parameters<typeof validate>[2],\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Input | Output> {\n  return (values: Input, _, options) => {\n    const result = validate(values, schema, schemaOptions);\n\n    if (result[0]) {\n      return {\n        values: {},\n        errors: toNestErrors(parseErrorSchema(result[0]), options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      values: resolverOptions.raw ? Object.assign({}, values) : result[1],\n      errors: {},\n    };\n  };\n}\n"],"names":["schema","schemaOptions","resolverOptions","values","_","options","error","result","validate","errors","toNestErrors","failures","reduce","previous","path","join","message","type","shouldUseNativeValidation","validateFieldsNatively","raw","Object","assign"],"mappings":"mGAiDEA,EACAC,EACAC,GAIA,gBAJAA,IAAAA,EAEI,CAAE,GAEEC,SAAAA,EAAeC,EAAGC,GACxB,IApDsBC,EAoDhBC,EAASC,EAAAA,SAASL,EAAQH,EAAQC,GAExC,OAAIM,EAAO,GACF,CACLJ,OAAQ,CAAA,EACRM,OAAQC,EAAYA,cAzDFJ,EAyDoBC,EAAO,GAxD5CD,EAAMK,WAAWC,OACtB,SAACC,EAAUP,GACT,OAACO,EAASP,EAAMQ,KAAKC,KAAK,MAAQ,CAChCC,QAASV,EAAMU,QACfC,KAAMX,EAAMW,QACRJ,CAAQ,EAChB,CAAA,IAkDsDR,KAItDA,EAAQa,2BAA6BC,yBAAuB,CAAA,EAAId,GAEzD,CACLF,OAAQD,EAAgBkB,IAAMC,OAAOC,OAAO,CAAE,EAAEnB,GAAUI,EAAO,GACjEE,OAAQ,CAAA,GAEZ,CACF"}
+{"version":3,"file":"superstruct.js","sources":["../src/superstruct.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { FieldError, FieldValues, Resolver } from 'react-hook-form';\nimport { Infer, Struct, StructError, validate } from 'superstruct';\n\nfunction parseErrorSchema(error: StructError) {\n  return error.failures().reduce<Record<string, FieldError>>(\n    (previous, error) =>\n      (previous[error.path.join('.')] = {\n        message: error.message,\n        type: error.type,\n      }) && previous,\n    {},\n  );\n}\n\n// This is required to correctly type the input of the returned function when coerce is true\n// superstruct does not store the input type of a schema alongside it\n// Infer<typeof schema> gives the output type of the coercion\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Output, any>,\n  schemaOptions: Omit<Parameters<typeof validate>[2], 'coerce'> & {\n    coerce: true;\n  },\n  resolverOptions?: {\n    raw?: boolean;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Input, any>,\n  schemaOptions?: Parameters<typeof validate>[2],\n  resolverOptions?: {\n    raw?: false;\n  },\n): Resolver<Input, Context, Infer<typeof schema>>;\n\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Input, any>,\n  schemaOptions: Parameters<typeof validate>[2] | undefined,\n  resolverOptions: {\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Superstruct schema validation\n * @param {Struct<TFieldValues, any>} schema - The Superstruct schema to validate against\n * @param {Parameters<typeof validate>[2]} [schemaOptions] - Optional Superstruct validation options\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {boolean} [resolverOptions.raw=false] - If true, returns raw values rather than validated results\n * @returns {Resolver<Infer<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = struct({\n *   name: string(),\n *   age: number()\n * });\n *\n * useForm({\n *   resolver: superstructResolver(schema)\n * });\n */\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Input, any>,\n  schemaOptions?: Parameters<typeof validate>[2],\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Input | Output> {\n  return (values: Input, _, options) => {\n    const result = validate(values, schema, schemaOptions);\n\n    if (result[0]) {\n      return {\n        values: {},\n        errors: toNestErrors(parseErrorSchema(result[0]), options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      values: resolverOptions.raw ? Object.assign({}, values) : result[1],\n      errors: {},\n    };\n  };\n}\n"],"names":["schema","schemaOptions","resolverOptions","values","_","options","error","result","validate","errors","toNestErrors","failures","reduce","previous","path","join","message","type","shouldUseNativeValidation","validateFieldsNatively","raw","Object","assign"],"mappings":"mGA8DEA,EACAC,EACAC,GAIA,gBAJAA,IAAAA,EAEI,CAAE,GAEEC,SAAAA,EAAeC,EAAGC,GACxB,IAjEsBC,EAiEhBC,EAASC,EAAAA,SAASL,EAAQH,EAAQC,GAExC,OAAIM,EAAO,GACF,CACLJ,OAAQ,CAAA,EACRM,OAAQC,EAAYA,cAtEFJ,EAsEoBC,EAAO,GArE5CD,EAAMK,WAAWC,OACtB,SAACC,EAAUP,GACT,OAACO,EAASP,EAAMQ,KAAKC,KAAK,MAAQ,CAChCC,QAASV,EAAMU,QACfC,KAAMX,EAAMW,QACRJ,CAAQ,EAChB,CAAA,IA+DsDR,KAItDA,EAAQa,2BAA6BC,yBAAuB,CAAA,EAAId,GAEzD,CACLF,OAAQD,EAAgBkB,IAAMC,OAAOC,OAAO,CAAE,EAAEnB,GAAUI,EAAO,GACjEE,OAAQ,CAAA,GAEZ,CACF"}

package/superstruct/dist/superstruct.modern.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"superstruct.modern.mjs","sources":["../src/superstruct.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { FieldError, FieldValues, Resolver } from 'react-hook-form';\nimport { Infer, Struct, StructError, validate } from 'superstruct';\n\nfunction parseErrorSchema(error: StructError) {\n  return error.failures().reduce<Record<string, FieldError>>(\n    (previous, error) =>\n      (previous[error.path.join('.')] = {\n        message: error.message,\n        type: error.type,\n      }) && previous,\n    {},\n  );\n}\n\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Input, any>,\n  schemaOptions?: Parameters<typeof validate>[2],\n  resolverOptions?: {\n    raw?: false;\n  },\n): Resolver<Input, Context, Infer<typeof schema>>;\n\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Input, any>,\n  schemaOptions: Parameters<typeof validate>[2] | undefined,\n  resolverOptions: {\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Superstruct schema validation\n * @param {Struct<TFieldValues, any>} schema - The Superstruct schema to validate against\n * @param {Parameters<typeof validate>[2]} [schemaOptions] - Optional Superstruct validation options\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {boolean} [resolverOptions.raw=false] - If true, returns raw values rather than validated results\n * @returns {Resolver<Infer<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = struct({\n *   name: string(),\n *   age: number()\n * });\n *\n * useForm({\n *   resolver: superstructResolver(schema)\n * });\n */\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Input, any>,\n  schemaOptions?: Parameters<typeof validate>[2],\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Input | Output> {\n  return (values: Input, _, options) => {\n    const result = validate(values, schema, schemaOptions);\n\n    if (result[0]) {\n      return {\n        values: {},\n        errors: toNestErrors(parseErrorSchema(result[0]), options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      values: resolverOptions.raw ? Object.assign({}, values) : result[1],\n      errors: {},\n    };\n  };\n}\n"],"names":["superstructResolver","schema","schemaOptions","resolverOptions","values","_","options","result","validate","errors","toNestErrors","error","failures","reduce","previous","path","join","message","type","shouldUseNativeValidation","validateFieldsNatively","raw","Object","assign"],"mappings":"sHAgDgB,SAAAA,EACdC,EACAC,EACAC,EAEI,CAAE,GAEN,MAAO,CAACC,EAAeC,EAAGC,KACxB,MAAMC,EAASC,EAASJ,EAAQH,EAAQC,GAExC,OAAIK,EAAO,GACF,CACLH,OAAQ,CAAA,EACRK,OAAQC,GAzDUC,EAyDoBJ,EAAO,GAxD5CI,EAAMC,WAAWC,OACtB,CAACC,EAAUH,KACRG,EAASH,EAAMI,KAAKC,KAAK,MAAQ,CAChCC,QAASN,EAAMM,QACfC,KAAMP,EAAMO,QACRJ,EACR,KAkDsDR,KAItDA,EAAQa,2BAA6BC,EAAuB,GAAId,GAEzD,CACLF,OAAQD,EAAgBkB,IAAMC,OAAOC,OAAO,CAAA,EAAInB,GAAUG,EAAO,GACjEE,OAAQ,CAAA,IAjEd,IAA0BE,EAoE1B"}
+{"version":3,"file":"superstruct.modern.mjs","sources":["../src/superstruct.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { FieldError, FieldValues, Resolver } from 'react-hook-form';\nimport { Infer, Struct, StructError, validate } from 'superstruct';\n\nfunction parseErrorSchema(error: StructError) {\n  return error.failures().reduce<Record<string, FieldError>>(\n    (previous, error) =>\n      (previous[error.path.join('.')] = {\n        message: error.message,\n        type: error.type,\n      }) && previous,\n    {},\n  );\n}\n\n// This is required to correctly type the input of the returned function when coerce is true\n// superstruct does not store the input type of a schema alongside it\n// Infer<typeof schema> gives the output type of the coercion\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Output, any>,\n  schemaOptions: Omit<Parameters<typeof validate>[2], 'coerce'> & {\n    coerce: true;\n  },\n  resolverOptions?: {\n    raw?: boolean;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Input, any>,\n  schemaOptions?: Parameters<typeof validate>[2],\n  resolverOptions?: {\n    raw?: false;\n  },\n): Resolver<Input, Context, Infer<typeof schema>>;\n\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Input, any>,\n  schemaOptions: Parameters<typeof validate>[2] | undefined,\n  resolverOptions: {\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Superstruct schema validation\n * @param {Struct<TFieldValues, any>} schema - The Superstruct schema to validate against\n * @param {Parameters<typeof validate>[2]} [schemaOptions] - Optional Superstruct validation options\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {boolean} [resolverOptions.raw=false] - If true, returns raw values rather than validated results\n * @returns {Resolver<Infer<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = struct({\n *   name: string(),\n *   age: number()\n * });\n *\n * useForm({\n *   resolver: superstructResolver(schema)\n * });\n */\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Input, any>,\n  schemaOptions?: Parameters<typeof validate>[2],\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Input | Output> {\n  return (values: Input, _, options) => {\n    const result = validate(values, schema, schemaOptions);\n\n    if (result[0]) {\n      return {\n        values: {},\n        errors: toNestErrors(parseErrorSchema(result[0]), options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      values: resolverOptions.raw ? Object.assign({}, values) : result[1],\n      errors: {},\n    };\n  };\n}\n"],"names":["superstructResolver","schema","schemaOptions","resolverOptions","values","_","options","result","validate","errors","toNestErrors","error","failures","reduce","previous","path","join","message","type","shouldUseNativeValidation","validateFieldsNatively","raw","Object","assign"],"mappings":"sHA6DgB,SAAAA,EACdC,EACAC,EACAC,EAEI,CAAE,GAEN,MAAO,CAACC,EAAeC,EAAGC,KACxB,MAAMC,EAASC,EAASJ,EAAQH,EAAQC,GAExC,OAAIK,EAAO,GACF,CACLH,OAAQ,CAAA,EACRK,OAAQC,GAtEUC,EAsEoBJ,EAAO,GArE5CI,EAAMC,WAAWC,OACtB,CAACC,EAAUH,KACRG,EAASH,EAAMI,KAAKC,KAAK,MAAQ,CAChCC,QAASN,EAAMM,QACfC,KAAMP,EAAMO,QACRJ,EACR,KA+DsDR,KAItDA,EAAQa,2BAA6BC,EAAuB,GAAId,GAEzD,CACLF,OAAQD,EAAgBkB,IAAMC,OAAOC,OAAO,CAAA,EAAInB,GAAUG,EAAO,GACjEE,OAAQ,CAAA,IA9Ed,IAA0BE,EAiF1B"}

package/superstruct/dist/superstruct.module.js.map

@@ -1 +1 @@
-{"version":3,"file":"superstruct.module.js","sources":["../src/superstruct.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { FieldError, FieldValues, Resolver } from 'react-hook-form';\nimport { Infer, Struct, StructError, validate } from 'superstruct';\n\nfunction parseErrorSchema(error: StructError) {\n  return error.failures().reduce<Record<string, FieldError>>(\n    (previous, error) =>\n      (previous[error.path.join('.')] = {\n        message: error.message,\n        type: error.type,\n      }) && previous,\n    {},\n  );\n}\n\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Input, any>,\n  schemaOptions?: Parameters<typeof validate>[2],\n  resolverOptions?: {\n    raw?: false;\n  },\n): Resolver<Input, Context, Infer<typeof schema>>;\n\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Input, any>,\n  schemaOptions: Parameters<typeof validate>[2] | undefined,\n  resolverOptions: {\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Superstruct schema validation\n * @param {Struct<TFieldValues, any>} schema - The Superstruct schema to validate against\n * @param {Parameters<typeof validate>[2]} [schemaOptions] - Optional Superstruct validation options\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {boolean} [resolverOptions.raw=false] - If true, returns raw values rather than validated results\n * @returns {Resolver<Infer<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = struct({\n *   name: string(),\n *   age: number()\n * });\n *\n * useForm({\n *   resolver: superstructResolver(schema)\n * });\n */\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Input, any>,\n  schemaOptions?: Parameters<typeof validate>[2],\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Input | Output> {\n  return (values: Input, _, options) => {\n    const result = validate(values, schema, schemaOptions);\n\n    if (result[0]) {\n      return {\n        values: {},\n        errors: toNestErrors(parseErrorSchema(result[0]), options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      values: resolverOptions.raw ? Object.assign({}, values) : result[1],\n      errors: {},\n    };\n  };\n}\n"],"names":["superstructResolver","schema","schemaOptions","resolverOptions","values","_","options","error","result","validate","errors","toNestErrors","failures","reduce","previous","path","join","message","type","shouldUseNativeValidation","validateFieldsNatively","raw","Object","assign"],"mappings":"+HAgDgBA,EACdC,EACAC,EACAC,GAIA,gBAJAA,IAAAA,EAEI,CAAE,GAEEC,SAAAA,EAAeC,EAAGC,GACxB,IApDsBC,EAoDhBC,EAASC,EAASL,EAAQH,EAAQC,GAExC,OAAIM,EAAO,GACF,CACLJ,OAAQ,CAAA,EACRM,OAAQC,GAzDUJ,EAyDoBC,EAAO,GAxD5CD,EAAMK,WAAWC,OACtB,SAACC,EAAUP,GACT,OAACO,EAASP,EAAMQ,KAAKC,KAAK,MAAQ,CAChCC,QAASV,EAAMU,QACfC,KAAMX,EAAMW,QACRJ,CAAQ,EAChB,CAAA,IAkDsDR,KAItDA,EAAQa,2BAA6BC,EAAuB,CAAA,EAAId,GAEzD,CACLF,OAAQD,EAAgBkB,IAAMC,OAAOC,OAAO,CAAE,EAAEnB,GAAUI,EAAO,GACjEE,OAAQ,CAAA,GAEZ,CACF"}
+{"version":3,"file":"superstruct.module.js","sources":["../src/superstruct.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { FieldError, FieldValues, Resolver } from 'react-hook-form';\nimport { Infer, Struct, StructError, validate } from 'superstruct';\n\nfunction parseErrorSchema(error: StructError) {\n  return error.failures().reduce<Record<string, FieldError>>(\n    (previous, error) =>\n      (previous[error.path.join('.')] = {\n        message: error.message,\n        type: error.type,\n      }) && previous,\n    {},\n  );\n}\n\n// This is required to correctly type the input of the returned function when coerce is true\n// superstruct does not store the input type of a schema alongside it\n// Infer<typeof schema> gives the output type of the coercion\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Output, any>,\n  schemaOptions: Omit<Parameters<typeof validate>[2], 'coerce'> & {\n    coerce: true;\n  },\n  resolverOptions?: {\n    raw?: boolean;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Input, any>,\n  schemaOptions?: Parameters<typeof validate>[2],\n  resolverOptions?: {\n    raw?: false;\n  },\n): Resolver<Input, Context, Infer<typeof schema>>;\n\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Input, any>,\n  schemaOptions: Parameters<typeof validate>[2] | undefined,\n  resolverOptions: {\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Superstruct schema validation\n * @param {Struct<TFieldValues, any>} schema - The Superstruct schema to validate against\n * @param {Parameters<typeof validate>[2]} [schemaOptions] - Optional Superstruct validation options\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {boolean} [resolverOptions.raw=false] - If true, returns raw values rather than validated results\n * @returns {Resolver<Infer<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = struct({\n *   name: string(),\n *   age: number()\n * });\n *\n * useForm({\n *   resolver: superstructResolver(schema)\n * });\n */\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Input, any>,\n  schemaOptions?: Parameters<typeof validate>[2],\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Input | Output> {\n  return (values: Input, _, options) => {\n    const result = validate(values, schema, schemaOptions);\n\n    if (result[0]) {\n      return {\n        values: {},\n        errors: toNestErrors(parseErrorSchema(result[0]), options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      values: resolverOptions.raw ? Object.assign({}, values) : result[1],\n      errors: {},\n    };\n  };\n}\n"],"names":["superstructResolver","schema","schemaOptions","resolverOptions","values","_","options","error","result","validate","errors","toNestErrors","failures","reduce","previous","path","join","message","type","shouldUseNativeValidation","validateFieldsNatively","raw","Object","assign"],"mappings":"+HA6DgBA,EACdC,EACAC,EACAC,GAIA,gBAJAA,IAAAA,EAEI,CAAE,GAEEC,SAAAA,EAAeC,EAAGC,GACxB,IAjEsBC,EAiEhBC,EAASC,EAASL,EAAQH,EAAQC,GAExC,OAAIM,EAAO,GACF,CACLJ,OAAQ,CAAA,EACRM,OAAQC,GAtEUJ,EAsEoBC,EAAO,GArE5CD,EAAMK,WAAWC,OACtB,SAACC,EAAUP,GACT,OAACO,EAASP,EAAMQ,KAAKC,KAAK,MAAQ,CAChCC,QAASV,EAAMU,QACfC,KAAMX,EAAMW,QACRJ,CAAQ,EAChB,CAAA,IA+DsDR,KAItDA,EAAQa,2BAA6BC,EAAuB,CAAA,EAAId,GAEzD,CACLF,OAAQD,EAAgBkB,IAAMC,OAAOC,OAAO,CAAE,EAAEnB,GAAUI,EAAO,GACjEE,OAAQ,CAAA,GAEZ,CACF"}

package/superstruct/dist/superstruct.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"superstruct.umd.js","sources":["../src/superstruct.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { FieldError, FieldValues, Resolver } from 'react-hook-form';\nimport { Infer, Struct, StructError, validate } from 'superstruct';\n\nfunction parseErrorSchema(error: StructError) {\n  return error.failures().reduce<Record<string, FieldError>>(\n    (previous, error) =>\n      (previous[error.path.join('.')] = {\n        message: error.message,\n        type: error.type,\n      }) && previous,\n    {},\n  );\n}\n\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Input, any>,\n  schemaOptions?: Parameters<typeof validate>[2],\n  resolverOptions?: {\n    raw?: false;\n  },\n): Resolver<Input, Context, Infer<typeof schema>>;\n\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Input, any>,\n  schemaOptions: Parameters<typeof validate>[2] | undefined,\n  resolverOptions: {\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Superstruct schema validation\n * @param {Struct<TFieldValues, any>} schema - The Superstruct schema to validate against\n * @param {Parameters<typeof validate>[2]} [schemaOptions] - Optional Superstruct validation options\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {boolean} [resolverOptions.raw=false] - If true, returns raw values rather than validated results\n * @returns {Resolver<Infer<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = struct({\n *   name: string(),\n *   age: number()\n * });\n *\n * useForm({\n *   resolver: superstructResolver(schema)\n * });\n */\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Input, any>,\n  schemaOptions?: Parameters<typeof validate>[2],\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Input | Output> {\n  return (values: Input, _, options) => {\n    const result = validate(values, schema, schemaOptions);\n\n    if (result[0]) {\n      return {\n        values: {},\n        errors: toNestErrors(parseErrorSchema(result[0]), options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      values: resolverOptions.raw ? Object.assign({}, values) : result[1],\n      errors: {},\n    };\n  };\n}\n"],"names":["schema","schemaOptions","resolverOptions","values","_","options","error","result","validate","errors","toNestErrors","failures","reduce","previous","path","join","message","type","shouldUseNativeValidation","validateFieldsNatively","raw","Object","assign"],"mappings":"qZAiDEA,EACAC,EACAC,GAIA,gBAJAA,IAAAA,EAEI,CAAE,GAEEC,SAAAA,EAAeC,EAAGC,GACxB,IApDsBC,EAoDhBC,EAASC,EAAAA,SAASL,EAAQH,EAAQC,GAExC,OAAIM,EAAO,GACF,CACLJ,OAAQ,CAAA,EACRM,OAAQC,EAAYA,cAzDFJ,EAyDoBC,EAAO,GAxD5CD,EAAMK,WAAWC,OACtB,SAACC,EAAUP,GACT,OAACO,EAASP,EAAMQ,KAAKC,KAAK,MAAQ,CAChCC,QAASV,EAAMU,QACfC,KAAMX,EAAMW,QACRJ,CAAQ,EAChB,CAAA,IAkDsDR,KAItDA,EAAQa,2BAA6BC,yBAAuB,CAAA,EAAId,GAEzD,CACLF,OAAQD,EAAgBkB,IAAMC,OAAOC,OAAO,CAAE,EAAEnB,GAAUI,EAAO,GACjEE,OAAQ,CAAA,GAEZ,CACF"}
+{"version":3,"file":"superstruct.umd.js","sources":["../src/superstruct.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { FieldError, FieldValues, Resolver } from 'react-hook-form';\nimport { Infer, Struct, StructError, validate } from 'superstruct';\n\nfunction parseErrorSchema(error: StructError) {\n  return error.failures().reduce<Record<string, FieldError>>(\n    (previous, error) =>\n      (previous[error.path.join('.')] = {\n        message: error.message,\n        type: error.type,\n      }) && previous,\n    {},\n  );\n}\n\n// This is required to correctly type the input of the returned function when coerce is true\n// superstruct does not store the input type of a schema alongside it\n// Infer<typeof schema> gives the output type of the coercion\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Output, any>,\n  schemaOptions: Omit<Parameters<typeof validate>[2], 'coerce'> & {\n    coerce: true;\n  },\n  resolverOptions?: {\n    raw?: boolean;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Input, any>,\n  schemaOptions?: Parameters<typeof validate>[2],\n  resolverOptions?: {\n    raw?: false;\n  },\n): Resolver<Input, Context, Infer<typeof schema>>;\n\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Input, any>,\n  schemaOptions: Parameters<typeof validate>[2] | undefined,\n  resolverOptions: {\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Superstruct schema validation\n * @param {Struct<TFieldValues, any>} schema - The Superstruct schema to validate against\n * @param {Parameters<typeof validate>[2]} [schemaOptions] - Optional Superstruct validation options\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {boolean} [resolverOptions.raw=false] - If true, returns raw values rather than validated results\n * @returns {Resolver<Infer<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = struct({\n *   name: string(),\n *   age: number()\n * });\n *\n * useForm({\n *   resolver: superstructResolver(schema)\n * });\n */\nexport function superstructResolver<Input extends FieldValues, Context, Output>(\n  schema: Struct<Input, any>,\n  schemaOptions?: Parameters<typeof validate>[2],\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Input | Output> {\n  return (values: Input, _, options) => {\n    const result = validate(values, schema, schemaOptions);\n\n    if (result[0]) {\n      return {\n        values: {},\n        errors: toNestErrors(parseErrorSchema(result[0]), options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      values: resolverOptions.raw ? Object.assign({}, values) : result[1],\n      errors: {},\n    };\n  };\n}\n"],"names":["schema","schemaOptions","resolverOptions","values","_","options","error","result","validate","errors","toNestErrors","failures","reduce","previous","path","join","message","type","shouldUseNativeValidation","validateFieldsNatively","raw","Object","assign"],"mappings":"qZA8DEA,EACAC,EACAC,GAIA,gBAJAA,IAAAA,EAEI,CAAE,GAEEC,SAAAA,EAAeC,EAAGC,GACxB,IAjEsBC,EAiEhBC,EAASC,EAAAA,SAASL,EAAQH,EAAQC,GAExC,OAAIM,EAAO,GACF,CACLJ,OAAQ,CAAA,EACRM,OAAQC,EAAYA,cAtEFJ,EAsEoBC,EAAO,GArE5CD,EAAMK,WAAWC,OACtB,SAACC,EAAUP,GACT,OAACO,EAASP,EAAMQ,KAAKC,KAAK,MAAQ,CAChCC,QAASV,EAAMU,QACfC,KAAMX,EAAMW,QACRJ,CAAQ,EAChB,CAAA,IA+DsDR,KAItDA,EAAQa,2BAA6BC,yBAAuB,CAAA,EAAId,GAEzD,CACLF,OAAQD,EAAgBkB,IAAMC,OAAOC,OAAO,CAAE,EAAEnB,GAAUI,EAAO,GACjEE,OAAQ,CAAA,GAEZ,CACF"}

package/superstruct/src/__tests__/superstruct.ts

@@ -1,3 +1,4 @@
+import { renderHook } from '@testing-library/react';
 import { Resolver, SubmitHandler, useForm } from 'react-hook-form';
 import * as s from 'superstruct';
 import { superstructResolver } from '..';
@@ -18,8 +19,9 @@ describe('superstructResolver', () => {
   it('should return values from superstructResolver with coerced values', async () => {
     const result = await superstructResolver(
       s.object({
-        id: s.coerce(s.number(), s.string(), (val) => String(val)),
+        id: s.coerce(s.string(), s.number(), (val) => String(val)),
       }),
+      { coerce: true },
     )({ id: 1 }, undefined, {
       fields,
       shouldUseNativeValidation,
@@ -64,9 +66,13 @@ describe('superstructResolver', () => {
   it('should correctly infer the output type from a superstruct schema for the handleSubmit function in useForm', () => {
     const schema = s.object({ id: s.number() });
 
-    const form = useForm({
-      resolver: superstructResolver(schema),
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        resolver: superstructResolver(schema, {}),
+      }),
+    );
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
 
@@ -82,11 +88,19 @@ describe('superstructResolver', () => {
       id: s.coerce(s.string(), s.number(), (val) => String(val)),
     });
 
-    const form = useForm({
-      resolver: superstructResolver(schema),
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        // With coerce, there is no way to infer the input type of the schema
+        resolver: superstructResolver<{ id: number }, unknown, { id: string }>(
+          schema,
+          { coerce: true },
+        ),
+      }),
+    );
 
-    expectTypeOf(form.watch('id')).toEqualTypeOf<string>();
+    expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
 
     expectTypeOf(form.handleSubmit).parameter(0).toEqualTypeOf<
       SubmitHandler<{

package/superstruct/src/superstruct.ts

@@ -13,6 +13,19 @@ function parseErrorSchema(error: StructError) {
   );
 }
 
+// This is required to correctly type the input of the returned function when coerce is true
+// superstruct does not store the input type of a schema alongside it
+// Infer<typeof schema> gives the output type of the coercion
+export function superstructResolver<Input extends FieldValues, Context, Output>(
+  schema: Struct<Output, any>,
+  schemaOptions: Omit<Parameters<typeof validate>[2], 'coerce'> & {
+    coerce: true;
+  },
+  resolverOptions?: {
+    raw?: boolean;
+  },
+): Resolver<Input, Context, Output>;
+
 export function superstructResolver<Input extends FieldValues, Context, Output>(
   schema: Struct<Input, any>,
   schemaOptions?: Parameters<typeof validate>[2],

package/typanion/src/__tests__/typanion.ts

@@ -1,3 +1,4 @@
+import { renderHook } from '@testing-library/react';
 import { SubmitHandler } from 'react-hook-form';
 import { useForm } from 'react-hook-form';
 import { Resolver } from 'react-hook-form';
@@ -51,9 +52,13 @@ describe('typanionResolver', () => {
   it('should correctly infer the output type from a typanion schema for the handleSubmit function in useForm', () => {
     const schema = t.isObject({ id: t.isNumber() });
 
-    const form = useForm({
-      resolver: typanionResolver(schema),
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        resolver: typanionResolver(schema),
+      }),
+    );
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
 

package/typebox/src/__tests__/typebox.ts

@@ -1,5 +1,6 @@
 import { Type } from '@sinclair/typebox';
 import { TypeCompiler } from '@sinclair/typebox/compiler';
+import { renderHook } from '@testing-library/react';
 import { Resolver, SubmitHandler, useForm } from 'react-hook-form';
 import { typeboxResolver } from '..';
 import { fields, invalidData, schema, validData } from './__fixtures__/data';
@@ -72,12 +73,16 @@ describe('typeboxResolver', () => {
   it('should correctly infer the output type from a typebox schema for the handleSubmit function in useForm', () => {
     const schema = Type.Object({ id: Type.Number() });
 
-    const form = useForm({
-      resolver: typeboxResolver(schema),
-      defaultValues: {
-        id: 3,
-      },
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        resolver: typeboxResolver(schema),
+        defaultValues: {
+          id: 3,
+        },
+      }),
+    );
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
 
@@ -91,12 +96,16 @@ describe('typeboxResolver', () => {
   it('should correctly infer the output type from a typebox schema with TypeCompiler for the handleSubmit function in useForm', () => {
     const typecheck = TypeCompiler.Compile(Type.Object({ id: Type.Number() }));
 
-    const form = useForm({
-      resolver: typeboxResolver(typecheck),
-      defaultValues: {
-        id: 3,
-      },
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        resolver: typeboxResolver(typecheck),
+        defaultValues: {
+          id: 3,
+        },
+      }),
+    );
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
 
@@ -114,12 +123,16 @@ describe('typeboxResolver', () => {
         .Encode((v) => Number.parseInt(v)),
     });
 
-    const form = useForm({
-      resolver: typeboxResolver(schema),
-      defaultValues: {
-        id: 3,
-      },
-    });
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm({
+        resolver: typeboxResolver(schema),
+        defaultValues: {
+          id: 3,
+        },
+      }),
+    );
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
 

package/typeschema/dist/typeschema.js

@@ -1,2 +1,2 @@
-var e=require("@hookform/resolvers"),r=require("react-hook-form");exports.typeschemaResolver=function(s,t,a){return void 0===a&&(a={}),function(t,i,o){try{var n=function(){if(u.issues){var s=function(e,s){for(var t=Object.assign([],e),a={};t.length;){var i=e[0];if(i.path){var o=i.path.join(".");if(a[o]||(a[o]={message:i.message,type:""}),s){var n=a[o].types,u=n&&n[""];a[o]=r.appendErrors(o,s,a,"",u?[].concat(u,i.message):i.message)}t.shift()}}return a}(u.issues,!o.shouldUseNativeValidation&&"all"===o.criteriaMode);return{values:{},errors:e.toNestErrors(s,o)}}return o.shouldUseNativeValidation&&e.validateFieldsNatively({},o),{values:a.raw?Object.assign({},t):u.value,errors:{}}},u=s["~standard"].validate(t),v=function(){if(u instanceof Promise)return Promise.resolve(u).then(function(e){u=e})}();return Promise.resolve(v&&v.then?v.then(n):n())}catch(e){return Promise.reject(e)}}};
+var r=require("@hookform/resolvers"),e=require("react-hook-form");function t(r,e){(null==e||e>r.length)&&(e=r.length);for(var t=0,n=Array(e);t<e;t++)n[t]=r[t];return n}exports.typeschemaResolver=function(n,a,o){return void 0===o&&(o={}),function(a,i,s){try{var u=function(){if(l.issues){var n=function(r,n){for(var a,o={},i=function(r){var e="undefined"!=typeof Symbol&&r[Symbol.iterator]||r["@@iterator"];if(e)return(e=e.call(r)).next.bind(e);if(Array.isArray(r)||(e=function(r,e){if(r){if("string"==typeof r)return t(r,e);var n={}.toString.call(r).slice(8,-1);return"Object"===n&&r.constructor&&(n=r.constructor.name),"Map"===n||"Set"===n?Array.from(r):"Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?t(r,e):void 0}}(r))){e&&(r=e);var n=0;return function(){return n>=r.length?{done:!0}:{done:!1,value:r[n++]}}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}(Object.assign([],r));!(a=i()).done;){var s=a.value;if(s.path){var u=s.path.join(".");if(o[u]||(o[u]={message:s.message,type:""}),n){var l=o[u].types,c=l&&l[""];o[u]=e.appendErrors(u,n,o,"",c?[].concat(c,s.message):s.message)}}}return o}(l.issues,!s.shouldUseNativeValidation&&"all"===s.criteriaMode);return{values:{},errors:r.toNestErrors(n,s)}}return s.shouldUseNativeValidation&&r.validateFieldsNatively({},s),{values:o.raw?Object.assign({},a):l.value,errors:{}}},l=n["~standard"].validate(a),c=function(){if(l instanceof Promise)return Promise.resolve(l).then(function(r){l=r})}();return Promise.resolve(c&&c.then?c.then(u):u())}catch(r){return Promise.reject(r)}}};
 //# sourceMappingURL=typeschema.js.map