@hookform/resolvers 3.10.0 → 4.1.0

package/ajv/src/__tests__/ajv-errors.ts

@@ -0,0 +1,227 @@
+import { ajvResolver } from '..';
+import * as fixture from './__fixtures__/data-errors';
+
+const shouldUseNativeValidation = false;
+
+describe('ajvResolver with errorMessage', () => {
+  it('should return values when validation pass', async () => {
+    expect(
+      await ajvResolver(fixture.schemaA)(fixture.validDataA, undefined, {
+        fields: fixture.fieldsA,
+        criteriaMode: 'all',
+        shouldUseNativeValidation,
+      }),
+    ).toEqual({
+      values: fixture.validDataA,
+      errors: {},
+    });
+  });
+
+  it('should return customized error messages when validation fails', async () => {
+    expect(
+      await ajvResolver(fixture.schemaA)(
+        fixture.invalidDataA,
+        {},
+        {
+          fields: fixture.fieldsA,
+          criteriaMode: 'all',
+          shouldUseNativeValidation,
+        },
+      ),
+    ).toMatchSnapshot();
+  });
+
+  it('should return customized error messages when requirement fails', async () => {
+    expect(
+      await ajvResolver(fixture.schemaA)({}, undefined, {
+        fields: fixture.fieldsA,
+        criteriaMode: 'all',
+        shouldUseNativeValidation,
+      }),
+    ).toMatchSnapshot();
+  });
+
+  it('should return customized error messages when some properties are undefined', async () => {
+    expect(
+      await ajvResolver(fixture.schemaA, undefined, { mode: 'sync' })(
+        fixture.undefinedDataA,
+        undefined,
+        {
+          fields: fixture.fieldsA,
+          criteriaMode: 'all',
+          shouldUseNativeValidation,
+        },
+      ),
+    ).toMatchSnapshot();
+  });
+
+  it('should return the same customized message for all validation failures', async () => {
+    expect(
+      await ajvResolver(fixture.schemaB)(
+        fixture.invalidDataB,
+        {},
+        {
+          fields: fixture.fieldsRest,
+          criteriaMode: 'all',
+          shouldUseNativeValidation,
+        },
+      ),
+    ).toMatchSnapshot();
+  });
+
+  it('should return the same customized error message when requirement fails', async () => {
+    expect(
+      await ajvResolver(fixture.schemaB)({}, undefined, {
+        fields: fixture.fieldsRest,
+        criteriaMode: 'all',
+        shouldUseNativeValidation,
+      }),
+    ).toMatchSnapshot();
+  });
+
+  it('should return the same customized message when some properties are undefined', async () => {
+    expect(
+      await ajvResolver(fixture.schemaB)(fixture.undefinedDataB, undefined, {
+        fields: fixture.fieldsRest,
+        criteriaMode: 'all',
+        shouldUseNativeValidation,
+      }),
+    ).toMatchSnapshot();
+  });
+
+  it('should return customized error messages for certain keywords when walidation fails', async () => {
+    expect(
+      await ajvResolver(fixture.schemaC)(
+        fixture.invalidDataC,
+        {},
+        {
+          fields: fixture.fieldsRest,
+          criteriaMode: 'all',
+          shouldUseNativeValidation,
+        },
+      ),
+    ).toMatchSnapshot();
+  });
+
+  it('should return customized error messages for certain keywords when requirement fails', async () => {
+    expect(
+      await ajvResolver(fixture.schemaC)({}, undefined, {
+        fields: fixture.fieldsRest,
+        criteriaMode: 'all',
+        shouldUseNativeValidation,
+      }),
+    ).toMatchSnapshot();
+  });
+
+  it('should return customized error messages for certain keywords when some properties are undefined', async () => {
+    expect(
+      await ajvResolver(fixture.schemaC)(fixture.undefinedDataC, undefined, {
+        fields: fixture.fieldsRest,
+        criteriaMode: 'all',
+        shouldUseNativeValidation,
+      }),
+    ).toMatchSnapshot();
+  });
+
+  it('should return different messages for different properties when walidation fails', async () => {
+    expect(
+      await ajvResolver(fixture.schemaD)(
+        fixture.invalidDataD,
+        {},
+        {
+          fields: fixture.fieldsRest,
+          criteriaMode: 'all',
+          shouldUseNativeValidation,
+        },
+      ),
+    ).toMatchSnapshot();
+  });
+
+  it('should return different messages for different properties when requirement fails', async () => {
+    expect(
+      await ajvResolver(fixture.schemaD)({}, undefined, {
+        fields: fixture.fieldsRest,
+        criteriaMode: 'all',
+        shouldUseNativeValidation,
+      }),
+    ).toMatchSnapshot();
+  });
+
+  it('should return different messages for different properties when some properties are undefined', async () => {
+    expect(
+      await ajvResolver(fixture.schemaD)(fixture.undefinedDataD, undefined, {
+        fields: fixture.fieldsRest,
+        criteriaMode: 'all',
+        shouldUseNativeValidation,
+      }),
+    ).toMatchSnapshot();
+  });
+
+  it('should return customized errors for properties/items when walidation fails', async () => {
+    expect(
+      await ajvResolver(fixture.schemaE)(
+        fixture.invalidDataE,
+        {},
+        {
+          fields: fixture.fieldsRest,
+          criteriaMode: 'all',
+          shouldUseNativeValidation,
+        },
+      ),
+    ).toMatchSnapshot();
+  });
+
+  it('should return customized errors for properties/items when requirement fails', async () => {
+    expect(
+      await ajvResolver(fixture.schemaE)({}, undefined, {
+        fields: fixture.fieldsRest,
+        criteriaMode: 'all',
+        shouldUseNativeValidation,
+      }),
+    ).toMatchSnapshot();
+  });
+
+  it('should return customized errors for properties/items when some properties are undefined', async () => {
+    expect(
+      await ajvResolver(fixture.schemaE)(fixture.undefinedDataE, undefined, {
+        fields: fixture.fieldsRest,
+        criteriaMode: 'all',
+        shouldUseNativeValidation,
+      }),
+    ).toMatchSnapshot();
+  });
+
+  it('should return a default message if there is no specific message for the error when walidation fails', async () => {
+    expect(
+      await ajvResolver(fixture.schemaF)(
+        fixture.invalidDataF,
+        {},
+        {
+          fields: fixture.fieldsRest,
+          criteriaMode: 'all',
+          shouldUseNativeValidation,
+        },
+      ),
+    ).toMatchSnapshot();
+  });
+
+  it('should return a default message if there is no specific message for the error when requirement fails', async () => {
+    expect(
+      await ajvResolver(fixture.schemaF)({}, undefined, {
+        fields: fixture.fieldsRest,
+        criteriaMode: 'all',
+        shouldUseNativeValidation,
+      }),
+    ).toMatchSnapshot();
+  });
+
+  it('should return a default message if there is no specific message for the error when some properties are undefined', async () => {
+    expect(
+      await ajvResolver(fixture.schemaF)(fixture.undefinedDataF, undefined, {
+        fields: fixture.fieldsRest,
+        criteriaMode: 'all',
+        shouldUseNativeValidation,
+      }),
+    ).toMatchSnapshot();
+  });
+});

package/ajv/src/ajv.ts

@@ -2,49 +2,82 @@ import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';
 import Ajv, { DefinedError } from 'ajv';
 import ajvErrors from 'ajv-errors';
 import { FieldError, appendErrors } from 'react-hook-form';
-import { Resolver } from './types';
+import { AjvError, Resolver } from './types';
 
 const parseErrorSchema = (
-  ajvErrors: DefinedError[],
+  ajvErrors: AjvError[],
   validateAllFieldCriteria: boolean,
 ) => {
-  // Ajv will return empty instancePath when require error
-  ajvErrors.forEach((error) => {
+  const parsedErrors: Record<string, FieldError> = {};
+
+  const reduceError = (error: AjvError) => {
+    // Ajv will return empty instancePath when require error
     if (error.keyword === 'required') {
-      error.instancePath += '/' + error.params.missingProperty;
+      error.instancePath += `/${error.params.missingProperty}`;
     }
-  });
 
-  return ajvErrors.reduce<Record<string, FieldError>>((previous, error) => {
     // `/deepObject/data` -> `deepObject.data`
     const path = error.instancePath.substring(1).replace(/\//g, '.');
 
-    if (!previous[path]) {
-      previous[path] = {
+    if (!parsedErrors[path]) {
+      parsedErrors[path] = {
         message: error.message,
         type: error.keyword,
       };
     }
 
     if (validateAllFieldCriteria) {
-      const types = previous[path].types;
+      const types = parsedErrors[path].types;
       const messages = types && types[error.keyword];
 
-      previous[path] = appendErrors(
+      parsedErrors[path] = appendErrors(
         path,
         validateAllFieldCriteria,
-        previous,
+        parsedErrors,
         error.keyword,
         messages
           ? ([] as string[]).concat(messages as string[], error.message || '')
           : error.message,
       ) as FieldError;
     }
+  };
+
+  for (let index = 0; index < ajvErrors.length; index += 1) {
+    const error = ajvErrors[index];
+
+    if (error.keyword === 'errorMessage') {
+      error.params.errors.forEach((originalError) => {
+        originalError.message = error.message;
+        reduceError(originalError);
+      });
+    } else {
+      reduceError(error);
+    }
+  }
 
-    return previous;
-  }, {});
+  return parsedErrors;
 };
 
+/**
+ * Creates a resolver for react-hook-form using Ajv schema validation
+ * @param {Schema} schema - The Ajv schema to validate against
+ * @param {Object} schemaOptions - Additional schema validation options
+ * @param {Object} resolverOptions - Additional resolver configuration
+ * @param {string} [resolverOptions.mode='async'] - Validation mode
+ * @returns {Resolver<Schema>} A resolver function compatible with react-hook-form
+ * @example
+ * const schema = ajv.compile({
+ *   type: 'object',
+ *   properties: {
+ *     name: { type: 'string' },
+ *     age: { type: 'number' }
+ *   }
+ * });
+ *
+ * useForm({
+ *   resolver: ajvResolver(schema)
+ * });
+ */
 export const ajvResolver: Resolver =
   (schema, schemaOptions, resolverOptions = {}) =>
   async (values, _, options) => {

package/ajv/src/types.ts

@@ -1,4 +1,5 @@
 import * as Ajv from 'ajv';
+import type { DefinedError, ErrorObject } from 'ajv';
 import { FieldValues, ResolverOptions, ResolverResult } from 'react-hook-form';
 
 export type Resolver = <T>(
@@ -10,3 +11,10 @@ export type Resolver = <T>(
   context: TContext | undefined,
   options: ResolverOptions<TFieldValues>,
 ) => Promise<ResolverResult<TFieldValues>>;
+
+// ajv doesn't export any types for errors with `keyword='errorMessage'`
+type ErrorMessage = ErrorObject<
+  'errorMessage',
+  { errors: (DefinedError & { emUsed: boolean })[] }
+>;
+export type AjvError = ErrorMessage | DefinedError;

package/arktype/dist/arktype.d.ts

@@ -1,2 +1,20 @@
-import type { Resolver } from './types';
-export declare const arktypeResolver: Resolver;
+import { Type } from 'arktype';
+import { Resolver } from 'react-hook-form';
+/**
+ * Creates a resolver for react-hook-form using Arktype schema validation
+ * @param {Schema} schema - The Arktype schema to validate against
+ * @param {Object} resolverOptions - Additional resolver configuration
+ * @param {string} [resolverOptions.mode='raw'] - Return the raw input values rather than the parsed values
+ * @returns {Resolver<Schema['inferOut']>} A resolver function compatible with react-hook-form
+ * @example
+ * const schema = type({
+ *   username: 'string>2'
+ * });
+ *
+ * useForm({
+ *   resolver: arktypeResolver(schema)
+ * });
+ */
+export declare function arktypeResolver<Schema extends Type<any, any>>(schema: Schema, _schemaOptions?: never, resolverOptions?: {
+    raw?: boolean;
+}): Resolver<Schema['inferOut']>;

package/arktype/dist/arktype.js

@@ -1,2 +1,2 @@
-var r=require("@hookform/resolvers"),e=require("arktype");exports.arktypeResolver=function(o,t,a){return void 0===a&&(a={}),function(t,s,i){var n,u=o(t);return u instanceof e.ArkErrors?{values:{},errors:r.toNestErrors((n=u,n.forEach(function(r){return Object.assign(r,{type:r.code})}),n.byPath),i)}:(i.shouldUseNativeValidation&&r.validateFieldsNatively({},i),{errors:{},values:a.raw?t:u})}};
+var r=require("@hookform/resolvers"),e=require("arktype");function o(r){for(var e=[].concat(r),o={};e.length;){var s=e[0],t=s.path.join(".");o[t]||(o[t]={message:s.message,type:s.code}),e.shift()}return o}exports.arktypeResolver=function(s,t,a){return void 0===a&&(a={}),function(t,i,n){var v=s(t);return v instanceof e.ArkErrors?{values:{},errors:r.toNestErrors(o(v),n)}:(n.shouldUseNativeValidation&&r.validateFieldsNatively({},n),{errors:{},values:a.raw?Object.assign({},t):v})}};
 //# sourceMappingURL=arktype.js.map

package/arktype/dist/arktype.js.map

@@ -1 +1 @@
-{"version":3,"file":"arktype.js","sources":["../src/arktype.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { ArkErrors } from 'arktype';\nimport { FieldError, FieldErrors } from 'react-hook-form';\nimport type { Resolver } from './types';\n\nconst parseErrorSchema = (e: ArkErrors): Record<string, FieldError> => {\n  // copy code to type to match FieldError shape\n  e.forEach((e) => Object.assign(e, { type: e.code }));\n  // need to cast here because TS doesn't understand we added the type field\n  return e.byPath as never;\n};\n\nexport const arktypeResolver: Resolver =\n  (schema, _schemaOptions, resolverOptions = {}) =>\n  (values, _, options) => {\n    const out = schema(values);\n\n    if (out instanceof ArkErrors) {\n      return {\n        values: {},\n        errors: toNestErrors(parseErrorSchema(out), options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      errors: {} as FieldErrors,\n      values: resolverOptions.raw ? values : out,\n    };\n  };\n"],"names":["schema","_schemaOptions","resolverOptions","values","_","options","e","out","ArkErrors","errors","toNestErrors","forEach","Object","assign","type","code","byPath","shouldUseNativeValidation","validateFieldsNatively","raw"],"mappings":"kFAaE,SAACA,EAAQC,EAAgBC,GACzB,YADyBA,IAAAA,IAAAA,EAAkB,CAAA,GAC3C,SAACC,EAAQC,EAAGC,GACV,IAVsBC,EAUhBC,EAAMP,EAAOG,GAEnB,OAAII,aAAeC,EAAAA,UACV,CACLL,OAAQ,CAAE,EACVM,OAAQC,EAAYA,cAfFJ,EAeoBC,EAb5CD,EAAEK,QAAQ,SAACL,UAAMM,OAAOC,OAAOP,EAAG,CAAEQ,KAAMR,EAAES,MAAO,GAE5CT,EAAEU,QAWyCX,KAIhDA,EAAQY,2BAA6BC,EAAsBA,uBAAC,CAAE,EAAEb,GAEzD,CACLI,OAAQ,CAAiB,EACzBN,OAAQD,EAAgBiB,IAAMhB,EAASI,GAE3C,CAAC"}
+{"version":3,"file":"arktype.js","sources":["../src/arktype.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { ArkErrors, Type } from 'arktype';\nimport { FieldError, FieldErrors, Resolver } from 'react-hook-form';\n\nfunction parseErrorSchema(arkErrors: ArkErrors): Record<string, FieldError> {\n  const errors = [...arkErrors];\n  const fieldsErrors: Record<string, FieldError> = {};\n\n  for (; errors.length; ) {\n    const error = errors[0];\n    const _path = error.path.join('.');\n\n    if (!fieldsErrors[_path]) {\n      fieldsErrors[_path] = { message: error.message, type: error.code };\n    }\n\n    errors.shift();\n  }\n\n  return fieldsErrors;\n}\n\n/**\n * Creates a resolver for react-hook-form using Arktype schema validation\n * @param {Schema} schema - The Arktype schema to validate against\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {string} [resolverOptions.mode='raw'] - Return the raw input values rather than the parsed values\n * @returns {Resolver<Schema['inferOut']>} A resolver function compatible with react-hook-form\n * @example\n * const schema = type({\n *   username: 'string>2'\n * });\n *\n * useForm({\n *   resolver: arktypeResolver(schema)\n * });\n */\nexport function arktypeResolver<Schema extends Type<any, any>>(\n  schema: Schema,\n  _schemaOptions?: never,\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Schema['inferOut']> {\n  return (values, _, options) => {\n    const out = schema(values);\n\n    if (out instanceof ArkErrors) {\n      return {\n        values: {},\n        errors: toNestErrors(parseErrorSchema(out), options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      errors: {} as FieldErrors,\n      values: resolverOptions.raw ? Object.assign({}, values) : out,\n    };\n  };\n}\n"],"names":["parseErrorSchema","arkErrors","errors","concat","fieldsErrors","length","error","_path","path","join","message","type","code","shift","schema","_schemaOptions","resolverOptions","values","_","options","out","ArkErrors","toNestErrors","shouldUseNativeValidation","validateFieldsNatively","raw","Object","assign"],"mappings":"0DAIA,SAASA,EAAiBC,GAIxB,IAHA,IAAMC,EAAMC,GAAAA,OAAOF,GACbG,EAA2C,CAAE,EAE5CF,EAAOG,QAAU,CACtB,IAAMC,EAAQJ,EAAO,GACfK,EAAQD,EAAME,KAAKC,KAAK,KAEzBL,EAAaG,KAChBH,EAAaG,GAAS,CAAEG,QAASJ,EAAMI,QAASC,KAAML,EAAMM,OAG9DV,EAAOW,OACT,CAEA,OAAOT,CACT,kCAkBEU,EACAC,EACAC,GAIA,gBAJAA,IAAAA,EAEI,CAAE,GAEEC,SAAAA,EAAQC,EAAGC,GACjB,IAAMC,EAAMN,EAAOG,GAEnB,OAAIG,aAAeC,YACV,CACLJ,OAAQ,CAAE,EACVf,OAAQoB,EAAAA,aAAatB,EAAiBoB,GAAMD,KAIhDA,EAAQI,2BAA6BC,yBAAuB,CAAA,EAAIL,GAEzD,CACLjB,OAAQ,GACRe,OAAQD,EAAgBS,IAAMC,OAAOC,OAAO,GAAIV,GAAUG,GAE9D,CACF"}

package/arktype/dist/arktype.mjs

@@ -1,2 +1,2 @@
-import{toNestErrors as r,validateFieldsNatively as o}from"@hookform/resolvers";import{ArkErrors as e}from"arktype";var t=function(t,a,n){return void 0===n&&(n={}),function(a,i,s){var u,f=t(a);return f instanceof e?{values:{},errors:r((u=f,u.forEach(function(r){return Object.assign(r,{type:r.code})}),u.byPath),s)}:(s.shouldUseNativeValidation&&o({},s),{errors:{},values:n.raw?a:f})}};export{t as arktypeResolver};
+import{toNestErrors as r,validateFieldsNatively as e}from"@hookform/resolvers";import{ArkErrors as o}from"arktype";function t(r){for(var e=[].concat(r),o={};e.length;){var t=e[0],a=t.path.join(".");o[a]||(o[a]={message:t.message,type:t.code}),e.shift()}return o}function a(a,n,s){return void 0===s&&(s={}),function(n,i,f){var u=a(n);return u instanceof o?{values:{},errors:r(t(u),f)}:(f.shouldUseNativeValidation&&e({},f),{errors:{},values:s.raw?Object.assign({},n):u})}}export{a as arktypeResolver};
 //# sourceMappingURL=arktype.module.js.map

package/arktype/dist/arktype.modern.mjs

@@ -1,2 +1,2 @@
-import{toNestErrors as r,validateFieldsNatively as o}from"@hookform/resolvers";import{ArkErrors as e}from"arktype";const s=(s,t,a={})=>(t,i,n)=>{const c=s(t);return c instanceof e?{values:{},errors:r((f=c,f.forEach(r=>Object.assign(r,{type:r.code})),f.byPath),n)}:(n.shouldUseNativeValidation&&o({},n),{errors:{},values:a.raw?t:c});var f};export{s as arktypeResolver};
+import{toNestErrors as r,validateFieldsNatively as e}from"@hookform/resolvers";import{ArkErrors as o}from"arktype";function t(r){const e=[...r],o={};for(;e.length;){const r=e[0],t=r.path.join(".");o[t]||(o[t]={message:r.message,type:r.code}),e.shift()}return o}function s(s,n,a={}){return(n,i,c)=>{const f=s(n);return f instanceof o?{values:{},errors:r(t(f),c)}:(c.shouldUseNativeValidation&&e({},c),{errors:{},values:a.raw?Object.assign({},n):f})}}export{s as arktypeResolver};
 //# sourceMappingURL=arktype.modern.mjs.map

package/arktype/dist/arktype.modern.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"arktype.modern.mjs","sources":["../src/arktype.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { ArkErrors } from 'arktype';\nimport { FieldError, FieldErrors } from 'react-hook-form';\nimport type { Resolver } from './types';\n\nconst parseErrorSchema = (e: ArkErrors): Record<string, FieldError> => {\n  // copy code to type to match FieldError shape\n  e.forEach((e) => Object.assign(e, { type: e.code }));\n  // need to cast here because TS doesn't understand we added the type field\n  return e.byPath as never;\n};\n\nexport const arktypeResolver: Resolver =\n  (schema, _schemaOptions, resolverOptions = {}) =>\n  (values, _, options) => {\n    const out = schema(values);\n\n    if (out instanceof ArkErrors) {\n      return {\n        values: {},\n        errors: toNestErrors(parseErrorSchema(out), options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      errors: {} as FieldErrors,\n      values: resolverOptions.raw ? values : out,\n    };\n  };\n"],"names":["arktypeResolver","schema","_schemaOptions","resolverOptions","values","_","options","out","ArkErrors","errors","toNestErrors","e","forEach","Object","assign","type","code","byPath","shouldUseNativeValidation","validateFieldsNatively","raw"],"mappings":"mHAKA,MAOaA,EACXA,CAACC,EAAQC,EAAgBC,EAAkB,CAAA,IAC3C,CAACC,EAAQC,EAAGC,KACV,MAAMC,EAAMN,EAAOG,GAEnB,OAAIG,aAAeC,EACV,CACLJ,OAAQ,CAAE,EACVK,OAAQC,GAfUC,EAeoBJ,EAb5CI,EAAEC,QAASD,GAAME,OAAOC,OAAOH,EAAG,CAAEI,KAAMJ,EAAEK,QAErCL,EAAEM,QAWyCX,KAIhDA,EAAQY,2BAA6BC,EAAuB,GAAIb,GAEzD,CACLG,OAAQ,CAAA,EACRL,OAAQD,EAAgBiB,IAAMhB,EAASG,IAvBnBI"}
+{"version":3,"file":"arktype.modern.mjs","sources":["../src/arktype.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { ArkErrors, Type } from 'arktype';\nimport { FieldError, FieldErrors, Resolver } from 'react-hook-form';\n\nfunction parseErrorSchema(arkErrors: ArkErrors): Record<string, FieldError> {\n  const errors = [...arkErrors];\n  const fieldsErrors: Record<string, FieldError> = {};\n\n  for (; errors.length; ) {\n    const error = errors[0];\n    const _path = error.path.join('.');\n\n    if (!fieldsErrors[_path]) {\n      fieldsErrors[_path] = { message: error.message, type: error.code };\n    }\n\n    errors.shift();\n  }\n\n  return fieldsErrors;\n}\n\n/**\n * Creates a resolver for react-hook-form using Arktype schema validation\n * @param {Schema} schema - The Arktype schema to validate against\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {string} [resolverOptions.mode='raw'] - Return the raw input values rather than the parsed values\n * @returns {Resolver<Schema['inferOut']>} A resolver function compatible with react-hook-form\n * @example\n * const schema = type({\n *   username: 'string>2'\n * });\n *\n * useForm({\n *   resolver: arktypeResolver(schema)\n * });\n */\nexport function arktypeResolver<Schema extends Type<any, any>>(\n  schema: Schema,\n  _schemaOptions?: never,\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Schema['inferOut']> {\n  return (values, _, options) => {\n    const out = schema(values);\n\n    if (out instanceof ArkErrors) {\n      return {\n        values: {},\n        errors: toNestErrors(parseErrorSchema(out), options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      errors: {} as FieldErrors,\n      values: resolverOptions.raw ? Object.assign({}, values) : out,\n    };\n  };\n}\n"],"names":["parseErrorSchema","arkErrors","errors","fieldsErrors","length","error","_path","path","join","message","type","code","shift","arktypeResolver","schema","_schemaOptions","resolverOptions","values","_","options","out","ArkErrors","toNestErrors","shouldUseNativeValidation","validateFieldsNatively","raw","Object","assign"],"mappings":"mHAIA,SAASA,EAAiBC,GACxB,MAAMC,EAAS,IAAID,GACbE,EAA2C,GAEjD,KAAOD,EAAOE,QAAU,CACtB,MAAMC,EAAQH,EAAO,GACfI,EAAQD,EAAME,KAAKC,KAAK,KAEzBL,EAAaG,KAChBH,EAAaG,GAAS,CAAEG,QAASJ,EAAMI,QAASC,KAAML,EAAMM,OAG9DT,EAAOU,OACT,CAEA,OAAOT,CACT,CAiBM,SAAUU,EACdC,EACAC,EACAC,EAEI,CAAE,GAEN,MAAO,CAACC,EAAQC,EAAGC,KACjB,MAAMC,EAAMN,EAAOG,GAEnB,OAAIG,aAAeC,EACV,CACLJ,OAAQ,CAAE,EACVf,OAAQoB,EAAatB,EAAiBoB,GAAMD,KAIhDA,EAAQI,2BAA6BC,EAAuB,CAAE,EAAEL,GAEzD,CACLjB,OAAQ,CAAA,EACRe,OAAQD,EAAgBS,IAAMC,OAAOC,OAAO,GAAIV,GAAUG,IAGhE"}

package/arktype/dist/arktype.module.js

@@ -1,2 +1,2 @@
-import{toNestErrors as r,validateFieldsNatively as o}from"@hookform/resolvers";import{ArkErrors as e}from"arktype";var t=function(t,a,n){return void 0===n&&(n={}),function(a,i,s){var u,f=t(a);return f instanceof e?{values:{},errors:r((u=f,u.forEach(function(r){return Object.assign(r,{type:r.code})}),u.byPath),s)}:(s.shouldUseNativeValidation&&o({},s),{errors:{},values:n.raw?a:f})}};export{t as arktypeResolver};
+import{toNestErrors as r,validateFieldsNatively as e}from"@hookform/resolvers";import{ArkErrors as o}from"arktype";function t(r){for(var e=[].concat(r),o={};e.length;){var t=e[0],a=t.path.join(".");o[a]||(o[a]={message:t.message,type:t.code}),e.shift()}return o}function a(a,n,s){return void 0===s&&(s={}),function(n,i,f){var u=a(n);return u instanceof o?{values:{},errors:r(t(u),f)}:(f.shouldUseNativeValidation&&e({},f),{errors:{},values:s.raw?Object.assign({},n):u})}}export{a as arktypeResolver};
 //# sourceMappingURL=arktype.module.js.map

package/arktype/dist/arktype.module.js.map

@@ -1 +1 @@
-{"version":3,"file":"arktype.module.js","sources":["../src/arktype.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { ArkErrors } from 'arktype';\nimport { FieldError, FieldErrors } from 'react-hook-form';\nimport type { Resolver } from './types';\n\nconst parseErrorSchema = (e: ArkErrors): Record<string, FieldError> => {\n  // copy code to type to match FieldError shape\n  e.forEach((e) => Object.assign(e, { type: e.code }));\n  // need to cast here because TS doesn't understand we added the type field\n  return e.byPath as never;\n};\n\nexport const arktypeResolver: Resolver =\n  (schema, _schemaOptions, resolverOptions = {}) =>\n  (values, _, options) => {\n    const out = schema(values);\n\n    if (out instanceof ArkErrors) {\n      return {\n        values: {},\n        errors: toNestErrors(parseErrorSchema(out), options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      errors: {} as FieldErrors,\n      values: resolverOptions.raw ? values : out,\n    };\n  };\n"],"names":["arktypeResolver","schema","_schemaOptions","resolverOptions","values","_","options","e","out","ArkErrors","errors","toNestErrors","forEach","Object","assign","type","code","byPath","shouldUseNativeValidation","validateFieldsNatively","raw"],"mappings":"mHAKA,IAOaA,EACX,SAACC,EAAQC,EAAgBC,GACzB,YADyBA,IAAAA,IAAAA,EAAkB,CAAA,GAC3C,SAACC,EAAQC,EAAGC,GACV,IAVsBC,EAUhBC,EAAMP,EAAOG,GAEnB,OAAII,aAAeC,EACV,CACLL,OAAQ,CAAE,EACVM,OAAQC,GAfUJ,EAeoBC,EAb5CD,EAAEK,QAAQ,SAACL,UAAMM,OAAOC,OAAOP,EAAG,CAAEQ,KAAMR,EAAES,MAAO,GAE5CT,EAAEU,QAWyCX,KAIhDA,EAAQY,2BAA6BC,EAAuB,CAAE,EAAEb,GAEzD,CACLI,OAAQ,CAAiB,EACzBN,OAAQD,EAAgBiB,IAAMhB,EAASI,GAE3C,CAAC"}
+{"version":3,"file":"arktype.module.js","sources":["../src/arktype.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { ArkErrors, Type } from 'arktype';\nimport { FieldError, FieldErrors, Resolver } from 'react-hook-form';\n\nfunction parseErrorSchema(arkErrors: ArkErrors): Record<string, FieldError> {\n  const errors = [...arkErrors];\n  const fieldsErrors: Record<string, FieldError> = {};\n\n  for (; errors.length; ) {\n    const error = errors[0];\n    const _path = error.path.join('.');\n\n    if (!fieldsErrors[_path]) {\n      fieldsErrors[_path] = { message: error.message, type: error.code };\n    }\n\n    errors.shift();\n  }\n\n  return fieldsErrors;\n}\n\n/**\n * Creates a resolver for react-hook-form using Arktype schema validation\n * @param {Schema} schema - The Arktype schema to validate against\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {string} [resolverOptions.mode='raw'] - Return the raw input values rather than the parsed values\n * @returns {Resolver<Schema['inferOut']>} A resolver function compatible with react-hook-form\n * @example\n * const schema = type({\n *   username: 'string>2'\n * });\n *\n * useForm({\n *   resolver: arktypeResolver(schema)\n * });\n */\nexport function arktypeResolver<Schema extends Type<any, any>>(\n  schema: Schema,\n  _schemaOptions?: never,\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Schema['inferOut']> {\n  return (values, _, options) => {\n    const out = schema(values);\n\n    if (out instanceof ArkErrors) {\n      return {\n        values: {},\n        errors: toNestErrors(parseErrorSchema(out), options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      errors: {} as FieldErrors,\n      values: resolverOptions.raw ? Object.assign({}, values) : out,\n    };\n  };\n}\n"],"names":["parseErrorSchema","arkErrors","errors","concat","fieldsErrors","length","error","_path","path","join","message","type","code","shift","arktypeResolver","schema","_schemaOptions","resolverOptions","values","_","options","out","ArkErrors","toNestErrors","shouldUseNativeValidation","validateFieldsNatively","raw","Object","assign"],"mappings":"mHAIA,SAASA,EAAiBC,GAIxB,IAHA,IAAMC,EAAMC,GAAAA,OAAOF,GACbG,EAA2C,CAAE,EAE5CF,EAAOG,QAAU,CACtB,IAAMC,EAAQJ,EAAO,GACfK,EAAQD,EAAME,KAAKC,KAAK,KAEzBL,EAAaG,KAChBH,EAAaG,GAAS,CAAEG,QAASJ,EAAMI,QAASC,KAAML,EAAMM,OAG9DV,EAAOW,OACT,CAEA,OAAOT,CACT,UAiBgBU,EACdC,EACAC,EACAC,GAIA,gBAJAA,IAAAA,EAEI,CAAE,GAEEC,SAAAA,EAAQC,EAAGC,GACjB,IAAMC,EAAMN,EAAOG,GAEnB,OAAIG,aAAeC,EACV,CACLJ,OAAQ,CAAE,EACVhB,OAAQqB,EAAavB,EAAiBqB,GAAMD,KAIhDA,EAAQI,2BAA6BC,EAAuB,CAAA,EAAIL,GAEzD,CACLlB,OAAQ,GACRgB,OAAQD,EAAgBS,IAAMC,OAAOC,OAAO,GAAIV,GAAUG,GAE9D,CACF"}

package/arktype/dist/arktype.umd.js

@@ -1,2 +1,2 @@
-!function(e,o){"object"==typeof exports&&"undefined"!=typeof module?o(exports,require("@hookform/resolvers"),require("arktype")):"function"==typeof define&&define.amd?define(["exports","@hookform/resolvers","arktype"],o):o((e||self).hookformResolversArktype={},e.hookformResolvers,e.arktype)}(this,function(e,o,r){e.arktypeResolver=function(e,t,s){return void 0===s&&(s={}),function(t,n,i){var f,a=e(t);return a instanceof r.ArkErrors?{values:{},errors:o.toNestErrors((f=a,f.forEach(function(e){return Object.assign(e,{type:e.code})}),f.byPath),i)}:(i.shouldUseNativeValidation&&o.validateFieldsNatively({},i),{errors:{},values:s.raw?t:a})}}});
+!function(e,o){"object"==typeof exports&&"undefined"!=typeof module?o(exports,require("@hookform/resolvers"),require("arktype")):"function"==typeof define&&define.amd?define(["exports","@hookform/resolvers","arktype"],o):o((e||self).hookformResolversArktype={},e.hookformResolvers,e.arktype)}(this,function(e,o,r){function t(e){for(var o=[].concat(e),r={};o.length;){var t=o[0],s=t.path.join(".");r[s]||(r[s]={message:t.message,type:t.code}),o.shift()}return r}e.arktypeResolver=function(e,s,n){return void 0===n&&(n={}),function(s,i,a){var f=e(s);return f instanceof r.ArkErrors?{values:{},errors:o.toNestErrors(t(f),a)}:(a.shouldUseNativeValidation&&o.validateFieldsNatively({},a),{errors:{},values:n.raw?Object.assign({},s):f})}}});
 //# sourceMappingURL=arktype.umd.js.map

package/arktype/dist/arktype.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"arktype.umd.js","sources":["../src/arktype.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { ArkErrors } from 'arktype';\nimport { FieldError, FieldErrors } from 'react-hook-form';\nimport type { Resolver } from './types';\n\nconst parseErrorSchema = (e: ArkErrors): Record<string, FieldError> => {\n  // copy code to type to match FieldError shape\n  e.forEach((e) => Object.assign(e, { type: e.code }));\n  // need to cast here because TS doesn't understand we added the type field\n  return e.byPath as never;\n};\n\nexport const arktypeResolver: Resolver =\n  (schema, _schemaOptions, resolverOptions = {}) =>\n  (values, _, options) => {\n    const out = schema(values);\n\n    if (out instanceof ArkErrors) {\n      return {\n        values: {},\n        errors: toNestErrors(parseErrorSchema(out), options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      errors: {} as FieldErrors,\n      values: resolverOptions.raw ? values : out,\n    };\n  };\n"],"names":["schema","_schemaOptions","resolverOptions","values","_","options","e","out","ArkErrors","errors","toNestErrors","forEach","Object","assign","type","code","byPath","shouldUseNativeValidation","validateFieldsNatively","raw"],"mappings":"wXAaE,SAACA,EAAQC,EAAgBC,GACzB,YADyBA,IAAAA,IAAAA,EAAkB,CAAA,GAC3C,SAACC,EAAQC,EAAGC,GACV,IAVsBC,EAUhBC,EAAMP,EAAOG,GAEnB,OAAII,aAAeC,EAAAA,UACV,CACLL,OAAQ,CAAE,EACVM,OAAQC,EAAYA,cAfFJ,EAeoBC,EAb5CD,EAAEK,QAAQ,SAACL,UAAMM,OAAOC,OAAOP,EAAG,CAAEQ,KAAMR,EAAES,MAAO,GAE5CT,EAAEU,QAWyCX,KAIhDA,EAAQY,2BAA6BC,EAAsBA,uBAAC,CAAE,EAAEb,GAEzD,CACLI,OAAQ,CAAiB,EACzBN,OAAQD,EAAgBiB,IAAMhB,EAASI,GAE3C,CAAC"}
+{"version":3,"file":"arktype.umd.js","sources":["../src/arktype.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { ArkErrors, Type } from 'arktype';\nimport { FieldError, FieldErrors, Resolver } from 'react-hook-form';\n\nfunction parseErrorSchema(arkErrors: ArkErrors): Record<string, FieldError> {\n  const errors = [...arkErrors];\n  const fieldsErrors: Record<string, FieldError> = {};\n\n  for (; errors.length; ) {\n    const error = errors[0];\n    const _path = error.path.join('.');\n\n    if (!fieldsErrors[_path]) {\n      fieldsErrors[_path] = { message: error.message, type: error.code };\n    }\n\n    errors.shift();\n  }\n\n  return fieldsErrors;\n}\n\n/**\n * Creates a resolver for react-hook-form using Arktype schema validation\n * @param {Schema} schema - The Arktype schema to validate against\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {string} [resolverOptions.mode='raw'] - Return the raw input values rather than the parsed values\n * @returns {Resolver<Schema['inferOut']>} A resolver function compatible with react-hook-form\n * @example\n * const schema = type({\n *   username: 'string>2'\n * });\n *\n * useForm({\n *   resolver: arktypeResolver(schema)\n * });\n */\nexport function arktypeResolver<Schema extends Type<any, any>>(\n  schema: Schema,\n  _schemaOptions?: never,\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Schema['inferOut']> {\n  return (values, _, options) => {\n    const out = schema(values);\n\n    if (out instanceof ArkErrors) {\n      return {\n        values: {},\n        errors: toNestErrors(parseErrorSchema(out), options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      errors: {} as FieldErrors,\n      values: resolverOptions.raw ? Object.assign({}, values) : out,\n    };\n  };\n}\n"],"names":["parseErrorSchema","arkErrors","errors","concat","fieldsErrors","length","error","_path","path","join","message","type","code","shift","schema","_schemaOptions","resolverOptions","values","_","options","out","ArkErrors","toNestErrors","shouldUseNativeValidation","validateFieldsNatively","raw","Object","assign"],"mappings":"sWAIA,SAASA,EAAiBC,GAIxB,IAHA,IAAMC,EAAMC,GAAAA,OAAOF,GACbG,EAA2C,CAAE,EAE5CF,EAAOG,QAAU,CACtB,IAAMC,EAAQJ,EAAO,GACfK,EAAQD,EAAME,KAAKC,KAAK,KAEzBL,EAAaG,KAChBH,EAAaG,GAAS,CAAEG,QAASJ,EAAMI,QAASC,KAAML,EAAMM,OAG9DV,EAAOW,OACT,CAEA,OAAOT,CACT,4BAkBEU,EACAC,EACAC,GAIA,gBAJAA,IAAAA,EAEI,CAAE,GAEEC,SAAAA,EAAQC,EAAGC,GACjB,IAAMC,EAAMN,EAAOG,GAEnB,OAAIG,aAAeC,YACV,CACLJ,OAAQ,CAAE,EACVf,OAAQoB,EAAAA,aAAatB,EAAiBoB,GAAMD,KAIhDA,EAAQI,2BAA6BC,yBAAuB,CAAA,EAAIL,GAEzD,CACLjB,OAAQ,GACRe,OAAQD,EAAgBS,IAAMC,OAAOC,OAAO,GAAIV,GAAUG,GAE9D,CACF"}

package/arktype/dist/index.d.ts

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

package/arktype/package.json

@@ -13,6 +13,6 @@
   "peerDependencies": {
     "react-hook-form": "^7.0.0",
     "@hookform/resolvers": "^2.0.0",
-    "arktype": "2.0.0-dev.14"
+    "arktype": "^2.0.0"
   }
 }

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

@@ -33,7 +33,7 @@ function TestComponent({ onSubmit }: Props) {
   );
 }
 
-test("form's native validation with Zod", async () => {
+test("form's native validation with Arktype", async () => {
   const handleSubmit = vi.fn();
   render(<TestComponent onSubmit={handleSubmit} />);
 
@@ -57,14 +57,14 @@ test("form's native validation with Zod", async () => {
   usernameField = screen.getByPlaceholderText(/username/i) as HTMLInputElement;
   expect(usernameField.validity.valid).toBe(false);
   expect(usernameField.validationMessage).toBe(
-    'username must be more than length 1',
+    'username must be at least length 2',
   );
 
   // password
   passwordField = screen.getByPlaceholderText(/password/i) as HTMLInputElement;
   expect(passwordField.validity.valid).toBe(false);
   expect(passwordField.validationMessage).toBe(
-    'password must be more than length 1',
+    'password must be at least length 2',
   );
 
   await user.type(screen.getByPlaceholderText(/username/i), 'joe');

package/arktype/src/__tests__/Form.tsx

@@ -12,16 +12,16 @@ const schema = type({
 
 type FormData = typeof schema.infer & { unusedProperty: string };
 
-interface Props {
-  onSubmit: (data: FormData) => void;
-}
-
-function TestComponent({ onSubmit }: Props) {
+function TestComponent({
+  onSubmit,
+}: {
+  onSubmit: (data: typeof schema.infer) => void;
+}) {
   const {
     register,
     handleSubmit,
     formState: { errors },
-  } = useForm<FormData>({
+  } = useForm({
     resolver: arktypeResolver(schema), // Useful to check TypeScript regressions
   });
 
@@ -47,10 +47,36 @@ test("form's validation with arkType and TypeScript's integration", async () =>
   await user.click(screen.getByText(/submit/i));
 
   expect(
-    screen.getByText('username must be more than length 1 (was 0)'),
+    screen.getByText('username must be at least length 2'),
   ).toBeInTheDocument();
   expect(
-    screen.getByText('password must be more than length 1 (was 0)'),
+    screen.getByText('password must be at least length 2'),
   ).toBeInTheDocument();
   expect(handleSubmit).not.toHaveBeenCalled();
 });
+
+export function TestComponentManualType({
+  onSubmit,
+}: {
+  onSubmit: (data: FormData) => void;
+}) {
+  const {
+    register,
+    handleSubmit,
+    formState: { errors },
+  } = useForm<typeof schema.infer, undefined, FormData>({
+    resolver: arktypeResolver(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/arktype/src/__tests__/__fixtures__/data.ts

@@ -7,7 +7,7 @@ export const schema = type({
   repeatPassword: 'string>1',
   accessToken: 'string|number',
   birthYear: '1900<number<2013',
-  email: 'email',
+  email: 'string.email',
   tags: 'string[]',
   enabled: 'boolean',
   url: 'string>1',
@@ -43,7 +43,7 @@ export const invalidData = {
   birthYear: 'birthYear',
   like: [{ id: 'z' }],
   url: 'abc',
-};
+} as any as typeof schema.infer;
 
 export const fields: Record<InternalFieldName, Field['_f']> = {
   username: {