@hookform/resolvers 4.1.3 → 5.0.1

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

@@ -1,3 +1,5 @@
+import { Resolver, SubmitHandler, useForm } from 'react-hook-form';
+import { z } from 'zod';
 import { standardSchemaResolver } from '..';
 import {
   customSchema,
@@ -49,7 +51,7 @@ describe('standardSchemaResolver', () => {
   it('should return values from standardSchemaResolver when validation pass & raw=true', async () => {
     const validateSpy = vi.spyOn(schema['~standard'], 'validate');
 
-    const result = await standardSchemaResolver(schema, {
+    const result = await standardSchemaResolver(schema, undefined, {
       raw: true,
     })(validData, undefined, {
       fields,
@@ -71,4 +73,79 @@ describe('standardSchemaResolver', () => {
 
     expect(result).toMatchSnapshot();
   });
+
+  /**
+   * Type inference tests
+   */
+  it('should correctly infer the output type from a standardSchema schema', () => {
+    const resolver = standardSchemaResolver(z.object({ id: z.number() }));
+
+    expectTypeOf(resolver).toEqualTypeOf<
+      Resolver<{ id: number }, unknown, { id: number }>
+    >();
+  });
+
+  it('should correctly infer the output type from a standardSchema schema using a transform', () => {
+    const resolver = standardSchemaResolver(
+      z.object({ id: z.number().transform((val) => String(val)) }),
+    );
+
+    expectTypeOf(resolver).toEqualTypeOf<
+      Resolver<{ id: number }, unknown, { id: string }>
+    >();
+  });
+
+  it('should correctly infer the output type from a standardSchema schema when a different input type is specified', () => {
+    const schema = z.object({ id: z.number() }).transform(({ id }) => {
+      return { id: String(id) };
+    });
+
+    const resolver = standardSchemaResolver<
+      { id: number },
+      any,
+      z.output<typeof schema>
+    >(schema);
+
+    expectTypeOf(resolver).toEqualTypeOf<
+      Resolver<{ id: number }, any, { id: string }>
+    >();
+  });
+
+  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,
+      },
+    });
+
+    expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
+
+    expectTypeOf(form.handleSubmit).parameter(0).toEqualTypeOf<
+      SubmitHandler<{
+        id: number;
+      }>
+    >();
+  });
+
+  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,
+      },
+    });
+
+    expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
+
+    expectTypeOf(form.handleSubmit).parameter(0).toEqualTypeOf<
+      SubmitHandler<{
+        id: string;
+      }>
+    >();
+  });
 });

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

@@ -3,7 +3,7 @@ import { StandardSchemaV1 } from '@standard-schema/spec';
 import { getDotPath } from '@standard-schema/utils';
 import { FieldError, FieldValues, Resolver } from 'react-hook-form';
 
-function parseIssues(
+function parseErrorSchema(
   issues: readonly StandardSchemaV1.Issue[],
   validateAllFieldCriteria: boolean,
 ) {
@@ -32,6 +32,30 @@ function parseIssues(
   return errors;
 }
 
+export function standardSchemaResolver<
+  Input extends FieldValues,
+  Context,
+  Output,
+>(
+  schema: StandardSchemaV1<Input, Output>,
+  _schemaOptions?: never,
+  resolverOptions?: {
+    raw?: false;
+  },
+): Resolver<Input, Context, Output>;
+
+export function standardSchemaResolver<
+  Input extends FieldValues,
+  Context,
+  Output,
+>(
+  schema: StandardSchemaV1<Input, Output>,
+  _schemaOptions: never | undefined,
+  resolverOptions: {
+    raw: true;
+  },
+): Resolver<Input, Context, Input>;
+
 /**
  * Creates a resolver for react-hook-form that validates data using a Standard Schema.
  *
@@ -53,13 +77,16 @@ function parseIssues(
  * ```
  */
 export function standardSchemaResolver<
-  Schema extends StandardSchemaV1<FieldValues>,
+  Input extends FieldValues,
+  Context,
+  Output,
 >(
-  schema: Schema,
+  schema: StandardSchemaV1<Input, Output>,
+  _schemaOptions?: never,
   resolverOptions: {
     raw?: boolean;
   } = {},
-): Resolver<StandardSchemaV1.InferOutput<Schema>> {
+): Resolver<Input, Context, Output | Input> {
   return async (values, _, options) => {
     let result = schema['~standard'].validate(values);
     if (result instanceof Promise) {
@@ -67,7 +94,7 @@ export function standardSchemaResolver<
     }
 
     if (result.issues) {
-      const errors = parseIssues(
+      const errors = parseErrorSchema(
         result.issues,
         !options.shouldUseNativeValidation && options.criteriaMode === 'all',
       );

package/superstruct/dist/superstruct.d.ts

@@ -1,22 +1,8 @@
 import { FieldValues, Resolver } from 'react-hook-form';
 import { Infer, Struct, validate } from 'superstruct';
-/**
- * Creates a resolver for react-hook-form using Superstruct schema validation
- * @param {Struct<TFieldValues, any>} schema - The Superstruct schema to validate against
- * @param {Parameters<typeof validate>[2]} [schemaOptions] - Optional Superstruct validation options
- * @param {Object} resolverOptions - Additional resolver configuration
- * @param {boolean} [resolverOptions.raw=false] - If true, returns raw values rather than validated results
- * @returns {Resolver<Infer<typeof schema>>} A resolver function compatible with react-hook-form
- * @example
- * const schema = struct({
- *   name: string(),
- *   age: number()
- * });
- *
- * useForm({
- *   resolver: superstructResolver(schema)
- * });
- */
-export declare function superstructResolver<TFieldValues extends FieldValues>(schema: Struct<TFieldValues, any>, schemaOptions?: Parameters<typeof validate>[2], resolverOptions?: {
-    raw?: boolean;
-}): Resolver<Infer<typeof schema>>;
+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>>;
+export declare function superstructResolver<Input extends FieldValues, Context, Output>(schema: Struct<Input, any>, schemaOptions: Parameters<typeof validate>[2] | undefined, resolverOptions: {
+    raw: true;
+}): Resolver<Input, Context, Input>;

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\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<TFieldValues extends FieldValues>(\n  schema: Struct<TFieldValues, any>,\n  schemaOptions?: Parameters<typeof validate>[2],\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Infer<typeof schema>> {\n  return (values, _, 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":"mGAiCEA,EACAC,EACAC,GAIA,gBAJAA,IAAAA,EAEI,CAAE,GAEEC,SAAAA,EAAQC,EAAGC,GACjB,IApCsBC,EAoChBC,EAASC,EAAAA,SAASL,EAAQH,EAAQC,GAExC,OAAIM,EAAO,GACF,CACLJ,OAAQ,CAAA,EACRM,OAAQC,EAAYA,cAzCFJ,EAyCoBC,EAAO,GAxC5CD,EAAMK,WAAWC,OACtB,SAACC,EAAUP,GACT,OAACO,EAASP,EAAMQ,KAAKC,KAAK,MAAQ,CAChCC,QAASV,EAAMU,QACfC,KAAMX,EAAMW,QACRJ,CAAQ,EAChB,CAAA,IAkCsDR,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\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"}

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\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<TFieldValues extends FieldValues>(\n  schema: Struct<TFieldValues, any>,\n  schemaOptions?: Parameters<typeof validate>[2],\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Infer<typeof schema>> {\n  return (values, _, 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":"sHAgCgB,SAAAA,EACdC,EACAC,EACAC,EAEI,CAAE,GAEN,MAAO,CAACC,EAAQC,EAAGC,KACjB,MAAMC,EAASC,EAASJ,EAAQH,EAAQC,GAExC,OAAIK,EAAO,GACF,CACLH,OAAQ,CAAA,EACRK,OAAQC,GAzCUC,EAyCoBJ,EAAO,GAxC5CI,EAAMC,WAAWC,OACtB,CAACC,EAAUH,KACRG,EAASH,EAAMI,KAAKC,KAAK,MAAQ,CAChCC,QAASN,EAAMM,QACfC,KAAMP,EAAMO,QACRJ,EACR,KAkCsDR,KAItDA,EAAQa,2BAA6BC,EAAuB,GAAId,GAEzD,CACLF,OAAQD,EAAgBkB,IAAMC,OAAOC,OAAO,CAAA,EAAInB,GAAUG,EAAO,GACjEE,OAAQ,CAAA,IAjDd,IAA0BE,EAoD1B"}
+{"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"}

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\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<TFieldValues extends FieldValues>(\n  schema: Struct<TFieldValues, any>,\n  schemaOptions?: Parameters<typeof validate>[2],\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Infer<typeof schema>> {\n  return (values, _, 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":"+HAgCgBA,EACdC,EACAC,EACAC,GAIA,gBAJAA,IAAAA,EAEI,CAAE,GAEEC,SAAAA,EAAQC,EAAGC,GACjB,IApCsBC,EAoChBC,EAASC,EAASL,EAAQH,EAAQC,GAExC,OAAIM,EAAO,GACF,CACLJ,OAAQ,CAAA,EACRM,OAAQC,GAzCUJ,EAyCoBC,EAAO,GAxC5CD,EAAMK,WAAWC,OACtB,SAACC,EAAUP,GACT,OAACO,EAASP,EAAMQ,KAAKC,KAAK,MAAQ,CAChCC,QAASV,EAAMU,QACfC,KAAMX,EAAMW,QACRJ,CAAQ,EAChB,CAAA,IAkCsDR,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\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"}

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\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<TFieldValues extends FieldValues>(\n  schema: Struct<TFieldValues, any>,\n  schemaOptions?: Parameters<typeof validate>[2],\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Infer<typeof schema>> {\n  return (values, _, 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":"qZAiCEA,EACAC,EACAC,GAIA,gBAJAA,IAAAA,EAEI,CAAE,GAEEC,SAAAA,EAAQC,EAAGC,GACjB,IApCsBC,EAoChBC,EAASC,EAAAA,SAASL,EAAQH,EAAQC,GAExC,OAAIM,EAAO,GACF,CACLJ,OAAQ,CAAA,EACRM,OAAQC,EAAYA,cAzCFJ,EAyCoBC,EAAO,GAxC5CD,EAAMK,WAAWC,OACtB,SAACC,EAAUP,GACT,OAACO,EAASP,EAAMQ,KAAKC,KAAK,MAAQ,CAChCC,QAASV,EAAMU,QACfC,KAAMX,EAAMW,QACRJ,CAAQ,EAChB,CAAA,IAkCsDR,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\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"}

package/superstruct/package.json

@@ -11,7 +11,7 @@
   "types": "dist/index.d.ts",
   "license": "MIT",
   "peerDependencies": {
-    "react-hook-form": "^7.0.0",
+    "react-hook-form": "^7.55.0",
     "@hookform/resolvers": "^2.0.0",
     "superstruct": ">=0.12.0"
   }

package/superstruct/src/__tests__/superstruct.ts

@@ -1,3 +1,5 @@
+import { Resolver, SubmitHandler, useForm } from 'react-hook-form';
+import * as s from 'superstruct';
 import { superstructResolver } from '..';
 import { fields, invalidData, schema, validData } from './__fixtures__/data';
 
@@ -13,6 +15,19 @@ describe('superstructResolver', () => {
     expect(result).toEqual({ errors: {}, values: validData });
   });
 
+  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: 1 }, undefined, {
+      fields,
+      shouldUseNativeValidation,
+    });
+
+    expect(result).toEqual({ errors: {}, values: { id: '1' } });
+  });
+
   it('should return a single error from superstructResolver when validation fails', async () => {
     const result = await superstructResolver(schema)(invalidData, undefined, {
       fields,
@@ -34,4 +49,49 @@ describe('superstructResolver', () => {
 
     expect(result).toEqual({ errors: {}, values: validData });
   });
+
+  /**
+   * Type inference tests
+   */
+  it('should correctly infer the output type from a superstruct schema', () => {
+    const resolver = superstructResolver(s.object({ id: s.number() }));
+
+    expectTypeOf(resolver).toEqualTypeOf<
+      Resolver<{ id: number }, unknown, { id: number }>
+    >();
+  });
+
+  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),
+    });
+
+    expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
+
+    expectTypeOf(form.handleSubmit).parameter(0).toEqualTypeOf<
+      SubmitHandler<{
+        id: number;
+      }>
+    >();
+  });
+
+  it('should correctly infer the output type from a superstruct schema with a transform for the handleSubmit function in useForm', () => {
+    const schema = s.object({
+      id: s.coerce(s.string(), s.number(), (val) => String(val)),
+    });
+
+    const form = useForm({
+      resolver: superstructResolver(schema),
+    });
+
+    expectTypeOf(form.watch('id')).toEqualTypeOf<string>();
+
+    expectTypeOf(form.handleSubmit).parameter(0).toEqualTypeOf<
+      SubmitHandler<{
+        id: string;
+      }>
+    >();
+  });
 });

package/superstruct/src/superstruct.ts

@@ -13,6 +13,22 @@ function parseErrorSchema(error: StructError) {
   );
 }
 
+export 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>>;
+
+export function superstructResolver<Input extends FieldValues, Context, Output>(
+  schema: Struct<Input, any>,
+  schemaOptions: Parameters<typeof validate>[2] | undefined,
+  resolverOptions: {
+    raw: true;
+  },
+): Resolver<Input, Context, Input>;
+
 /**
  * Creates a resolver for react-hook-form using Superstruct schema validation
  * @param {Struct<TFieldValues, any>} schema - The Superstruct schema to validate against
@@ -30,14 +46,14 @@ function parseErrorSchema(error: StructError) {
  *   resolver: superstructResolver(schema)
  * });
  */
-export function superstructResolver<TFieldValues extends FieldValues>(
-  schema: Struct<TFieldValues, any>,
+export function superstructResolver<Input extends FieldValues, Context, Output>(
+  schema: Struct<Input, any>,
   schemaOptions?: Parameters<typeof validate>[2],
   resolverOptions: {
     raw?: boolean;
   } = {},
-): Resolver<Infer<typeof schema>> {
-  return (values, _, options) => {
+): Resolver<Input, Context, Input | Output> {
+  return (values: Input, _, options) => {
     const result = validate(values, schema, schemaOptions);
 
     if (result[0]) {

package/typanion/dist/typanion.d.ts

@@ -1,18 +1,10 @@
 import type { FieldValues, Resolver } from 'react-hook-form';
 import * as t from 'typanion';
-/**
- * Creates a resolver for react-hook-form using Typanion schema validation
- * @param {t.StrictValidator<TFieldValues, TFieldValues>} schema - The Typanion schema to validate against
- * @param {Pick<t.ValidationState, 'coercions' | 'coercion'>} [schemaOptions] - Optional Typanion validation options
- * @returns {Resolver<t.InferType<typeof schema>>} A resolver function compatible with react-hook-form
- * @example
- * const schema = t.isObject({
- *   name: t.isString(),
- *   age: t.isInteger()
- * });
- *
- * useForm({
- *   resolver: typanionResolver(schema)
- * });
- */
-export declare function typanionResolver<TFieldValues extends FieldValues>(schema: t.StrictValidator<TFieldValues, TFieldValues>, schemaOptions?: Pick<t.ValidationState, 'coercions' | 'coercion'>): Resolver<t.InferType<typeof schema>>;
+export declare function typanionResolver<Input extends FieldValues, Context, Output>(schema: t.StrictValidator<Input, Input>, schemaOptions?: Pick<t.ValidationState, 'coercions' | 'coercion'>, resolverOptions?: {
+    mode?: 'async' | 'sync';
+    raw?: false;
+}): Resolver<Input, Context, t.InferType<typeof schema>>;
+export declare function typanionResolver<Input extends FieldValues, Context, Output>(schema: t.StrictValidator<Input, Input>, schemaOptions: Pick<t.ValidationState, 'coercions' | 'coercion'> | undefined, resolverOptions: {
+    mode?: 'async' | 'sync';
+    raw: true;
+}): Resolver<Input, Context, Input>;

package/typanion/dist/typanion.js.map

@@ -1 +1 @@
-{"version":3,"file":"typanion.js","sources":["../src/typanion.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport type {\n  FieldError,\n  FieldErrors,\n  FieldValues,\n  Resolver,\n} from 'react-hook-form';\nimport * as t from 'typanion';\n\nfunction parseErrors(errors: string[], parsedErrors: FieldErrors = {}) {\n  return errors.reduce((acc, error) => {\n    const fieldIndex = error.indexOf(':');\n\n    const field = error.slice(1, fieldIndex);\n    const message = error.slice(fieldIndex + 1).trim();\n\n    acc[field] = {\n      message,\n    } as FieldError;\n\n    return acc;\n  }, parsedErrors);\n}\n\n/**\n * Creates a resolver for react-hook-form using Typanion schema validation\n * @param {t.StrictValidator<TFieldValues, TFieldValues>} schema - The Typanion schema to validate against\n * @param {Pick<t.ValidationState, 'coercions' | 'coercion'>} [schemaOptions] - Optional Typanion validation options\n * @returns {Resolver<t.InferType<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = t.isObject({\n *   name: t.isString(),\n *   age: t.isInteger()\n * });\n *\n * useForm({\n *   resolver: typanionResolver(schema)\n * });\n */\nexport function typanionResolver<TFieldValues extends FieldValues>(\n  schema: t.StrictValidator<TFieldValues, TFieldValues>,\n  schemaOptions: Pick<t.ValidationState, 'coercions' | 'coercion'> = {},\n): Resolver<t.InferType<typeof schema>> {\n  return (values, _, options) => {\n    const rawErrors: string[] = [];\n    const isValid = schema(\n      values,\n      Object.assign(\n        {},\n        {\n          errors: rawErrors,\n        },\n        schemaOptions,\n      ),\n    );\n    const parsedErrors = parseErrors(rawErrors);\n\n    if (isValid) {\n      options.shouldUseNativeValidation &&\n        validateFieldsNatively(parsedErrors, options);\n\n      return { values, errors: {} };\n    }\n\n    return { values: {}, errors: toNestErrors(parsedErrors, options) };\n  };\n}\n"],"names":["schema","schemaOptions","values","_","options","rawErrors","isValid","Object","assign","errors","parsedErrors","reduce","acc","error","fieldIndex","indexOf","field","slice","message","trim","parseErrors","shouldUseNativeValidation","validateFieldsNatively","toNestErrors"],"mappings":"8DAuCgB,SACdA,EACAC,GAEA,YAFAA,IAAAA,IAAAA,EAAmE,CAAE,GAE7DC,SAAAA,EAAQC,EAAGC,GACjB,IAAMC,EAAsB,GACtBC,EAAUN,EACdE,EACAK,OAAOC,OACL,CAAE,EACF,CACEC,OAAQJ,GAEVJ,IAGES,EA9CV,SAAqBD,EAAkBC,GACrC,gBADqCA,IAAAA,EAA4B,IAC1DD,EAAOE,OAAO,SAACC,EAAKC,GACzB,IAAMC,EAAaD,EAAME,QAAQ,KAE3BC,EAAQH,EAAMI,MAAM,EAAGH,GACvBI,EAAUL,EAAMI,MAAMH,EAAa,GAAGK,OAM5C,OAJAP,EAAII,GAAS,CACXE,QAAAA,GAGKN,CACT,EAAGF,EACL,CAiCyBU,CAAYf,GAEjC,OAAIC,GACFF,EAAQiB,2BACNC,EAAAA,uBAAuBZ,EAAcN,GAEhC,CAAEF,OAAAA,EAAQO,OAAQ,CAAA,IAGpB,CAAEP,OAAQ,GAAIO,OAAQc,EAAYA,aAACb,EAAcN,GAC1D,CACF"}
+{"version":3,"file":"typanion.js","sources":["../src/typanion.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport type {\n  FieldError,\n  FieldErrors,\n  FieldValues,\n  Resolver,\n} from 'react-hook-form';\nimport * as t from 'typanion';\n\nfunction parseErrors(errors: string[], parsedErrors: FieldErrors = {}) {\n  return errors.reduce((acc, error) => {\n    const fieldIndex = error.indexOf(':');\n\n    const field = error.slice(1, fieldIndex);\n    const message = error.slice(fieldIndex + 1).trim();\n\n    acc[field] = {\n      message,\n    } as FieldError;\n\n    return acc;\n  }, parsedErrors);\n}\n\nexport function typanionResolver<Input extends FieldValues, Context, Output>(\n  schema: t.StrictValidator<Input, Input>,\n  schemaOptions?: Pick<t.ValidationState, 'coercions' | 'coercion'>,\n  resolverOptions?: {\n    mode?: 'async' | 'sync';\n    raw?: false;\n  },\n): Resolver<Input, Context, t.InferType<typeof schema>>;\n\nexport function typanionResolver<Input extends FieldValues, Context, Output>(\n  schema: t.StrictValidator<Input, Input>,\n  schemaOptions: Pick<t.ValidationState, 'coercions' | 'coercion'> | undefined,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Typanion schema validation\n * @param {t.StrictValidator<TFieldValues, TFieldValues>} schema - The Typanion schema to validate against\n * @param {Pick<t.ValidationState, 'coercions' | 'coercion'>} [schemaOptions] - Optional Typanion validation options\n * @returns {Resolver<t.InferType<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = t.isObject({\n *   name: t.isString(),\n *   age: t.isInteger()\n * });\n *\n * useForm({\n *   resolver: typanionResolver(schema)\n * });\n */\nexport function typanionResolver<Input extends FieldValues, Context, Output>(\n  schema: t.StrictValidator<Input, Input>,\n  schemaOptions: Pick<t.ValidationState, 'coercions' | 'coercion'> = {},\n): Resolver<Input, Context, Output | Input> {\n  return (values: Input, _, options) => {\n    const rawErrors: string[] = [];\n    const isValid = schema(\n      values,\n      Object.assign(\n        {},\n        {\n          errors: rawErrors,\n        },\n        schemaOptions,\n      ),\n    );\n    const parsedErrors = parseErrors(rawErrors);\n\n    if (isValid) {\n      options.shouldUseNativeValidation &&\n        validateFieldsNatively(parsedErrors, options);\n\n      return { values, errors: {} };\n    }\n\n    return { values: {}, errors: toNestErrors(parsedErrors, options) };\n  };\n}\n"],"names":["schema","schemaOptions","values","_","options","rawErrors","isValid","Object","assign","errors","parsedErrors","reduce","acc","error","fieldIndex","indexOf","field","slice","message","trim","parseErrors","shouldUseNativeValidation","validateFieldsNatively","toNestErrors"],"mappings":"8DAyDgB,SACdA,EACAC,GAEA,YAFAA,IAAAA,IAAAA,EAAmE,CAAE,GAE7DC,SAAAA,EAAeC,EAAGC,GACxB,IAAMC,EAAsB,GACtBC,EAAUN,EACdE,EACAK,OAAOC,OACL,CAAE,EACF,CACEC,OAAQJ,GAEVJ,IAGES,EAhEV,SAAqBD,EAAkBC,GACrC,gBADqCA,IAAAA,EAA4B,IAC1DD,EAAOE,OAAO,SAACC,EAAKC,GACzB,IAAMC,EAAaD,EAAME,QAAQ,KAE3BC,EAAQH,EAAMI,MAAM,EAAGH,GACvBI,EAAUL,EAAMI,MAAMH,EAAa,GAAGK,OAM5C,OAJAP,EAAII,GAAS,CACXE,QAAAA,GAGKN,CACT,EAAGF,EACL,CAmDyBU,CAAYf,GAEjC,OAAIC,GACFF,EAAQiB,2BACNC,EAAAA,uBAAuBZ,EAAcN,GAEhC,CAAEF,OAAAA,EAAQO,OAAQ,CAAA,IAGpB,CAAEP,OAAQ,GAAIO,OAAQc,EAAYA,aAACb,EAAcN,GAC1D,CACF"}

package/typanion/dist/typanion.modern.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"typanion.modern.mjs","sources":["../src/typanion.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport type {\n  FieldError,\n  FieldErrors,\n  FieldValues,\n  Resolver,\n} from 'react-hook-form';\nimport * as t from 'typanion';\n\nfunction parseErrors(errors: string[], parsedErrors: FieldErrors = {}) {\n  return errors.reduce((acc, error) => {\n    const fieldIndex = error.indexOf(':');\n\n    const field = error.slice(1, fieldIndex);\n    const message = error.slice(fieldIndex + 1).trim();\n\n    acc[field] = {\n      message,\n    } as FieldError;\n\n    return acc;\n  }, parsedErrors);\n}\n\n/**\n * Creates a resolver for react-hook-form using Typanion schema validation\n * @param {t.StrictValidator<TFieldValues, TFieldValues>} schema - The Typanion schema to validate against\n * @param {Pick<t.ValidationState, 'coercions' | 'coercion'>} [schemaOptions] - Optional Typanion validation options\n * @returns {Resolver<t.InferType<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = t.isObject({\n *   name: t.isString(),\n *   age: t.isInteger()\n * });\n *\n * useForm({\n *   resolver: typanionResolver(schema)\n * });\n */\nexport function typanionResolver<TFieldValues extends FieldValues>(\n  schema: t.StrictValidator<TFieldValues, TFieldValues>,\n  schemaOptions: Pick<t.ValidationState, 'coercions' | 'coercion'> = {},\n): Resolver<t.InferType<typeof schema>> {\n  return (values, _, options) => {\n    const rawErrors: string[] = [];\n    const isValid = schema(\n      values,\n      Object.assign(\n        {},\n        {\n          errors: rawErrors,\n        },\n        schemaOptions,\n      ),\n    );\n    const parsedErrors = parseErrors(rawErrors);\n\n    if (isValid) {\n      options.shouldUseNativeValidation &&\n        validateFieldsNatively(parsedErrors, options);\n\n      return { values, errors: {} };\n    }\n\n    return { values: {}, errors: toNestErrors(parsedErrors, options) };\n  };\n}\n"],"names":["typanionResolver","schema","schemaOptions","values","_","options","rawErrors","isValid","Object","assign","errors","parsedErrors","reduce","acc","error","fieldIndex","indexOf","field","slice","message","trim","parseErrors","shouldUseNativeValidation","validateFieldsNatively","toNestErrors"],"mappings":"+EAuCgB,SAAAA,EACdC,EACAC,EAAmE,IAEnE,MAAO,CAACC,EAAQC,EAAGC,KACjB,MAAMC,EAAsB,GACtBC,EAAUN,EACdE,EACAK,OAAOC,OACL,CAAA,EACA,CACEC,OAAQJ,GAEVJ,IAGES,EA9CV,SAAqBD,EAAkBC,EAA4B,CAAE,GACnE,OAAOD,EAAOE,OAAO,CAACC,EAAKC,KACzB,MAAMC,EAAaD,EAAME,QAAQ,KAE3BC,EAAQH,EAAMI,MAAM,EAAGH,GACvBI,EAAUL,EAAMI,MAAMH,EAAa,GAAGK,OAM5C,OAJAP,EAAII,GAAS,CACXE,WAGKN,GACNF,EACL,CAiCyBU,CAAYf,GAEjC,OAAIC,GACFF,EAAQiB,2BACNC,EAAuBZ,EAAcN,GAEhC,CAAEF,SAAQO,OAAQ,KAGpB,CAAEP,OAAQ,CAAE,EAAEO,OAAQc,EAAab,EAAcN,IAE5D"}
+{"version":3,"file":"typanion.modern.mjs","sources":["../src/typanion.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport type {\n  FieldError,\n  FieldErrors,\n  FieldValues,\n  Resolver,\n} from 'react-hook-form';\nimport * as t from 'typanion';\n\nfunction parseErrors(errors: string[], parsedErrors: FieldErrors = {}) {\n  return errors.reduce((acc, error) => {\n    const fieldIndex = error.indexOf(':');\n\n    const field = error.slice(1, fieldIndex);\n    const message = error.slice(fieldIndex + 1).trim();\n\n    acc[field] = {\n      message,\n    } as FieldError;\n\n    return acc;\n  }, parsedErrors);\n}\n\nexport function typanionResolver<Input extends FieldValues, Context, Output>(\n  schema: t.StrictValidator<Input, Input>,\n  schemaOptions?: Pick<t.ValidationState, 'coercions' | 'coercion'>,\n  resolverOptions?: {\n    mode?: 'async' | 'sync';\n    raw?: false;\n  },\n): Resolver<Input, Context, t.InferType<typeof schema>>;\n\nexport function typanionResolver<Input extends FieldValues, Context, Output>(\n  schema: t.StrictValidator<Input, Input>,\n  schemaOptions: Pick<t.ValidationState, 'coercions' | 'coercion'> | undefined,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Typanion schema validation\n * @param {t.StrictValidator<TFieldValues, TFieldValues>} schema - The Typanion schema to validate against\n * @param {Pick<t.ValidationState, 'coercions' | 'coercion'>} [schemaOptions] - Optional Typanion validation options\n * @returns {Resolver<t.InferType<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = t.isObject({\n *   name: t.isString(),\n *   age: t.isInteger()\n * });\n *\n * useForm({\n *   resolver: typanionResolver(schema)\n * });\n */\nexport function typanionResolver<Input extends FieldValues, Context, Output>(\n  schema: t.StrictValidator<Input, Input>,\n  schemaOptions: Pick<t.ValidationState, 'coercions' | 'coercion'> = {},\n): Resolver<Input, Context, Output | Input> {\n  return (values: Input, _, options) => {\n    const rawErrors: string[] = [];\n    const isValid = schema(\n      values,\n      Object.assign(\n        {},\n        {\n          errors: rawErrors,\n        },\n        schemaOptions,\n      ),\n    );\n    const parsedErrors = parseErrors(rawErrors);\n\n    if (isValid) {\n      options.shouldUseNativeValidation &&\n        validateFieldsNatively(parsedErrors, options);\n\n      return { values, errors: {} };\n    }\n\n    return { values: {}, errors: toNestErrors(parsedErrors, options) };\n  };\n}\n"],"names":["typanionResolver","schema","schemaOptions","values","_","options","rawErrors","isValid","Object","assign","errors","parsedErrors","reduce","acc","error","fieldIndex","indexOf","field","slice","message","trim","parseErrors","shouldUseNativeValidation","validateFieldsNatively","toNestErrors"],"mappings":"+EAyDgB,SAAAA,EACdC,EACAC,EAAmE,IAEnE,MAAO,CAACC,EAAeC,EAAGC,KACxB,MAAMC,EAAsB,GACtBC,EAAUN,EACdE,EACAK,OAAOC,OACL,CAAA,EACA,CACEC,OAAQJ,GAEVJ,IAGES,EAhEV,SAAqBD,EAAkBC,EAA4B,CAAE,GACnE,OAAOD,EAAOE,OAAO,CAACC,EAAKC,KACzB,MAAMC,EAAaD,EAAME,QAAQ,KAE3BC,EAAQH,EAAMI,MAAM,EAAGH,GACvBI,EAAUL,EAAMI,MAAMH,EAAa,GAAGK,OAM5C,OAJAP,EAAII,GAAS,CACXE,WAGKN,GACNF,EACL,CAmDyBU,CAAYf,GAEjC,OAAIC,GACFF,EAAQiB,2BACNC,EAAuBZ,EAAcN,GAEhC,CAAEF,SAAQO,OAAQ,KAGpB,CAAEP,OAAQ,CAAE,EAAEO,OAAQc,EAAab,EAAcN,IAE5D"}

package/typanion/dist/typanion.module.js.map

@@ -1 +1 @@
-{"version":3,"file":"typanion.module.js","sources":["../src/typanion.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport type {\n  FieldError,\n  FieldErrors,\n  FieldValues,\n  Resolver,\n} from 'react-hook-form';\nimport * as t from 'typanion';\n\nfunction parseErrors(errors: string[], parsedErrors: FieldErrors = {}) {\n  return errors.reduce((acc, error) => {\n    const fieldIndex = error.indexOf(':');\n\n    const field = error.slice(1, fieldIndex);\n    const message = error.slice(fieldIndex + 1).trim();\n\n    acc[field] = {\n      message,\n    } as FieldError;\n\n    return acc;\n  }, parsedErrors);\n}\n\n/**\n * Creates a resolver for react-hook-form using Typanion schema validation\n * @param {t.StrictValidator<TFieldValues, TFieldValues>} schema - The Typanion schema to validate against\n * @param {Pick<t.ValidationState, 'coercions' | 'coercion'>} [schemaOptions] - Optional Typanion validation options\n * @returns {Resolver<t.InferType<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = t.isObject({\n *   name: t.isString(),\n *   age: t.isInteger()\n * });\n *\n * useForm({\n *   resolver: typanionResolver(schema)\n * });\n */\nexport function typanionResolver<TFieldValues extends FieldValues>(\n  schema: t.StrictValidator<TFieldValues, TFieldValues>,\n  schemaOptions: Pick<t.ValidationState, 'coercions' | 'coercion'> = {},\n): Resolver<t.InferType<typeof schema>> {\n  return (values, _, options) => {\n    const rawErrors: string[] = [];\n    const isValid = schema(\n      values,\n      Object.assign(\n        {},\n        {\n          errors: rawErrors,\n        },\n        schemaOptions,\n      ),\n    );\n    const parsedErrors = parseErrors(rawErrors);\n\n    if (isValid) {\n      options.shouldUseNativeValidation &&\n        validateFieldsNatively(parsedErrors, options);\n\n      return { values, errors: {} };\n    }\n\n    return { values: {}, errors: toNestErrors(parsedErrors, options) };\n  };\n}\n"],"names":["typanionResolver","schema","schemaOptions","values","_","options","rawErrors","isValid","Object","assign","errors","parsedErrors","reduce","acc","error","fieldIndex","indexOf","field","slice","message","trim","parseErrors","shouldUseNativeValidation","validateFieldsNatively","toNestErrors"],"mappings":"+EAuCgB,SAAAA,EACdC,EACAC,GAEA,YAFAA,IAAAA,IAAAA,EAAmE,CAAE,GAE7DC,SAAAA,EAAQC,EAAGC,GACjB,IAAMC,EAAsB,GACtBC,EAAUN,EACdE,EACAK,OAAOC,OACL,CAAE,EACF,CACEC,OAAQJ,GAEVJ,IAGES,EA9CV,SAAqBD,EAAkBC,GACrC,gBADqCA,IAAAA,EAA4B,IAC1DD,EAAOE,OAAO,SAACC,EAAKC,GACzB,IAAMC,EAAaD,EAAME,QAAQ,KAE3BC,EAAQH,EAAMI,MAAM,EAAGH,GACvBI,EAAUL,EAAMI,MAAMH,EAAa,GAAGK,OAM5C,OAJAP,EAAII,GAAS,CACXE,QAAAA,GAGKN,CACT,EAAGF,EACL,CAiCyBU,CAAYf,GAEjC,OAAIC,GACFF,EAAQiB,2BACNC,EAAuBZ,EAAcN,GAEhC,CAAEF,OAAAA,EAAQO,OAAQ,CAAA,IAGpB,CAAEP,OAAQ,GAAIO,OAAQc,EAAab,EAAcN,GAC1D,CACF"}
+{"version":3,"file":"typanion.module.js","sources":["../src/typanion.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport type {\n  FieldError,\n  FieldErrors,\n  FieldValues,\n  Resolver,\n} from 'react-hook-form';\nimport * as t from 'typanion';\n\nfunction parseErrors(errors: string[], parsedErrors: FieldErrors = {}) {\n  return errors.reduce((acc, error) => {\n    const fieldIndex = error.indexOf(':');\n\n    const field = error.slice(1, fieldIndex);\n    const message = error.slice(fieldIndex + 1).trim();\n\n    acc[field] = {\n      message,\n    } as FieldError;\n\n    return acc;\n  }, parsedErrors);\n}\n\nexport function typanionResolver<Input extends FieldValues, Context, Output>(\n  schema: t.StrictValidator<Input, Input>,\n  schemaOptions?: Pick<t.ValidationState, 'coercions' | 'coercion'>,\n  resolverOptions?: {\n    mode?: 'async' | 'sync';\n    raw?: false;\n  },\n): Resolver<Input, Context, t.InferType<typeof schema>>;\n\nexport function typanionResolver<Input extends FieldValues, Context, Output>(\n  schema: t.StrictValidator<Input, Input>,\n  schemaOptions: Pick<t.ValidationState, 'coercions' | 'coercion'> | undefined,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Typanion schema validation\n * @param {t.StrictValidator<TFieldValues, TFieldValues>} schema - The Typanion schema to validate against\n * @param {Pick<t.ValidationState, 'coercions' | 'coercion'>} [schemaOptions] - Optional Typanion validation options\n * @returns {Resolver<t.InferType<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = t.isObject({\n *   name: t.isString(),\n *   age: t.isInteger()\n * });\n *\n * useForm({\n *   resolver: typanionResolver(schema)\n * });\n */\nexport function typanionResolver<Input extends FieldValues, Context, Output>(\n  schema: t.StrictValidator<Input, Input>,\n  schemaOptions: Pick<t.ValidationState, 'coercions' | 'coercion'> = {},\n): Resolver<Input, Context, Output | Input> {\n  return (values: Input, _, options) => {\n    const rawErrors: string[] = [];\n    const isValid = schema(\n      values,\n      Object.assign(\n        {},\n        {\n          errors: rawErrors,\n        },\n        schemaOptions,\n      ),\n    );\n    const parsedErrors = parseErrors(rawErrors);\n\n    if (isValid) {\n      options.shouldUseNativeValidation &&\n        validateFieldsNatively(parsedErrors, options);\n\n      return { values, errors: {} };\n    }\n\n    return { values: {}, errors: toNestErrors(parsedErrors, options) };\n  };\n}\n"],"names":["typanionResolver","schema","schemaOptions","values","_","options","rawErrors","isValid","Object","assign","errors","parsedErrors","reduce","acc","error","fieldIndex","indexOf","field","slice","message","trim","parseErrors","shouldUseNativeValidation","validateFieldsNatively","toNestErrors"],"mappings":"+EAyDgB,SAAAA,EACdC,EACAC,GAEA,YAFAA,IAAAA,IAAAA,EAAmE,CAAE,GAE7DC,SAAAA,EAAeC,EAAGC,GACxB,IAAMC,EAAsB,GACtBC,EAAUN,EACdE,EACAK,OAAOC,OACL,CAAE,EACF,CACEC,OAAQJ,GAEVJ,IAGES,EAhEV,SAAqBD,EAAkBC,GACrC,gBADqCA,IAAAA,EAA4B,IAC1DD,EAAOE,OAAO,SAACC,EAAKC,GACzB,IAAMC,EAAaD,EAAME,QAAQ,KAE3BC,EAAQH,EAAMI,MAAM,EAAGH,GACvBI,EAAUL,EAAMI,MAAMH,EAAa,GAAGK,OAM5C,OAJAP,EAAII,GAAS,CACXE,QAAAA,GAGKN,CACT,EAAGF,EACL,CAmDyBU,CAAYf,GAEjC,OAAIC,GACFF,EAAQiB,2BACNC,EAAuBZ,EAAcN,GAEhC,CAAEF,OAAAA,EAAQO,OAAQ,CAAA,IAGpB,CAAEP,OAAQ,GAAIO,OAAQc,EAAab,EAAcN,GAC1D,CACF"}

package/typanion/dist/typanion.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"typanion.umd.js","sources":["../src/typanion.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport type {\n  FieldError,\n  FieldErrors,\n  FieldValues,\n  Resolver,\n} from 'react-hook-form';\nimport * as t from 'typanion';\n\nfunction parseErrors(errors: string[], parsedErrors: FieldErrors = {}) {\n  return errors.reduce((acc, error) => {\n    const fieldIndex = error.indexOf(':');\n\n    const field = error.slice(1, fieldIndex);\n    const message = error.slice(fieldIndex + 1).trim();\n\n    acc[field] = {\n      message,\n    } as FieldError;\n\n    return acc;\n  }, parsedErrors);\n}\n\n/**\n * Creates a resolver for react-hook-form using Typanion schema validation\n * @param {t.StrictValidator<TFieldValues, TFieldValues>} schema - The Typanion schema to validate against\n * @param {Pick<t.ValidationState, 'coercions' | 'coercion'>} [schemaOptions] - Optional Typanion validation options\n * @returns {Resolver<t.InferType<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = t.isObject({\n *   name: t.isString(),\n *   age: t.isInteger()\n * });\n *\n * useForm({\n *   resolver: typanionResolver(schema)\n * });\n */\nexport function typanionResolver<TFieldValues extends FieldValues>(\n  schema: t.StrictValidator<TFieldValues, TFieldValues>,\n  schemaOptions: Pick<t.ValidationState, 'coercions' | 'coercion'> = {},\n): Resolver<t.InferType<typeof schema>> {\n  return (values, _, options) => {\n    const rawErrors: string[] = [];\n    const isValid = schema(\n      values,\n      Object.assign(\n        {},\n        {\n          errors: rawErrors,\n        },\n        schemaOptions,\n      ),\n    );\n    const parsedErrors = parseErrors(rawErrors);\n\n    if (isValid) {\n      options.shouldUseNativeValidation &&\n        validateFieldsNatively(parsedErrors, options);\n\n      return { values, errors: {} };\n    }\n\n    return { values: {}, errors: toNestErrors(parsedErrors, options) };\n  };\n}\n"],"names":["schema","schemaOptions","values","_","options","rawErrors","isValid","Object","assign","errors","parsedErrors","reduce","acc","error","fieldIndex","indexOf","field","slice","message","trim","parseErrors","shouldUseNativeValidation","validateFieldsNatively","toNestErrors"],"mappings":"iVAuCgB,SACdA,EACAC,GAEA,YAFAA,IAAAA,IAAAA,EAAmE,CAAE,GAE7DC,SAAAA,EAAQC,EAAGC,GACjB,IAAMC,EAAsB,GACtBC,EAAUN,EACdE,EACAK,OAAOC,OACL,CAAE,EACF,CACEC,OAAQJ,GAEVJ,IAGES,EA9CV,SAAqBD,EAAkBC,GACrC,gBADqCA,IAAAA,EAA4B,IAC1DD,EAAOE,OAAO,SAACC,EAAKC,GACzB,IAAMC,EAAaD,EAAME,QAAQ,KAE3BC,EAAQH,EAAMI,MAAM,EAAGH,GACvBI,EAAUL,EAAMI,MAAMH,EAAa,GAAGK,OAM5C,OAJAP,EAAII,GAAS,CACXE,QAAAA,GAGKN,CACT,EAAGF,EACL,CAiCyBU,CAAYf,GAEjC,OAAIC,GACFF,EAAQiB,2BACNC,EAAAA,uBAAuBZ,EAAcN,GAEhC,CAAEF,OAAAA,EAAQO,OAAQ,CAAA,IAGpB,CAAEP,OAAQ,GAAIO,OAAQc,EAAYA,aAACb,EAAcN,GAC1D,CACF"}
+{"version":3,"file":"typanion.umd.js","sources":["../src/typanion.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport type {\n  FieldError,\n  FieldErrors,\n  FieldValues,\n  Resolver,\n} from 'react-hook-form';\nimport * as t from 'typanion';\n\nfunction parseErrors(errors: string[], parsedErrors: FieldErrors = {}) {\n  return errors.reduce((acc, error) => {\n    const fieldIndex = error.indexOf(':');\n\n    const field = error.slice(1, fieldIndex);\n    const message = error.slice(fieldIndex + 1).trim();\n\n    acc[field] = {\n      message,\n    } as FieldError;\n\n    return acc;\n  }, parsedErrors);\n}\n\nexport function typanionResolver<Input extends FieldValues, Context, Output>(\n  schema: t.StrictValidator<Input, Input>,\n  schemaOptions?: Pick<t.ValidationState, 'coercions' | 'coercion'>,\n  resolverOptions?: {\n    mode?: 'async' | 'sync';\n    raw?: false;\n  },\n): Resolver<Input, Context, t.InferType<typeof schema>>;\n\nexport function typanionResolver<Input extends FieldValues, Context, Output>(\n  schema: t.StrictValidator<Input, Input>,\n  schemaOptions: Pick<t.ValidationState, 'coercions' | 'coercion'> | undefined,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Typanion schema validation\n * @param {t.StrictValidator<TFieldValues, TFieldValues>} schema - The Typanion schema to validate against\n * @param {Pick<t.ValidationState, 'coercions' | 'coercion'>} [schemaOptions] - Optional Typanion validation options\n * @returns {Resolver<t.InferType<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = t.isObject({\n *   name: t.isString(),\n *   age: t.isInteger()\n * });\n *\n * useForm({\n *   resolver: typanionResolver(schema)\n * });\n */\nexport function typanionResolver<Input extends FieldValues, Context, Output>(\n  schema: t.StrictValidator<Input, Input>,\n  schemaOptions: Pick<t.ValidationState, 'coercions' | 'coercion'> = {},\n): Resolver<Input, Context, Output | Input> {\n  return (values: Input, _, options) => {\n    const rawErrors: string[] = [];\n    const isValid = schema(\n      values,\n      Object.assign(\n        {},\n        {\n          errors: rawErrors,\n        },\n        schemaOptions,\n      ),\n    );\n    const parsedErrors = parseErrors(rawErrors);\n\n    if (isValid) {\n      options.shouldUseNativeValidation &&\n        validateFieldsNatively(parsedErrors, options);\n\n      return { values, errors: {} };\n    }\n\n    return { values: {}, errors: toNestErrors(parsedErrors, options) };\n  };\n}\n"],"names":["schema","schemaOptions","values","_","options","rawErrors","isValid","Object","assign","errors","parsedErrors","reduce","acc","error","fieldIndex","indexOf","field","slice","message","trim","parseErrors","shouldUseNativeValidation","validateFieldsNatively","toNestErrors"],"mappings":"iVAyDgB,SACdA,EACAC,GAEA,YAFAA,IAAAA,IAAAA,EAAmE,CAAE,GAE7DC,SAAAA,EAAeC,EAAGC,GACxB,IAAMC,EAAsB,GACtBC,EAAUN,EACdE,EACAK,OAAOC,OACL,CAAE,EACF,CACEC,OAAQJ,GAEVJ,IAGES,EAhEV,SAAqBD,EAAkBC,GACrC,gBADqCA,IAAAA,EAA4B,IAC1DD,EAAOE,OAAO,SAACC,EAAKC,GACzB,IAAMC,EAAaD,EAAME,QAAQ,KAE3BC,EAAQH,EAAMI,MAAM,EAAGH,GACvBI,EAAUL,EAAMI,MAAMH,EAAa,GAAGK,OAM5C,OAJAP,EAAII,GAAS,CACXE,QAAAA,GAGKN,CACT,EAAGF,EACL,CAmDyBU,CAAYf,GAEjC,OAAIC,GACFF,EAAQiB,2BACNC,EAAAA,uBAAuBZ,EAAcN,GAEhC,CAAEF,OAAAA,EAAQO,OAAQ,CAAA,IAGpB,CAAEP,OAAQ,GAAIO,OAAQc,EAAYA,aAACb,EAAcN,GAC1D,CACF"}

package/typanion/package.json

@@ -11,7 +11,7 @@
   "types": "dist/index.d.ts",
   "license": "MIT",
   "peerDependencies": {
-    "react-hook-form": "^7.0.0",
+    "react-hook-form": "^7.55.0",
     "@hookform/resolvers": "^2.0.0",
     "typanion": "^3.3.2"
   }

package/typanion/src/__tests__/Form.tsx

@@ -10,12 +10,6 @@ const schema = t.isObject({
   password: t.cascade(t.isString(), [t.hasMinLength(1)]),
 });
 
-interface FormData {
-  unusedProperty: string;
-  username: string;
-  password: string;
-}
-
 function TestComponent({
   onSubmit,
 }: { onSubmit: (data: t.InferType<typeof schema>) => void }) {
@@ -55,29 +49,3 @@ test("form's validation with Typanion and TypeScript's integration", async () =>
   ).toHaveLength(2);
   expect(handleSubmit).not.toHaveBeenCalled();
 });
-
-export function TestComponentManualType({
-  onSubmit,
-}: {
-  onSubmit: (data: FormData) => void;
-}) {
-  const {
-    register,
-    handleSubmit,
-    formState: { errors },
-  } = useForm<t.InferType<typeof schema>, undefined, FormData>({
-    resolver: typanionResolver(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>
-  );
-}

package/typanion/src/__tests__/typanion.ts

@@ -1,3 +1,7 @@
+import { SubmitHandler } from 'react-hook-form';
+import { useForm } from 'react-hook-form';
+import { Resolver } from 'react-hook-form';
+import * as t from 'typanion';
 import { typanionResolver } from '..';
 import { fields, invalidData, schema, validData } from './__fixtures__/data';
 
@@ -32,4 +36,49 @@ describe('typanionResolver', () => {
 
     expect(result).toMatchSnapshot();
   });
+
+  /**
+   * Type inference tests
+   */
+  it('should correctly infer the output type from a typanion schema', () => {
+    const resolver = typanionResolver(t.isObject({ id: t.isNumber() }));
+
+    expectTypeOf(resolver).toEqualTypeOf<
+      Resolver<ObjectType<{ id: number }>, unknown, ObjectType<{ id: number }>>
+    >();
+  });
+
+  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),
+    });
+
+    expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
+
+    expectTypeOf(form.handleSubmit)
+      .parameter(0)
+      .toEqualTypeOf<SubmitHandler<ObjectType<{ id: number }>>>();
+  });
 });
+
+/**
+ * Copied from Typanion source code because it's not exported
+ */
+
+declare type ExtractIndex<T> = {
+  // biome-ignore lint/complexity/noBannedTypes: for testing purposes
+  [K in keyof T as {} extends Record<K, 1> ? K : never]: T[K];
+};
+declare type RemoveIndex<T> = {
+  // biome-ignore lint/complexity/noBannedTypes: for testing purposes
+  [K in keyof T as {} extends Record<K, 1> ? never : K]: T[K];
+};
+declare type UndefinedProperties<T> = {
+  [P in keyof T]-?: undefined extends T[P] ? P : never;
+}[keyof T];
+declare type UndefinedToOptional<T> = Partial<Pick<T, UndefinedProperties<T>>> &
+  Pick<T, Exclude<keyof T, UndefinedProperties<T>>>;
+declare type ObjectType<T> = UndefinedToOptional<RemoveIndex<T>> &
+  ExtractIndex<T>;