@hookform/resolvers 3.1.1 → 3.2.0

package/README.md

@@ -26,18 +26,28 @@
 
 ### Supported resolvers
 
-- [Yup](#Yup)
-- [Zod](#Zod)
-- [Superstruct](#Superstruct)
-- [Joi](#Joi)
-- [Class Validator](#Class-Validator)
-- [io-ts](#io-ts)
-- [Nope](#Nope)
-- [computed-types](#computed-types)
-- [typanion](#typanion)
-- [Ajv](#Ajv)
-- [TypeBox](#TypeBox)
-- [ArkType](#ArkType)
+- [Install](#install)
+- [Links](#links)
+  - [Supported resolvers](#supported-resolvers)
+- [API](#api)
+- [Quickstart](#quickstart)
+  - [Yup](#yup)
+  - [Zod](#zod)
+  - [Superstruct](#superstruct)
+  - [Joi](#joi)
+  - [Vest](#vest)
+  - [Class Validator](#class-validator)
+  - [io-ts](#io-ts)
+  - [Nope](#nope)
+  - [computed-types](#computed-types)
+  - [typanion](#typanion)
+  - [Ajv](#ajv)
+  - [TypeBox](#typebox)
+  - [ArkType](#arktype)
+  - [Valibot](#valibot)
+- [Backers](#backers)
+  - [Sponsors](#sponsors)
+- [Contributors](#contributors)
 
 ## API
 
@@ -532,6 +542,40 @@ const App = () => {
 };
 ```
 
+### [Valibot](https://github.com/fabian-hiller/valibot)
+
+The modular and type safe schema library for validating structural data
+
+[![npm](https://img.shields.io/bundlephobia/minzip/valibot?style=for-the-badge)](https://bundlephobia.com/result?p=valibot)
+
+```typescript jsx
+import { useForm } from 'react-hook-form';
+import { valibotResolver } from '@hookform/resolvers/valibot';
+import { object, string, minLength, endsWith } from 'valibot';
+
+const schema = object({
+  username: string('username is required', [
+    minLength(3, 'Needs to be at least 3 characters'),
+    endsWith('cool', 'Needs to end with `cool`'),
+  ]),
+  password: string('password is required'),
+});
+
+const App = () => {
+  const { register, handleSubmit } = useForm({
+    resolver: valibotResolver(schema),
+  });
+
+  return (
+    <form onSubmit={handleSubmit((d) => console.log(d))}>
+      <input {...register('username')} />
+      <input type="password" {...register('password')} />
+      <input type="submit" />
+    </form>
+  );
+};
+```
+
 ## Backers
 
 Thanks goes to all our backers! [[Become a backer](https://opencollective.com/react-hook-form#backer)].

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hookform/resolvers",
   "amdName": "hookformResolvers",
-  "version": "3.1.1",
+  "version": "3.2.0",
   "description": "React Hook Form validation resolvers: Yup, Joi, Superstruct, Zod, Vest, Class Validator, io-ts, Nope, computed-types, TypeBox, arktype and Typanion",
   "main": "dist/resolvers.js",
   "module": "dist/resolvers.module.js",
@@ -93,6 +93,12 @@
       "import": "./arktype/dist/arktype.mjs",
       "require": "./arktype/dist/arktype.js"
     },
+    "./valibot": {
+      "types": "./valibot/dist/index.d.ts",
+      "umd": "./valibot/dist/valibot.umd.js",
+      "import": "./valibot/dist/valibot.mjs",
+      "require": "./valibot/dist/valibot.js"
+    },
     "./package.json": "./package.json",
     "./*": "./*"
   },
@@ -136,7 +142,10 @@
     "typebox/dist",
     "arktype/package.json",
     "arktype/src",
-    "arktype/dist"
+    "arktype/dist",
+    "valibot/package.json",
+    "valibot/src",
+    "valibot/dist"
   ],
   "publishConfig": {
     "access": "public"
@@ -158,6 +167,7 @@
     "build:ajv": "microbundle --cwd ajv --globals @hookform/resolvers=hookformResolvers,react-hook-form=ReactHookForm",
     "build:typebox": "microbundle --cwd typebox --globals @hookform/resolvers=hookformResolvers,react-hook-form=ReactHookForm,@sinclair/typebox/value=value",
     "build:arktype": "microbundle --cwd arktype --globals @hookform/resolvers=hookformResolvers,react-hook-form=ReactHookForm",
+    "build:valibot": "microbundle --cwd valibot --globals @hookform/resolvers=hookformResolvers,react-hook-form=ReactHookForm",
     "postbuild": "node ./config/node-13-exports.js",
     "lint": "eslint . --ext .ts,.js --ignore-path .gitignore",
     "lint:types": "tsc",
@@ -238,6 +248,7 @@
     "superstruct": "^1.0.3",
     "typanion": "^3.12.1",
     "typescript": "^5.0.4",
+    "valibot": "^0.8.0",
     "vest": "^4.6.9",
     "vite": "^4.2.1",
     "vite-tsconfig-paths": "^4.2.0",

package/valibot/dist/index.d.ts

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

package/valibot/dist/types.d.ts

@@ -0,0 +1,13 @@
+import { FieldValues, ResolverResult, ResolverOptions } from 'react-hook-form';
+import { BaseSchema, BaseSchemaAsync, ParseInfo } from 'valibot';
+export type Resolver = <T extends BaseSchema | BaseSchemaAsync>(schema: T, schemaOptions?: Partial<Pick<ParseInfo, 'abortEarly' | 'abortPipeEarly'>>, resolverOptions?: {
+    /**
+     * @default async
+     */
+    mode?: 'sync' | 'async';
+    /**
+     * Return the raw input values rather than the parsed values.
+     * @default false
+     */
+    raw?: boolean;
+}) => <TFieldValues extends FieldValues, TContext>(values: TFieldValues, context: TContext | undefined, options: ResolverOptions<TFieldValues>) => Promise<ResolverResult<TFieldValues>>;

package/valibot/dist/valibot.d.ts

@@ -0,0 +1,2 @@
+import type { Resolver } from './types';
+export declare const valibotResolver: Resolver;

package/valibot/dist/valibot.js

@@ -0,0 +1,2 @@
+var r=require("@hookform/resolvers"),e=require("valibot"),t=function(r){var e=r.issues.reduce(function(r,e){if(e.path){var t=e.path.map(function(r){return r.key}).join(".");r[t]=[].concat(r[t]||[],[{message:e.message,type:e.validation}])}return r},{});return Object.entries(e).reduce(function(r,e){var t=e[1][0];return r[e[0]]={message:t.message,type:t.type},r},{})};exports.valibotResolver=function(n,o,s){return void 0===o&&(o={abortEarly:!1,abortPipeEarly:!1}),void 0===s&&(s={mode:"async",raw:!1}),function(a,i,u){try{return Promise.resolve(function(r,t){try{var i=function(){function r(r){return{values:i?a:r,errors:{}}}var t=s.mode,i=s.raw;return"sync"===t?r("sync"===t?e.parse(n,a,o):e.parseAsync(n,a,o)):Promise.resolve("sync"===t?e.parse(n,a,o):e.parseAsync(n,a,o)).then(r)}()}catch(r){return t(r)}return i&&i.then?i.then(void 0,t):i}(0,function(n){if(n instanceof e.ValiError)return{values:{},errors:r.toNestError(t(n),u)};throw n}))}catch(r){return Promise.reject(r)}}};
+//# sourceMappingURL=valibot.js.map

package/valibot/dist/valibot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"valibot.js","sources":["../src/valibot.ts"],"sourcesContent":["import { toNestError } from '@hookform/resolvers';\nimport type { Resolver } from './types';\nimport {\n  BaseSchema,\n  BaseSchemaAsync,\n  ValiError,\n  parse,\n  parseAsync,\n} from 'valibot';\nimport { FieldErrors, FieldError } from 'react-hook-form';\n\ntype FlatErrors = Record<string, [FieldError, ...FieldError[]]>;\n\nconst parseErrors = (error: ValiError): FieldErrors => {\n  const errors = error.issues.reduce<FlatErrors>((flatErrors, issue) => {\n    if (issue.path) {\n      const path = issue.path.map(({ key }) => key).join('.');\n      flatErrors[path] = [\n        ...(flatErrors[path] || []),\n        {\n          message: issue.message,\n          type: issue.validation,\n        },\n      ];\n    }\n\n    return flatErrors;\n  }, {});\n\n  return Object.entries(errors).reduce<FieldErrors>((acc, [path, errors]) => {\n    const [firstError] = errors;\n    acc[path] = {\n      message: firstError.message,\n      type: firstError.type,\n    };\n\n    return acc;\n  }, {});\n};\n\nexport const valibotResolver: Resolver =\n  (\n    schema,\n    schemaOptions = {\n      abortEarly: false,\n      abortPipeEarly: false,\n    },\n    resolverOptions = {\n      mode: 'async',\n      raw: false,\n    },\n  ) =>\n  async (values, _, options) => {\n    try {\n      const { mode, raw } = resolverOptions;\n      const parsed =\n        mode === 'sync'\n          ? parse(schema as BaseSchema, values, schemaOptions)\n          : await parseAsync(\n              schema as BaseSchema | BaseSchemaAsync,\n              values,\n              schemaOptions,\n            );\n\n      return { values: raw ? values : parsed, errors: {} as FieldErrors };\n    } catch (error) {\n      if (error instanceof ValiError) {\n        return {\n          values: {},\n          errors: toNestError(parseErrors(error), options),\n        };\n      }\n\n      throw error;\n    }\n  };\n"],"names":["parseErrors","error","errors","issues","reduce","flatErrors","issue","path","map","_ref","key","join","concat","message","type","validation","Object","entries","acc","_ref2","firstError","schema","schemaOptions","resolverOptions","values","abortEarly","abortPipeEarly","mode","raw","_","options","Promise","resolve","_temp","parsed","parse","parseAsync","then","_catch","ValiError","toNestError","e","reject"],"mappings":"0DAaMA,EAAc,SAACC,GACnB,IAAMC,EAASD,EAAME,OAAOC,OAAmB,SAACC,EAAYC,GAC1D,GAAIA,EAAMC,KAAM,CACd,IAAMA,EAAOD,EAAMC,KAAKC,IAAI,SAAAC,UAAMA,EAAHC,GAAa,GAAEC,KAAK,KACnDN,EAAWE,GAAKK,GAAAA,OACVP,EAAWE,IAAS,GAAE,CAC1B,CACEM,QAASP,EAAMO,QACfC,KAAMR,EAAMS,aAGjB,CAED,OAAOV,CACT,EAAG,CAAA,GAEH,OAAOW,OAAOC,QAAQf,GAAQE,OAAoB,SAACc,EAAGC,GAAoB,IACjEC,EAD4DD,KACxC,GAM3B,OALAD,EAF2DC,EAAA,IAE/C,CACVN,QAASO,EAAWP,QACpBC,KAAMM,EAAWN,MAGZI,CACT,EAAG,GACL,0BAGE,SACEG,EACAC,EAIAC,GAKKC,YATQ,IAAbF,IAAAA,EAAgB,CACdG,YAAY,EACZC,gBAAgB,SAEH,IAAfH,IAAAA,EAAkB,CAChBI,KAAM,QACNC,KAAK,IAGFJ,SAAAA,EAAQK,EAAGC,GAAO,IAAIC,OAAAA,QAAAC,gCAAA,WACvBC,SAAAA,EAEIC,GASN,MAAO,CAAEV,OAAQI,EAAMJ,EAASU,EAAQhC,OAAQ,GAAoB,CAVpE,IAAQyB,EAAcJ,EAAdI,KAAMC,EAAQL,EAARK,IAAwB,MAE3B,SAATD,EAAeM,EAAN,SAATN,EACIQ,EAAAA,MAAMd,EAAsBG,EAAQF,GAC9Bc,EAAAA,WACJf,EACAG,EACAF,IACDS,QAAAC,QANI,SAATL,EACIQ,EAAAA,MAAMd,EAAsBG,EAAQF,GAC9Bc,EAAAA,WACJf,EACAG,EACAF,IACDe,KAAAJ,EAGR,6DAb0BK,CAAA,EAa1B,SAAQrC,GACP,GAAIA,aAAiBsC,YACnB,MAAO,CACLf,OAAQ,GACRtB,OAAQsC,EAAAA,YAAYxC,EAAYC,GAAQ6B,IAI5C,MAAM7B,CACP,GACH,CAAC,MAAAwC,UAAAV,QAAAW,OAAAD,EAAA,CAAA,CAAA"}

package/valibot/dist/valibot.mjs

@@ -0,0 +1,2 @@
+import{toNestError as r}from"@hookform/resolvers";import{parse as e,parseAsync as t,ValiError as n}from"valibot";var o=function(r){var e=r.issues.reduce(function(r,e){if(e.path){var t=e.path.map(function(r){return r.key}).join(".");r[t]=[].concat(r[t]||[],[{message:e.message,type:e.validation}])}return r},{});return Object.entries(e).reduce(function(r,e){var t=e[1][0];return r[e[0]]={message:t.message,type:t.type},r},{})},a=function(a,i,s){return void 0===i&&(i={abortEarly:!1,abortPipeEarly:!1}),void 0===s&&(s={mode:"async",raw:!1}),function(u,c,f){try{return Promise.resolve(function(r,n){try{var o=function(){function r(r){return{values:o?u:r,errors:{}}}var n=s.mode,o=s.raw;return"sync"===n?r("sync"===n?e(a,u,i):t(a,u,i)):Promise.resolve("sync"===n?e(a,u,i):t(a,u,i)).then(r)}()}catch(r){return n(r)}return o&&o.then?o.then(void 0,n):o}(0,function(e){if(e instanceof n)return{values:{},errors:r(o(e),f)};throw e}))}catch(r){return Promise.reject(r)}}};export{a as valibotResolver};
+//# sourceMappingURL=valibot.module.js.map

package/valibot/dist/valibot.modern.mjs

@@ -0,0 +1,2 @@
+import{toNestError as e}from"@hookform/resolvers";import{parse as r,parseAsync as t,ValiError as s}from"valibot";const o=e=>{const r=e.issues.reduce((e,r)=>{if(r.path){const t=r.path.map(({key:e})=>e).join(".");e[t]=[...e[t]||[],{message:r.message,type:r.validation}]}return e},{});return Object.entries(r).reduce((e,[r,t])=>{const[s]=t;return e[r]={message:s.message,type:s.type},e},{})},a=(a,n={abortEarly:!1,abortPipeEarly:!1},c={mode:"async",raw:!1})=>async(i,m,p)=>{try{const{mode:e,raw:s}=c,o="sync"===e?r(a,i,n):await t(a,i,n);return{values:s?i:o,errors:{}}}catch(r){if(r instanceof s)return{values:{},errors:e(o(r),p)};throw r}};export{a as valibotResolver};
+//# sourceMappingURL=valibot.modern.mjs.map

package/valibot/dist/valibot.modern.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"valibot.modern.mjs","sources":["../src/valibot.ts"],"sourcesContent":["import { toNestError } from '@hookform/resolvers';\nimport type { Resolver } from './types';\nimport {\n  BaseSchema,\n  BaseSchemaAsync,\n  ValiError,\n  parse,\n  parseAsync,\n} from 'valibot';\nimport { FieldErrors, FieldError } from 'react-hook-form';\n\ntype FlatErrors = Record<string, [FieldError, ...FieldError[]]>;\n\nconst parseErrors = (error: ValiError): FieldErrors => {\n  const errors = error.issues.reduce<FlatErrors>((flatErrors, issue) => {\n    if (issue.path) {\n      const path = issue.path.map(({ key }) => key).join('.');\n      flatErrors[path] = [\n        ...(flatErrors[path] || []),\n        {\n          message: issue.message,\n          type: issue.validation,\n        },\n      ];\n    }\n\n    return flatErrors;\n  }, {});\n\n  return Object.entries(errors).reduce<FieldErrors>((acc, [path, errors]) => {\n    const [firstError] = errors;\n    acc[path] = {\n      message: firstError.message,\n      type: firstError.type,\n    };\n\n    return acc;\n  }, {});\n};\n\nexport const valibotResolver: Resolver =\n  (\n    schema,\n    schemaOptions = {\n      abortEarly: false,\n      abortPipeEarly: false,\n    },\n    resolverOptions = {\n      mode: 'async',\n      raw: false,\n    },\n  ) =>\n  async (values, _, options) => {\n    try {\n      const { mode, raw } = resolverOptions;\n      const parsed =\n        mode === 'sync'\n          ? parse(schema as BaseSchema, values, schemaOptions)\n          : await parseAsync(\n              schema as BaseSchema | BaseSchemaAsync,\n              values,\n              schemaOptions,\n            );\n\n      return { values: raw ? values : parsed, errors: {} as FieldErrors };\n    } catch (error) {\n      if (error instanceof ValiError) {\n        return {\n          values: {},\n          errors: toNestError(parseErrors(error), options),\n        };\n      }\n\n      throw error;\n    }\n  };\n"],"names":["parseErrors","error","errors","issues","reduce","flatErrors","issue","path","map","key","join","message","type","validation","Object","entries","acc","firstError","valibotResolver","schema","schemaOptions","abortEarly","abortPipeEarly","resolverOptions","mode","raw","async","values","_","options","parsed","parse","parseAsync","ValiError","toNestError"],"mappings":"iHAaA,MAAMA,EAAeC,IACnB,MAAMC,EAASD,EAAME,OAAOC,OAAmB,CAACC,EAAYC,KAC1D,GAAIA,EAAMC,KAAM,CACd,MAAMA,EAAOD,EAAMC,KAAKC,IAAI,EAAGC,SAAUA,GAAKC,KAAK,KACnDL,EAAWE,GAAQ,IACbF,EAAWE,IAAS,GACxB,CACEI,QAASL,EAAMK,QACfC,KAAMN,EAAMO,YAGjB,CAED,OAAOR,GACN,CAAE,GAEL,OAAOS,OAAOC,QAAQb,GAAQE,OAAoB,CAACY,GAAMT,EAAML,MAC7D,MAAOe,GAAcf,EAMrB,OALAc,EAAIT,GAAQ,CACVI,QAASM,EAAWN,QACpBC,KAAMK,EAAWL,MAGZI,GACN,CAAA,EAAE,EAGME,EACXA,CACEC,EACAC,EAAgB,CACdC,YAAY,EACZC,gBAAgB,GAElBC,EAAkB,CAChBC,KAAM,QACNC,KAAK,KAGTC,MAAOC,EAAQC,EAAGC,KAChB,IACE,MAAML,KAAEA,EAAIC,IAAEA,GAAQF,EAChBO,EACK,SAATN,EACIO,EAAMZ,EAAsBQ,EAAQP,SAC9BY,EACJb,EACAQ,EACAP,GAGR,MAAO,CAAEO,OAAQF,EAAME,EAASG,EAAQ5B,OAAQ,GACjD,CAAC,MAAOD,GACP,GAAIA,aAAiBgC,EACnB,MAAO,CACLN,OAAQ,CAAE,EACVzB,OAAQgC,EAAYlC,EAAYC,GAAQ4B,IAI5C,MAAM5B,CACP"}

package/valibot/dist/valibot.module.js

@@ -0,0 +1,2 @@
+import{toNestError as r}from"@hookform/resolvers";import{parse as e,parseAsync as t,ValiError as n}from"valibot";var o=function(r){var e=r.issues.reduce(function(r,e){if(e.path){var t=e.path.map(function(r){return r.key}).join(".");r[t]=[].concat(r[t]||[],[{message:e.message,type:e.validation}])}return r},{});return Object.entries(e).reduce(function(r,e){var t=e[1][0];return r[e[0]]={message:t.message,type:t.type},r},{})},a=function(a,i,s){return void 0===i&&(i={abortEarly:!1,abortPipeEarly:!1}),void 0===s&&(s={mode:"async",raw:!1}),function(u,c,f){try{return Promise.resolve(function(r,n){try{var o=function(){function r(r){return{values:o?u:r,errors:{}}}var n=s.mode,o=s.raw;return"sync"===n?r("sync"===n?e(a,u,i):t(a,u,i)):Promise.resolve("sync"===n?e(a,u,i):t(a,u,i)).then(r)}()}catch(r){return n(r)}return o&&o.then?o.then(void 0,n):o}(0,function(e){if(e instanceof n)return{values:{},errors:r(o(e),f)};throw e}))}catch(r){return Promise.reject(r)}}};export{a as valibotResolver};
+//# sourceMappingURL=valibot.module.js.map

package/valibot/dist/valibot.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"valibot.module.js","sources":["../src/valibot.ts"],"sourcesContent":["import { toNestError } from '@hookform/resolvers';\nimport type { Resolver } from './types';\nimport {\n  BaseSchema,\n  BaseSchemaAsync,\n  ValiError,\n  parse,\n  parseAsync,\n} from 'valibot';\nimport { FieldErrors, FieldError } from 'react-hook-form';\n\ntype FlatErrors = Record<string, [FieldError, ...FieldError[]]>;\n\nconst parseErrors = (error: ValiError): FieldErrors => {\n  const errors = error.issues.reduce<FlatErrors>((flatErrors, issue) => {\n    if (issue.path) {\n      const path = issue.path.map(({ key }) => key).join('.');\n      flatErrors[path] = [\n        ...(flatErrors[path] || []),\n        {\n          message: issue.message,\n          type: issue.validation,\n        },\n      ];\n    }\n\n    return flatErrors;\n  }, {});\n\n  return Object.entries(errors).reduce<FieldErrors>((acc, [path, errors]) => {\n    const [firstError] = errors;\n    acc[path] = {\n      message: firstError.message,\n      type: firstError.type,\n    };\n\n    return acc;\n  }, {});\n};\n\nexport const valibotResolver: Resolver =\n  (\n    schema,\n    schemaOptions = {\n      abortEarly: false,\n      abortPipeEarly: false,\n    },\n    resolverOptions = {\n      mode: 'async',\n      raw: false,\n    },\n  ) =>\n  async (values, _, options) => {\n    try {\n      const { mode, raw } = resolverOptions;\n      const parsed =\n        mode === 'sync'\n          ? parse(schema as BaseSchema, values, schemaOptions)\n          : await parseAsync(\n              schema as BaseSchema | BaseSchemaAsync,\n              values,\n              schemaOptions,\n            );\n\n      return { values: raw ? values : parsed, errors: {} as FieldErrors };\n    } catch (error) {\n      if (error instanceof ValiError) {\n        return {\n          values: {},\n          errors: toNestError(parseErrors(error), options),\n        };\n      }\n\n      throw error;\n    }\n  };\n"],"names":["parseErrors","error","errors","issues","reduce","flatErrors","issue","path","map","_ref","key","join","concat","message","type","validation","Object","entries","acc","_ref2","firstError","valibotResolver","schema","schemaOptions","resolverOptions","values","abortEarly","abortPipeEarly","mode","raw","_","options","Promise","resolve","_temp","parsed","parse","parseAsync","then","_catch","ValiError","toNestError","e","reject"],"mappings":"iHAaA,IAAMA,EAAc,SAACC,GACnB,IAAMC,EAASD,EAAME,OAAOC,OAAmB,SAACC,EAAYC,GAC1D,GAAIA,EAAMC,KAAM,CACd,IAAMA,EAAOD,EAAMC,KAAKC,IAAI,SAAAC,UAAMA,EAAHC,GAAa,GAAEC,KAAK,KACnDN,EAAWE,GAAKK,GAAAA,OACVP,EAAWE,IAAS,GAAE,CAC1B,CACEM,QAASP,EAAMO,QACfC,KAAMR,EAAMS,aAGjB,CAED,OAAOV,CACT,EAAG,CAAA,GAEH,OAAOW,OAAOC,QAAQf,GAAQE,OAAoB,SAACc,EAAGC,GAAoB,IACjEC,EAD4DD,KACxC,GAM3B,OALAD,EAF2DC,EAAA,IAE/C,CACVN,QAASO,EAAWP,QACpBC,KAAMM,EAAWN,MAGZI,CACT,EAAG,GACL,EAEaG,EACX,SACEC,EACAC,EAIAC,GAKKC,YATQ,IAAbF,IAAAA,EAAgB,CACdG,YAAY,EACZC,gBAAgB,SAEH,IAAfH,IAAAA,EAAkB,CAChBI,KAAM,QACNC,KAAK,IAGFJ,SAAAA,EAAQK,EAAGC,GAAO,IAAIC,OAAAA,QAAAC,gCAAA,WACvBC,SAAAA,EAEIC,GASN,MAAO,CAAEV,OAAQI,EAAMJ,EAASU,EAAQjC,OAAQ,GAAoB,CAVpE,IAAQ0B,EAAcJ,EAAdI,KAAMC,EAAQL,EAARK,IAAwB,MAE3B,SAATD,EAAeM,EAAN,SAATN,EACIQ,EAAMd,EAAsBG,EAAQF,GAC9Bc,EACJf,EACAG,EACAF,IACDS,QAAAC,QANI,SAATL,EACIQ,EAAMd,EAAsBG,EAAQF,GAC9Bc,EACJf,EACAG,EACAF,IACDe,KAAAJ,EAGR,6DAb0BK,CAAA,EAa1B,SAAQtC,GACP,GAAIA,aAAiBuC,EACnB,MAAO,CACLf,OAAQ,GACRvB,OAAQuC,EAAYzC,EAAYC,GAAQ8B,IAI5C,MAAM9B,CACP,GACH,CAAC,MAAAyC,UAAAV,QAAAW,OAAAD,EAAA,CAAA,CAAA"}

package/valibot/dist/valibot.umd.js

@@ -0,0 +1,2 @@
+!function(e,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports,require("@hookform/resolvers"),require("valibot")):"function"==typeof define&&define.amd?define(["exports","@hookform/resolvers","valibot"],r):r((e||self).hookformResolversValibot={},e.hookformResolvers,e.valibot)}(this,function(e,r,o){var t=function(e){var r=e.issues.reduce(function(e,r){if(r.path){var o=r.path.map(function(e){return e.key}).join(".");e[o]=[].concat(e[o]||[],[{message:r.message,type:r.validation}])}return e},{});return Object.entries(r).reduce(function(e,r){var o=r[1][0];return e[r[0]]={message:o.message,type:o.type},e},{})};e.valibotResolver=function(e,n,s){return void 0===n&&(n={abortEarly:!1,abortPipeEarly:!1}),void 0===s&&(s={mode:"async",raw:!1}),function(i,a,u){try{return Promise.resolve(function(r,t){try{var a=function(){function r(e){return{values:a?i:e,errors:{}}}var t=s.mode,a=s.raw;return"sync"===t?r("sync"===t?o.parse(e,i,n):o.parseAsync(e,i,n)):Promise.resolve("sync"===t?o.parse(e,i,n):o.parseAsync(e,i,n)).then(r)}()}catch(e){return t(e)}return a&&a.then?a.then(void 0,t):a}(0,function(e){if(e instanceof o.ValiError)return{values:{},errors:r.toNestError(t(e),u)};throw e}))}catch(e){return Promise.reject(e)}}}});
+//# sourceMappingURL=valibot.umd.js.map

package/valibot/dist/valibot.umd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"valibot.umd.js","sources":["../src/valibot.ts"],"sourcesContent":["import { toNestError } from '@hookform/resolvers';\nimport type { Resolver } from './types';\nimport {\n  BaseSchema,\n  BaseSchemaAsync,\n  ValiError,\n  parse,\n  parseAsync,\n} from 'valibot';\nimport { FieldErrors, FieldError } from 'react-hook-form';\n\ntype FlatErrors = Record<string, [FieldError, ...FieldError[]]>;\n\nconst parseErrors = (error: ValiError): FieldErrors => {\n  const errors = error.issues.reduce<FlatErrors>((flatErrors, issue) => {\n    if (issue.path) {\n      const path = issue.path.map(({ key }) => key).join('.');\n      flatErrors[path] = [\n        ...(flatErrors[path] || []),\n        {\n          message: issue.message,\n          type: issue.validation,\n        },\n      ];\n    }\n\n    return flatErrors;\n  }, {});\n\n  return Object.entries(errors).reduce<FieldErrors>((acc, [path, errors]) => {\n    const [firstError] = errors;\n    acc[path] = {\n      message: firstError.message,\n      type: firstError.type,\n    };\n\n    return acc;\n  }, {});\n};\n\nexport const valibotResolver: Resolver =\n  (\n    schema,\n    schemaOptions = {\n      abortEarly: false,\n      abortPipeEarly: false,\n    },\n    resolverOptions = {\n      mode: 'async',\n      raw: false,\n    },\n  ) =>\n  async (values, _, options) => {\n    try {\n      const { mode, raw } = resolverOptions;\n      const parsed =\n        mode === 'sync'\n          ? parse(schema as BaseSchema, values, schemaOptions)\n          : await parseAsync(\n              schema as BaseSchema | BaseSchemaAsync,\n              values,\n              schemaOptions,\n            );\n\n      return { values: raw ? values : parsed, errors: {} as FieldErrors };\n    } catch (error) {\n      if (error instanceof ValiError) {\n        return {\n          values: {},\n          errors: toNestError(parseErrors(error), options),\n        };\n      }\n\n      throw error;\n    }\n  };\n"],"names":["parseErrors","error","errors","issues","reduce","flatErrors","issue","path","map","_ref","key","join","concat","message","type","validation","Object","entries","acc","_ref2","firstError","schema","schemaOptions","resolverOptions","values","abortEarly","abortPipeEarly","mode","raw","_","options","Promise","resolve","_temp","parsed","parse","parseAsync","then","_catch","ValiError","toNestError","e","reject"],"mappings":"sWAaA,IAAMA,EAAc,SAACC,GACnB,IAAMC,EAASD,EAAME,OAAOC,OAAmB,SAACC,EAAYC,GAC1D,GAAIA,EAAMC,KAAM,CACd,IAAMA,EAAOD,EAAMC,KAAKC,IAAI,SAAAC,UAAMA,EAAHC,GAAa,GAAEC,KAAK,KACnDN,EAAWE,GAAKK,GAAAA,OACVP,EAAWE,IAAS,GAAE,CAC1B,CACEM,QAASP,EAAMO,QACfC,KAAMR,EAAMS,aAGjB,CAED,OAAOV,CACT,EAAG,CAAA,GAEH,OAAOW,OAAOC,QAAQf,GAAQE,OAAoB,SAACc,EAAGC,GAAoB,IACjEC,EAD4DD,KACxC,GAM3B,OALAD,EAF2DC,EAAA,IAE/C,CACVN,QAASO,EAAWP,QACpBC,KAAMM,EAAWN,MAGZI,CACT,EAAG,GACL,oBAGE,SACEG,EACAC,EAIAC,GAKKC,YATQ,IAAbF,IAAAA,EAAgB,CACdG,YAAY,EACZC,gBAAgB,SAEH,IAAfH,IAAAA,EAAkB,CAChBI,KAAM,QACNC,KAAK,IAGFJ,SAAAA,EAAQK,EAAGC,GAAO,IAAIC,OAAAA,QAAAC,gCAAA,WACvBC,SAAAA,EAEIC,GASN,MAAO,CAAEV,OAAQI,EAAMJ,EAASU,EAAQhC,OAAQ,GAAoB,CAVpE,IAAQyB,EAAcJ,EAAdI,KAAMC,EAAQL,EAARK,IAAwB,MAE3B,SAATD,EAAeM,EAAN,SAATN,EACIQ,EAAAA,MAAMd,EAAsBG,EAAQF,GAC9Bc,EAAAA,WACJf,EACAG,EACAF,IACDS,QAAAC,QANI,SAATL,EACIQ,EAAAA,MAAMd,EAAsBG,EAAQF,GAC9Bc,EAAAA,WACJf,EACAG,EACAF,IACDe,KAAAJ,EAGR,6DAb0BK,CAAA,EAa1B,SAAQrC,GACP,GAAIA,aAAiBsC,YACnB,MAAO,CACLf,OAAQ,GACRtB,OAAQsC,EAAAA,YAAYxC,EAAYC,GAAQ6B,IAI5C,MAAM7B,CACP,GACH,CAAC,MAAAwC,UAAAV,QAAAW,OAAAD,EAAA,CAAA,CAAA"}

package/valibot/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@hookform/resolvers/valibot",
+  "amdName": "hookformResolversValibot",
+  "version": "1.0.0",
+  "private": true,
+  "description": "React Hook Form validation resolver: valibot",
+  "main": "dist/valibot.js",
+  "module": "dist/valibot.module.js",
+  "umd:main": "dist/valibot.umd.js",
+  "source": "src/index.ts",
+  "types": "dist/index.d.ts",
+  "license": "MIT",
+  "peerDependencies": {
+    "react-hook-form": "^7.0.0",
+    "@hookform/resolvers": "^2.0.0",
+    "valibot": ">=0.8"
+  }
+}

package/valibot/src/__tests__/__fixtures__/data.ts

@@ -0,0 +1,88 @@
+import { Field, InternalFieldName } from 'react-hook-form';
+import {
+  object,
+  string,
+  minLength,
+  maxLength,
+  regex,
+  number,
+  minValue,
+  maxValue,
+  email,
+  array,
+  boolean,
+  required,
+} from 'valibot';
+
+export const schema = required(
+  object({
+    username: string([minLength(2), maxLength(30), regex(/^\w+$/)]),
+    password: string('New Password is required', [
+      regex(new RegExp('.*[A-Z].*'), 'One uppercase character'),
+      regex(new RegExp('.*[a-z].*'), 'One lowercase character'),
+      regex(new RegExp('.*\\d.*'), 'One number'),
+      regex(
+        new RegExp('.*[`~<>?,./!@#$%^&*()\\-_+="\'|{}\\[\\];:\\\\].*'),
+        'One special character',
+      ),
+      minLength(8, 'Must be at least 8 characters in length'),
+    ]),
+    repeatPassword: string('Repeat Password is required'),
+    accessToken: string('Access token is required'),
+    birthYear: number('Please enter your birth year', [
+      minValue(1900),
+      maxValue(2013),
+    ]),
+    email: string([email('Invalid email address')]),
+    tags: array(string('Tags should be strings')),
+    enabled: boolean(),
+    like: required(
+      object({
+        id: number('Like id is required'),
+        name: string('Like name is required', [minLength(4, 'Too short')]),
+      }),
+    ),
+  }),
+);
+
+export const validData = {
+  username: 'Doe',
+  password: 'Password123_',
+  repeatPassword: 'Password123_',
+  birthYear: 2000,
+  email: 'john@doe.com',
+  tags: ['tag1', 'tag2'],
+  enabled: true,
+  accessToken: 'accessToken',
+  like: {
+    id: 1,
+    name: 'name',
+  },
+};
+
+export const invalidData = {
+  password: '___',
+  email: '',
+  birthYear: 'birthYear',
+  like: { id: 'z' },
+  tags: [1, 2, 3],
+};
+
+export const fields: Record<InternalFieldName, Field['_f']> = {
+  username: {
+    ref: { name: 'username' },
+    name: 'username',
+  },
+  password: {
+    ref: { name: 'password' },
+    name: 'password',
+  },
+  email: {
+    ref: { name: 'email' },
+    name: 'email',
+  },
+  birthday: {
+    ref: { name: 'birthday' },
+    name: 'birthday',
+  },
+};

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

@@ -0,0 +1,79 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`valibotResolver > should return a single error from valibotResolver when validation fails 1`] = `
+{
+  "errors": {
+    "accessToken": {
+      "message": "Invalid type",
+      "ref": undefined,
+      "type": "non_optional",
+    },
+    "birthYear": {
+      "message": "Please enter your birth year",
+      "ref": undefined,
+      "type": "number",
+    },
+    "email": {
+      "message": "Invalid email address",
+      "ref": {
+        "name": "email",
+      },
+      "type": "email",
+    },
+    "enabled": {
+      "message": "Invalid type",
+      "ref": undefined,
+      "type": "non_optional",
+    },
+    "like": {
+      "id": {
+        "message": "Like id is required",
+        "ref": undefined,
+        "type": "number",
+      },
+      "name": {
+        "message": "Invalid type",
+        "ref": undefined,
+        "type": "non_optional",
+      },
+    },
+    "password": {
+      "message": "One uppercase character",
+      "ref": {
+        "name": "password",
+      },
+      "type": "regex",
+    },
+    "repeatPassword": {
+      "message": "Invalid type",
+      "ref": undefined,
+      "type": "non_optional",
+    },
+    "tags": [
+      {
+        "message": "Tags should be strings",
+        "ref": undefined,
+        "type": "string",
+      },
+      {
+        "message": "Tags should be strings",
+        "ref": undefined,
+        "type": "string",
+      },
+      {
+        "message": "Tags should be strings",
+        "ref": undefined,
+        "type": "string",
+      },
+    ],
+    "username": {
+      "message": "Invalid type",
+      "ref": {
+        "name": "username",
+      },
+      "type": "non_optional",
+    },
+  },
+  "values": {},
+}
+`;

package/valibot/src/__tests__/valibot.ts

@@ -0,0 +1,24 @@
+/* eslint-disable no-console, @typescript-eslint/ban-ts-comment */
+import { valibotResolver } from '..';
+import { schema, validData, fields, invalidData } from './__fixtures__/data';
+
+const shouldUseNativeValidation = false;
+describe('valibotResolver', () => {
+  it('should return values from valibotResolver when validation pass', async () => {
+    const result = await valibotResolver(schema)(validData, undefined, {
+      fields,
+      shouldUseNativeValidation,
+    });
+
+    expect(result).toEqual({ errors: {}, values: validData });
+  });
+
+  it('should return a single error from valibotResolver when validation fails', async () => {
+    const result = await valibotResolver(schema)(invalidData, undefined, {
+      fields,
+      shouldUseNativeValidation,
+    });
+
+    expect(result).toMatchSnapshot();
+  });
+});

package/valibot/src/index.ts

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

package/valibot/src/types.ts

@@ -0,0 +1,22 @@
+import { FieldValues, ResolverResult, ResolverOptions } from 'react-hook-form';
+import { BaseSchema, BaseSchemaAsync, ParseInfo } from 'valibot';
+
+export type Resolver = <T extends BaseSchema | BaseSchemaAsync>(
+  schema: T,
+  schemaOptions?: Partial<Pick<ParseInfo, 'abortEarly' | 'abortPipeEarly'>>,
+  resolverOptions?: {
+    /**
+     * @default async
+     */
+    mode?: 'sync' | 'async';
+    /**
+     * Return the raw input values rather than the parsed values.
+     * @default false
+     */
+    raw?: boolean;
+  },
+) => <TFieldValues extends FieldValues, TContext>(
+  values: TFieldValues,
+  context: TContext | undefined,
+  options: ResolverOptions<TFieldValues>,
+) => Promise<ResolverResult<TFieldValues>>;

package/valibot/src/valibot.ts

@@ -0,0 +1,76 @@
+import { toNestError } from '@hookform/resolvers';
+import type { Resolver } from './types';
+import {
+  BaseSchema,
+  BaseSchemaAsync,
+  ValiError,
+  parse,
+  parseAsync,
+} from 'valibot';
+import { FieldErrors, FieldError } from 'react-hook-form';
+
+type FlatErrors = Record<string, [FieldError, ...FieldError[]]>;
+
+const parseErrors = (error: ValiError): FieldErrors => {
+  const errors = error.issues.reduce<FlatErrors>((flatErrors, issue) => {
+    if (issue.path) {
+      const path = issue.path.map(({ key }) => key).join('.');
+      flatErrors[path] = [
+        ...(flatErrors[path] || []),
+        {
+          message: issue.message,
+          type: issue.validation,
+        },
+      ];
+    }
+
+    return flatErrors;
+  }, {});
+
+  return Object.entries(errors).reduce<FieldErrors>((acc, [path, errors]) => {
+    const [firstError] = errors;
+    acc[path] = {
+      message: firstError.message,
+      type: firstError.type,
+    };
+
+    return acc;
+  }, {});
+};
+
+export const valibotResolver: Resolver =
+  (
+    schema,
+    schemaOptions = {
+      abortEarly: false,
+      abortPipeEarly: false,
+    },
+    resolverOptions = {
+      mode: 'async',
+      raw: false,
+    },
+  ) =>
+  async (values, _, options) => {
+    try {
+      const { mode, raw } = resolverOptions;
+      const parsed =
+        mode === 'sync'
+          ? parse(schema as BaseSchema, values, schemaOptions)
+          : await parseAsync(
+              schema as BaseSchema | BaseSchemaAsync,
+              values,
+              schemaOptions,
+            );
+
+      return { values: raw ? values : parsed, errors: {} as FieldErrors };
+    } catch (error) {
+      if (error instanceof ValiError) {
+        return {
+          values: {},
+          errors: toNestError(parseErrors(error), options),
+        };
+      }
+
+      throw error;
+    }
+  };