@hookform/resolvers 4.0.0 → 4.1.0

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

@@ -4,60 +4,247 @@ exports[`standardSchemaResolver > should return a single error from standardSche
 {
   "errors": {
     "accessToken": {
-      "message": "accessToken must be a number or a string (was missing)",
+      "message": "Invalid input",
       "ref": undefined,
+      "type": "",
     },
     "birthYear": {
-      "message": "birthYear must be a number (was a string)",
+      "message": "Expected number, received string",
       "ref": undefined,
+      "type": "",
     },
     "dateStr": {
-      "message": "dateStr must be a Date (was missing)",
+      "message": "Required",
       "ref": undefined,
+      "type": "",
     },
     "email": {
-      "message": "email must be an email address (was "")",
+      "message": "Invalid email",
       "ref": {
         "name": "email",
       },
+      "type": "",
     },
     "enabled": {
-      "message": "enabled must be boolean (was missing)",
+      "message": "Required",
       "ref": undefined,
+      "type": "",
     },
     "like": [
       {
         "id": {
-          "message": "like[0].id must be a number (was a string)",
+          "message": "Expected number, received string",
           "ref": undefined,
+          "type": "",
         },
         "name": {
-          "message": "like[0].name must be a string (was missing)",
+          "message": "Required",
           "ref": undefined,
+          "type": "",
         },
       },
     ],
     "password": {
-      "message": "password must be matched by .*[A-Za-z].* or matched by .*\\d.* (was "___")",
+      "message": "One uppercase character",
       "ref": {
         "name": "password",
       },
+      "type": "",
     },
     "repeatPassword": {
-      "message": "repeatPassword must be a string (was missing)",
+      "message": "Required",
       "ref": undefined,
+      "type": "",
     },
     "tags": {
-      "message": "tags must be an array (was missing)",
+      "message": "Required",
       "ref": undefined,
+      "type": "",
+    },
+    "url": {
+      "message": "Custom error url",
+      "ref": undefined,
+      "type": "",
+    },
+    "username": {
+      "message": "Required",
+      "ref": {
+        "name": "username",
+      },
+      "type": "",
+    },
+  },
+  "values": {},
+}
+`;
+
+exports[`standardSchemaResolver > should return all the errors from standardSchemaResolver when validation fails with \`validateAllFieldCriteria\` set to true 1`] = `
+{
+  "errors": {
+    "accessToken": {
+      "message": "Invalid input",
+      "ref": undefined,
+      "type": "",
+      "types": {
+        "0": "Invalid input",
+      },
+    },
+    "birthYear": {
+      "message": "Expected number, received string",
+      "ref": undefined,
+      "type": "",
+      "types": {
+        "0": "Expected number, received string",
+      },
+    },
+    "dateStr": {
+      "message": "Required",
+      "ref": undefined,
+      "type": "",
+      "types": {
+        "0": "Required",
+      },
+    },
+    "email": {
+      "message": "Invalid email",
+      "ref": {
+        "name": "email",
+      },
+      "type": "",
+      "types": {
+        "0": "Invalid email",
+      },
+    },
+    "enabled": {
+      "message": "Required",
+      "ref": undefined,
+      "type": "",
+      "types": {
+        "0": "Required",
+      },
+    },
+    "like": [
+      {
+        "id": {
+          "message": "Expected number, received string",
+          "ref": undefined,
+          "type": "",
+          "types": {
+            "0": "Expected number, received string",
+          },
+        },
+        "name": {
+          "message": "Required",
+          "ref": undefined,
+          "type": "",
+          "types": {
+            "0": "Required",
+          },
+        },
+      },
+    ],
+    "password": {
+      "message": "One uppercase character",
+      "ref": {
+        "name": "password",
+      },
+      "type": "",
+      "types": {
+        "0": "One uppercase character",
+        "1": "One lowercase character",
+        "2": "One number",
+        "3": "Must be at least 8 characters in length",
+      },
+    },
+    "repeatPassword": {
+      "message": "Required",
+      "ref": undefined,
+      "type": "",
+      "types": {
+        "0": "Required",
+      },
+    },
+    "tags": {
+      "message": "Required",
+      "ref": undefined,
+      "type": "",
+      "types": {
+        "0": "Required",
+      },
+    },
+    "url": {
+      "message": "Custom error url",
+      "ref": undefined,
+      "type": "",
+      "types": {
+        "0": "Custom error url",
+      },
     },
     "username": {
-      "message": "username must be a string (was missing)",
+      "message": "Required",
       "ref": {
         "name": "username",
       },
+      "type": "",
+      "types": {
+        "0": "Required",
+      },
     },
   },
   "values": {},
 }
 `;
+
+exports[`standardSchemaResolver > should return values from standardSchemaResolver when validation pass & raw=true 1`] = `
+{
+  "errors": {},
+  "values": {
+    "accessToken": "accessToken",
+    "birthYear": 2000,
+    "dateStr": "2020-01-01T00:00:00.000Z",
+    "email": "john@doe.com",
+    "enabled": true,
+    "like": [
+      {
+        "id": 1,
+        "name": "name",
+      },
+    ],
+    "password": "Password123_",
+    "repeatPassword": "Password123_",
+    "tags": [
+      "tag1",
+      "tag2",
+    ],
+    "url": "https://react-hook-form.com/",
+    "username": "Doe",
+  },
+}
+`;
+
+exports[`standardSchemaResolver > should return values from standardSchemaResolver when validation pass 1`] = `
+{
+  "errors": {},
+  "values": {
+    "accessToken": "accessToken",
+    "birthYear": 2000,
+    "dateStr": 2020-01-01T00:00:00.000Z,
+    "email": "john@doe.com",
+    "enabled": true,
+    "like": [
+      {
+        "id": 1,
+        "name": "name",
+      },
+    ],
+    "password": "Password123_",
+    "repeatPassword": "Password123_",
+    "tags": [
+      "tag1",
+      "tag2",
+    ],
+    "url": "https://react-hook-form.com/",
+    "username": "Doe",
+  },
+}
+`;

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

@@ -4,13 +4,13 @@ import { fields, invalidData, schema, validData } from './__fixtures__/data';
 const shouldUseNativeValidation = false;
 
 describe('standardSchemaResolver', () => {
-  it('should return values from standardSchemaResolver when validation pass & raw=true', async () => {
+  it('should return values from standardSchemaResolver when validation pass', async () => {
     const result = await standardSchemaResolver(schema)(validData, undefined, {
       fields,
       shouldUseNativeValidation,
     });
 
-    expect(result).toEqual({ errors: {}, values: validData });
+    expect(result).toMatchSnapshot();
   });
 
   it('should return a single error from standardSchemaResolver when validation fails', async () => {
@@ -25,4 +25,32 @@ describe('standardSchemaResolver', () => {
 
     expect(result).toMatchSnapshot();
   });
+
+  it('should return all the errors from standardSchemaResolver when validation fails with `validateAllFieldCriteria` set to true', async () => {
+    const result = await standardSchemaResolver(schema)(
+      invalidData,
+      undefined,
+      {
+        fields,
+        criteriaMode: 'all',
+        shouldUseNativeValidation,
+      },
+    );
+
+    expect(result).toMatchSnapshot();
+  });
+
+  it('should return values from standardSchemaResolver when validation pass & raw=true', async () => {
+    const validateSpy = vi.spyOn(schema['~standard'], 'validate');
+
+    const result = await standardSchemaResolver(schema, {
+      raw: true,
+    })(validData, undefined, {
+      fields,
+      shouldUseNativeValidation,
+    });
+
+    expect(validateSpy).toHaveBeenCalledTimes(1);
+    expect(result).toMatchSnapshot();
+  });
 });

package/standard-schema/src/index.ts

@@ -1,2 +1 @@
 export * from './standard-schema';
-export * from './types';

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

@@ -1,34 +1,76 @@
 import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';
 import { StandardSchemaV1 } from '@standard-schema/spec';
-import { FieldError } from 'react-hook-form';
-import type { Resolver } from './types';
+import { FieldError, FieldValues, Resolver } from 'react-hook-form';
 
-const parseIssues = (issues: readonly StandardSchemaV1.Issue[]) => {
+function parseIssues(
+  issues: readonly StandardSchemaV1.Issue[],
+  validateAllFieldCriteria: boolean,
+) {
   const errors: Record<string, FieldError> = {};
 
   for (let i = 0; i < issues.length; i++) {
-    const issue = issues[i];
-    const path = issue.path?.join('.') ?? '';
+    const error = issues[i];
+    const path = error.path?.join('.');
 
     if (path) {
       if (!errors[path]) {
-        errors[path] = { message: issue.message } as FieldError;
+        errors[path] = { message: error.message, type: '' };
+      }
+
+      if (validateAllFieldCriteria) {
+        const types = errors[path].types || {};
+
+        errors[path].types = {
+          ...types,
+          [Object.keys(types).length]: error.message,
+        };
       }
     }
   }
 
   return errors;
-};
+}
 
-export const standardSchemaResolver: Resolver =
-  (schema) => async (values, _, options) => {
+/**
+ * Creates a resolver for react-hook-form that validates data using a Standard Schema.
+ *
+ * @param {Schema} schema - The Standard Schema to validate against
+ * @param {Object} resolverOptions - Options for the resolver
+ * @param {boolean} [resolverOptions.raw=false] - Whether to return raw input values instead of parsed values
+ * @returns {Resolver} A resolver function compatible with react-hook-form
+ *
+ * @example
+ * ```ts
+ * const schema = z.object({
+ *   name: z.string().min(2),
+ *   age: z.number().min(18)
+ * });
+ *
+ * useForm({
+ *   resolver: standardSchemaResolver(schema)
+ * });
+ * ```
+ */
+export function standardSchemaResolver<
+  TFieldValues extends FieldValues,
+  Schema extends StandardSchemaV1<TFieldValues, any>,
+>(
+  schema: Schema,
+  resolverOptions: {
+    raw?: boolean;
+  } = {},
+): Resolver<NonNullable<(typeof schema)['~standard']['types']>['output']> {
+  return async (values: TFieldValues, _, options) => {
     let result = schema['~standard'].validate(values);
     if (result instanceof Promise) {
       result = await result;
     }
 
     if (result.issues) {
-      const errors = parseIssues(result.issues);
+      const errors = parseIssues(
+        result.issues,
+        !options.shouldUseNativeValidation && options.criteriaMode === 'all',
+      );
 
       return {
         values: {},
@@ -39,7 +81,8 @@ export const standardSchemaResolver: Resolver =
     options.shouldUseNativeValidation && validateFieldsNatively({}, options);
 
     return {
-      values: values,
+      values: resolverOptions.raw ? Object.assign({}, values) : result.value,
       errors: {},
     };
   };
+}

package/superstruct/dist/index.d.ts

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

package/superstruct/dist/superstruct.d.ts

@@ -1,2 +1,22 @@
-import { Resolver } from './types';
-export declare const superstructResolver: Resolver;
+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>>;

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 } from 'react-hook-form';\n\nimport { StructError, validate } from 'superstruct';\nimport { Resolver } from './types';\n\nconst parseErrorSchema = (error: StructError) =>\n  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\nexport const superstructResolver: Resolver =\n  (schema, schemaOptions, resolverOptions = {}) =>\n  (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"],"names":["schema","schemaOptions","resolverOptions","values","_","options","error","result","validate","errors","toNestErrors","failures","reduce","previous","path","join","message","type","shouldUseNativeValidation","validateFieldsNatively","raw","Object","assign"],"mappings":"0FAiBE,SAACA,EAAQC,EAAeC,GAAoB,gBAApBA,IAAAA,EAAkB,CAAE,GAC3CC,SAAAA,EAAQC,EAAGC,GACV,IAbsBC,EAahBC,EAASC,EAAAA,SAASL,EAAQH,EAAQC,GAExC,OAAIM,EAAO,GACF,CACLJ,OAAQ,GACRM,OAAQC,EAAAA,cAlBUJ,EAkBoBC,EAAO,GAjBnDD,EAAMK,WAAWC,OACf,SAACC,EAAUP,GAAK,OACbO,EAASP,EAAMQ,KAAKC,KAAK,MAAQ,CAChCC,QAASV,EAAMU,QACfC,KAAMX,EAAMW,QACRJ,CAAQ,EAChB,KAWsDR,KAItDA,EAAQa,2BAA6BC,EAAsBA,uBAAC,CAAE,EAAEd,GAEzD,CACLF,OAAQD,EAAgBkB,IAAMC,OAAOC,OAAO,CAAE,EAAEnB,GAAUI,EAAO,GACjEE,OAAQ,CAAA,GAEZ,CAAC"}
+{"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"}

package/superstruct/dist/superstruct.mjs

@@ -1,2 +1,2 @@
-import{toNestErrors as r,validateFieldsNatively as e}from"@hookform/resolvers";import{validate as o}from"superstruct";var s=function(s,t,a){return void 0===a&&(a={}),function(u,i,n){var f,m=o(u,s,t);return m[0]?{values:{},errors:r((f=m[0],f.failures().reduce(function(r,e){return(r[e.path.join(".")]={message:e.message,type:e.type})&&r},{})),n)}:(n.shouldUseNativeValidation&&e({},n),{values:a.raw?Object.assign({},u):m[1],errors:{}})}};export{s as superstructResolver};
+import{toNestErrors as r,validateFieldsNatively as e}from"@hookform/resolvers";import{validate as o}from"superstruct";function s(s,t,u){return void 0===u&&(u={}),function(a,i,n){var f,m=o(a,s,t);return m[0]?{values:{},errors:r((f=m[0],f.failures().reduce(function(r,e){return(r[e.path.join(".")]={message:e.message,type:e.type})&&r},{})),n)}:(n.shouldUseNativeValidation&&e({},n),{values:u.raw?Object.assign({},a):m[1],errors:{}})}}export{s as superstructResolver};
 //# sourceMappingURL=superstruct.module.js.map

package/superstruct/dist/superstruct.modern.mjs

@@ -1,2 +1,2 @@
-import{toNestErrors as r,validateFieldsNatively as e}from"@hookform/resolvers";import{validate as s}from"superstruct";const o=(o,t,a={})=>(i,u,m)=>{const p=s(i,o,t);return p[0]?{values:{},errors:r((l=p[0],l.failures().reduce((r,e)=>(r[e.path.join(".")]={message:e.message,type:e.type})&&r,{})),m)}:(m.shouldUseNativeValidation&&e({},m),{values:a.raw?Object.assign({},i):p[1],errors:{}});var l};export{o as superstructResolver};
+import{toNestErrors as r,validateFieldsNatively as e}from"@hookform/resolvers";import{validate as s}from"superstruct";function o(o,t,a={}){return(u,i,n)=>{const m=s(u,o,t);return m[0]?{values:{},errors:r((p=m[0],p.failures().reduce((r,e)=>(r[e.path.join(".")]={message:e.message,type:e.type})&&r,{})),n)}:(n.shouldUseNativeValidation&&e({},n),{values:a.raw?Object.assign({},u):m[1],errors:{}});var p}}export{o as superstructResolver};
 //# sourceMappingURL=superstruct.modern.mjs.map

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 } from 'react-hook-form';\n\nimport { StructError, validate } from 'superstruct';\nimport { Resolver } from './types';\n\nconst parseErrorSchema = (error: StructError) =>\n  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\nexport const superstructResolver: Resolver =\n  (schema, schemaOptions, resolverOptions = {}) =>\n  (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"],"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":"sHAMA,MAUaA,EACXA,CAACC,EAAQC,EAAeC,EAAkB,CAAA,IAC1C,CAACC,EAAQC,EAAGC,KACV,MAAMC,EAASC,EAASJ,EAAQH,EAAQC,GAExC,OAAIK,EAAO,GACF,CACLH,OAAQ,CAAA,EACRK,OAAQC,GAlBUC,EAkBoBJ,EAAO,GAjBnDI,EAAMC,WAAWC,OACf,CAACC,EAAUH,KACRG,EAASH,EAAMI,KAAKC,KAAK,MAAQ,CAChCC,QAASN,EAAMM,QACfC,KAAMP,EAAMO,QACRJ,EACR,CAAA,IAWsDR,KAItDA,EAAQa,2BAA6BC,EAAuB,GAAId,GAEzD,CACLF,OAAQD,EAAgBkB,IAAMC,OAAOC,OAAO,CAAE,EAAEnB,GAAUG,EAAO,GACjEE,OAAQ,KA1BYE"}
+{"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"}

package/superstruct/dist/superstruct.module.js

@@ -1,2 +1,2 @@
-import{toNestErrors as r,validateFieldsNatively as e}from"@hookform/resolvers";import{validate as o}from"superstruct";var s=function(s,t,a){return void 0===a&&(a={}),function(u,i,n){var f,m=o(u,s,t);return m[0]?{values:{},errors:r((f=m[0],f.failures().reduce(function(r,e){return(r[e.path.join(".")]={message:e.message,type:e.type})&&r},{})),n)}:(n.shouldUseNativeValidation&&e({},n),{values:a.raw?Object.assign({},u):m[1],errors:{}})}};export{s as superstructResolver};
+import{toNestErrors as r,validateFieldsNatively as e}from"@hookform/resolvers";import{validate as o}from"superstruct";function s(s,t,u){return void 0===u&&(u={}),function(a,i,n){var f,m=o(a,s,t);return m[0]?{values:{},errors:r((f=m[0],f.failures().reduce(function(r,e){return(r[e.path.join(".")]={message:e.message,type:e.type})&&r},{})),n)}:(n.shouldUseNativeValidation&&e({},n),{values:u.raw?Object.assign({},a):m[1],errors:{}})}}export{s as superstructResolver};
 //# sourceMappingURL=superstruct.module.js.map

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 } from 'react-hook-form';\n\nimport { StructError, validate } from 'superstruct';\nimport { Resolver } from './types';\n\nconst parseErrorSchema = (error: StructError) =>\n  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\nexport const superstructResolver: Resolver =\n  (schema, schemaOptions, resolverOptions = {}) =>\n  (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"],"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":"sHAMA,IAUaA,EACX,SAACC,EAAQC,EAAeC,GAAoB,gBAApBA,IAAAA,EAAkB,CAAE,GAC3CC,SAAAA,EAAQC,EAAGC,GACV,IAbsBC,EAahBC,EAASC,EAASL,EAAQH,EAAQC,GAExC,OAAIM,EAAO,GACF,CACLJ,OAAQ,GACRM,OAAQC,GAlBUJ,EAkBoBC,EAAO,GAjBnDD,EAAMK,WAAWC,OACf,SAACC,EAAUP,GAAK,OACbO,EAASP,EAAMQ,KAAKC,KAAK,MAAQ,CAChCC,QAASV,EAAMU,QACfC,KAAMX,EAAMW,QACRJ,CAAQ,EAChB,KAWsDR,KAItDA,EAAQa,2BAA6BC,EAAuB,CAAE,EAAEd,GAEzD,CACLF,OAAQD,EAAgBkB,IAAMC,OAAOC,OAAO,CAAE,EAAEnB,GAAUI,EAAO,GACjEE,OAAQ,CAAA,GAEZ,CAAC"}
+{"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"}

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 } from 'react-hook-form';\n\nimport { StructError, validate } from 'superstruct';\nimport { Resolver } from './types';\n\nconst parseErrorSchema = (error: StructError) =>\n  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\nexport const superstructResolver: Resolver =\n  (schema, schemaOptions, resolverOptions = {}) =>\n  (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"],"names":["schema","schemaOptions","resolverOptions","values","_","options","error","result","validate","errors","toNestErrors","failures","reduce","previous","path","join","message","type","shouldUseNativeValidation","validateFieldsNatively","raw","Object","assign"],"mappings":"4YAiBE,SAACA,EAAQC,EAAeC,GAAoB,gBAApBA,IAAAA,EAAkB,CAAE,GAC3CC,SAAAA,EAAQC,EAAGC,GACV,IAbsBC,EAahBC,EAASC,EAAAA,SAASL,EAAQH,EAAQC,GAExC,OAAIM,EAAO,GACF,CACLJ,OAAQ,GACRM,OAAQC,EAAAA,cAlBUJ,EAkBoBC,EAAO,GAjBnDD,EAAMK,WAAWC,OACf,SAACC,EAAUP,GAAK,OACbO,EAASP,EAAMQ,KAAKC,KAAK,MAAQ,CAChCC,QAASV,EAAMU,QACfC,KAAMX,EAAMW,QACRJ,CAAQ,EAChB,KAWsDR,KAItDA,EAAQa,2BAA6BC,EAAsBA,uBAAC,CAAE,EAAEd,GAEzD,CACLF,OAAQD,EAAgBkB,IAAMC,OAAOC,OAAO,CAAE,EAAEnB,GAAUI,EAAO,GACjEE,OAAQ,CAAA,GAEZ,CAAC"}
+{"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"}

package/superstruct/src/__tests__/Form.tsx

@@ -58,3 +58,29 @@ test("form's validation with Superstruct and TypeScript's integration", async ()
   ).toBeInTheDocument();
   expect(handleSubmit).not.toHaveBeenCalled();
 });
+
+export function TestComponentManualType({
+  onSubmit,
+}: {
+  onSubmit: (data: FormData) => void;
+}) {
+  const {
+    register,
+    handleSubmit,
+    formState: { errors },
+  } = useForm<Infer<typeof schema>, undefined, FormData>({
+    resolver: superstructResolver(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/superstruct/src/__tests__/__fixtures__/data.ts

@@ -53,7 +53,7 @@ export const invalidData = {
   email: '',
   birthYear: 'birthYear',
   like: [{ id: 'z' }],
-};
+} as any as Infer<typeof schema>;
 
 export const fields: Record<InternalFieldName, Field['_f']> = {
   username: {

package/superstruct/src/index.ts

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

package/superstruct/src/superstruct.ts

@@ -1,11 +1,9 @@
 import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';
-import { FieldError } from 'react-hook-form';
+import { FieldError, FieldValues, Resolver } from 'react-hook-form';
+import { Infer, Struct, StructError, validate } from 'superstruct';
 
-import { StructError, validate } from 'superstruct';
-import { Resolver } from './types';
-
-const parseErrorSchema = (error: StructError) =>
-  error.failures().reduce<Record<string, FieldError>>(
+function parseErrorSchema(error: StructError) {
+  return error.failures().reduce<Record<string, FieldError>>(
     (previous, error) =>
       (previous[error.path.join('.')] = {
         message: error.message,
@@ -13,10 +11,33 @@ const parseErrorSchema = (error: StructError) =>
       }) && previous,
     {},
   );
+}
 
-export const superstructResolver: Resolver =
-  (schema, schemaOptions, resolverOptions = {}) =>
-  (values, _, options) => {
+/**
+ * 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 function superstructResolver<TFieldValues extends FieldValues>(
+  schema: Struct<TFieldValues, any>,
+  schemaOptions?: Parameters<typeof validate>[2],
+  resolverOptions: {
+    raw?: boolean;
+  } = {},
+): Resolver<Infer<typeof schema>> {
+  return (values, _, options) => {
     const result = validate(values, schema, schemaOptions);
 
     if (result[0]) {
@@ -33,3 +54,4 @@ export const superstructResolver: Resolver =
       errors: {},
     };
   };
+}

package/typanion/dist/index.d.ts

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

package/typanion/dist/typanion.d.ts

@@ -1,2 +1,18 @@
-import type { Resolver } from './types';
-export declare const typanionResolver: Resolver;
+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>>;