@hookform/resolvers 4.1.2 → 5.0.0

package/typeschema/dist/typeschema.modern.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"typeschema.modern.mjs","sources":["../src/typeschema.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport type { ValidationIssue } from '@typeschema/core';\nimport { validate } from '@typeschema/main';\nimport { FieldError, FieldErrors, appendErrors } from 'react-hook-form';\nimport type { Resolver } from './types';\n\nconst parseErrorSchema = (\n  typeschemaErrors: ValidationIssue[],\n  validateAllFieldCriteria: boolean,\n): FieldErrors => {\n  const errors: Record<string, FieldError> = {};\n\n  for (; typeschemaErrors.length; ) {\n    const error = typeschemaErrors[0];\n\n    if (!error.path) {\n      continue;\n    }\n    const _path = error.path.join('.');\n\n    if (!errors[_path]) {\n      errors[_path] = { message: error.message, type: '' };\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types[''];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        '',\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    typeschemaErrors.shift();\n  }\n\n  return errors;\n};\n\n/**\n * Creates a resolver for react-hook-form using TypeSchema validation\n * @param {any} schema - The TypeSchema to validate against\n * @param {any} _ - Unused parameter\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {string} [resolverOptions.mode='async'] - Validation mode\n * @returns {Resolver} A resolver function compatible with react-hook-form\n * @example\n * const schema = z.object({\n *   name: z.string().required(),\n *   age: z.number().required(),\n * });\n *\n * useForm({\n *   resolver: typeschemaResolver(schema)\n * });\n */\nexport const typeschemaResolver: Resolver =\n  (schema, _, resolverOptions = {}) =>\n  async (values, _, options) => {\n    const result = await validate(schema, values);\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    if (result.success) {\n      return {\n        errors: {} as FieldErrors,\n        values: resolverOptions.raw\n          ? Object.assign({}, values)\n          : (result.data as any),\n      };\n    }\n\n    return {\n      values: {},\n      errors: toNestErrors(\n        parseErrorSchema(\n          result.issues,\n          !options.shouldUseNativeValidation && options.criteriaMode === 'all',\n        ),\n        options,\n      ),\n    };\n  };\n"],"names":["parseErrorSchema","typeschemaErrors","validateAllFieldCriteria","errors","length","error","path","_path","join","message","type","types","messages","appendErrors","concat","shift","typeschemaResolver","schema","_","resolverOptions","async","values","options","result","validate","shouldUseNativeValidation","validateFieldsNatively","success","raw","Object","assign","data","toNestErrors","issues","criteriaMode"],"mappings":"0KAMA,MAAMA,EAAmBA,CACvBC,EACAC,KAEA,MAAMC,EAAqC,CAAE,EAE7C,KAAOF,EAAiBG,QAAU,CAChC,MAAMC,EAAQJ,EAAiB,GAE/B,IAAKI,EAAMC,KACT,SAEF,MAAMC,EAAQF,EAAMC,KAAKE,KAAK,KAM9B,GAJKL,EAAOI,KACVJ,EAAOI,GAAS,CAAEE,QAASJ,EAAMI,QAASC,KAAM,KAG9CR,EAA0B,CAC5B,MAAMS,EAAQR,EAAOI,GAAOI,MACtBC,EAAWD,GAASA,EAAM,IAEhCR,EAAOI,GAASM,EACdN,EACAL,EACAC,EACA,GACAS,EACK,GAAgBE,OAAOF,EAAsBP,EAAMI,SACpDJ,EAAMI,QAEd,CAEAR,EAAiBc,OACnB,CAEA,OAAOZ,GAoBIa,EACXA,CAACC,EAAQC,EAAGC,EAAkB,CAAA,IAC9BC,MAAOC,EAAQH,EAAGI,KAChB,MAAMC,QAAeC,EAASP,EAAQI,GAItC,OAFAC,EAAQG,2BAA6BC,EAAuB,CAAA,EAAIJ,GAE5DC,EAAOI,QACF,CACLxB,OAAQ,CAAA,EACRkB,OAAQF,EAAgBS,IACpBC,OAAOC,OAAO,CAAA,EAAIT,GACjBE,EAAOQ,MAIT,CACLV,OAAQ,CAAE,EACVlB,OAAQ6B,EACNhC,EACEuB,EAAOU,QACNX,EAAQG,2BAAsD,QAAzBH,EAAQY,cAEhDZ"}
+{"version":3,"file":"typeschema.modern.mjs","sources":["../src/typeschema.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport {\n  FieldError,\n  FieldErrors,\n  FieldValues,\n  Resolver,\n  appendErrors,\n} from 'react-hook-form';\nimport { StandardSchemaV1 } from 'zod/lib/standard-schema';\n\nconst parseErrorSchema = (\n  typeschemaErrors: readonly StandardSchemaV1.Issue[],\n  validateAllFieldCriteria: boolean,\n): FieldErrors => {\n  const schemaErrors = Object.assign([], typeschemaErrors);\n  const errors: Record<string, FieldError> = {};\n\n  for (; schemaErrors.length; ) {\n    const error = typeschemaErrors[0];\n\n    if (!error.path) {\n      continue;\n    }\n    const _path = error.path.join('.');\n\n    if (!errors[_path]) {\n      errors[_path] = { message: error.message, type: '' };\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types[''];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        '',\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    schemaErrors.shift();\n  }\n\n  return errors;\n};\n\nexport function typeschemaResolver<Input extends FieldValues, Context, Output>(\n  schema: StandardSchemaV1<Input, Output>,\n  _schemaOptions?: never,\n  resolverOptions?: {\n    raw?: false;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function typeschemaResolver<Input extends FieldValues, Context, Output>(\n  schema: StandardSchemaV1<Input, Output>,\n  _schemaOptions: never | undefined,\n  resolverOptions: {\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using TypeSchema validation\n * @param {any} schema - The TypeSchema to validate against\n * @param {any} _ - Unused parameter\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {string} [resolverOptions.mode='async'] - Validation mode\n * @returns {Resolver} A resolver function compatible with react-hook-form\n * @example\n * const schema = z.object({\n *   name: z.string().required(),\n *   age: z.number().required(),\n * });\n *\n * useForm({\n *   resolver: typeschemaResolver(schema)\n * });\n */\nexport function typeschemaResolver<Input extends FieldValues, Context, Output>(\n  schema: StandardSchemaV1<Input, Output>,\n  _schemaOptions?: never,\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Output | Input> {\n  return async (values, _, options) => {\n    let result = schema['~standard'].validate(values);\n    if (result instanceof Promise) {\n      result = await result;\n    }\n\n    if (result.issues) {\n      const errors = parseErrorSchema(\n        result.issues,\n        !options.shouldUseNativeValidation && options.criteriaMode === 'all',\n      );\n\n      return {\n        values: {},\n        errors: toNestErrors(errors, options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      values: resolverOptions.raw ? Object.assign({}, values) : result.value,\n      errors: {},\n    };\n  };\n}\n"],"names":["typeschemaResolver","schema","_schemaOptions","resolverOptions","async","values","_","options","result","validate","Promise","issues","errors","parseErrorSchema","typeschemaErrors","validateAllFieldCriteria","schemaErrors","Object","assign","length","error","path","_path","join","message","type","types","messages","appendErrors","concat","shift","shouldUseNativeValidation","criteriaMode","toNestErrors","validateFieldsNatively","raw","value"],"mappings":"8HAmFM,SAAUA,EACdC,EACAC,EACAC,EAEI,IAEJ,OAAOC,MAAOC,EAAQC,EAAGC,KACvB,IAAIC,EAASP,EAAO,aAAaQ,SAASJ,GAK1C,GAJIG,aAAkBE,UACpBF,QAAeA,GAGbA,EAAOG,OAAQ,CACjB,MAAMC,EAvFaC,EACvBC,EACAC,KAEA,MAAMC,EAAeC,OAAOC,OAAO,GAAIJ,GACjCF,EAAqC,CAAE,EAE7C,KAAOI,EAAaG,QAAU,CAC5B,MAAMC,EAAQN,EAAiB,GAE/B,IAAKM,EAAMC,KACT,SAEF,MAAMC,EAAQF,EAAMC,KAAKE,KAAK,KAM9B,GAJKX,EAAOU,KACVV,EAAOU,GAAS,CAAEE,QAASJ,EAAMI,QAASC,KAAM,KAG9CV,EAA0B,CAC5B,MAAMW,EAAQd,EAAOU,GAAOI,MACtBC,EAAWD,GAASA,EAAM,IAEhCd,EAAOU,GAASM,EACdN,EACAP,EACAH,EACA,GACAe,EACK,GAAgBE,OAAOF,EAAsBP,EAAMI,SACpDJ,EAAMI,QAEd,CAEAR,EAAac,OACf,CAEA,OAAOlB,GAkDYC,CACbL,EAAOG,QACNJ,EAAQwB,2BAAsD,QAAzBxB,EAAQyB,cAGhD,MAAO,CACL3B,OAAQ,CAAA,EACRO,OAAQqB,EAAarB,EAAQL,GAEjC,CAIA,OAFAA,EAAQwB,2BAA6BG,EAAuB,CAAA,EAAI3B,GAEzD,CACLF,OAAQF,EAAgBgC,IAAMlB,OAAOC,OAAO,CAAA,EAAIb,GAAUG,EAAO4B,MACjExB,OAAQ,CAAA,GAGd"}

package/typeschema/dist/typeschema.module.js

@@ -1,2 +1,2 @@
-import{validateFieldsNatively as e,toNestErrors as r}from"@hookform/resolvers";import{validate as t}from"@typeschema/main";import{appendErrors as o}from"react-hook-form";var s=function(e,r){for(var t={};e.length;){var s=e[0];if(s.path){var a=s.path.join(".");if(t[a]||(t[a]={message:s.message,type:""}),r){var i=t[a].types,n=i&&i[""];t[a]=o(a,r,t,"",n?[].concat(n,s.message):s.message)}e.shift()}}return t},a=function(o,a,i){return void 0===i&&(i={}),function(a,n,m){try{return Promise.resolve(t(o,a)).then(function(t){return m.shouldUseNativeValidation&&e({},m),t.success?{errors:{},values:i.raw?Object.assign({},a):t.data}:{values:{},errors:r(s(t.issues,!m.shouldUseNativeValidation&&"all"===m.criteriaMode),m)}})}catch(e){return Promise.reject(e)}}};export{a as typeschemaResolver};
+import{toNestErrors as e,validateFieldsNatively as r}from"@hookform/resolvers";import{appendErrors as t}from"react-hook-form";function s(s,o,a){return void 0===a&&(a={}),function(o,i,n){try{var u=function(){if(f.issues){var s=function(e,r){for(var s=Object.assign([],e),o={};s.length;){var a=e[0];if(a.path){var i=a.path.join(".");if(o[i]||(o[i]={message:a.message,type:""}),r){var n=o[i].types,u=n&&n[""];o[i]=t(i,r,o,"",u?[].concat(u,a.message):a.message)}s.shift()}}return o}(f.issues,!n.shouldUseNativeValidation&&"all"===n.criteriaMode);return{values:{},errors:e(s,n)}}return n.shouldUseNativeValidation&&r({},n),{values:a.raw?Object.assign({},o):f.value,errors:{}}},f=s["~standard"].validate(o),c=function(){if(f instanceof Promise)return Promise.resolve(f).then(function(e){f=e})}();return Promise.resolve(c&&c.then?c.then(u):u())}catch(e){return Promise.reject(e)}}}export{s as typeschemaResolver};
 //# sourceMappingURL=typeschema.module.js.map

package/typeschema/dist/typeschema.module.js.map

@@ -1 +1 @@
-{"version":3,"file":"typeschema.module.js","sources":["../src/typeschema.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport type { ValidationIssue } from '@typeschema/core';\nimport { validate } from '@typeschema/main';\nimport { FieldError, FieldErrors, appendErrors } from 'react-hook-form';\nimport type { Resolver } from './types';\n\nconst parseErrorSchema = (\n  typeschemaErrors: ValidationIssue[],\n  validateAllFieldCriteria: boolean,\n): FieldErrors => {\n  const errors: Record<string, FieldError> = {};\n\n  for (; typeschemaErrors.length; ) {\n    const error = typeschemaErrors[0];\n\n    if (!error.path) {\n      continue;\n    }\n    const _path = error.path.join('.');\n\n    if (!errors[_path]) {\n      errors[_path] = { message: error.message, type: '' };\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types[''];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        '',\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    typeschemaErrors.shift();\n  }\n\n  return errors;\n};\n\n/**\n * Creates a resolver for react-hook-form using TypeSchema validation\n * @param {any} schema - The TypeSchema to validate against\n * @param {any} _ - Unused parameter\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {string} [resolverOptions.mode='async'] - Validation mode\n * @returns {Resolver} A resolver function compatible with react-hook-form\n * @example\n * const schema = z.object({\n *   name: z.string().required(),\n *   age: z.number().required(),\n * });\n *\n * useForm({\n *   resolver: typeschemaResolver(schema)\n * });\n */\nexport const typeschemaResolver: Resolver =\n  (schema, _, resolverOptions = {}) =>\n  async (values, _, options) => {\n    const result = await validate(schema, values);\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    if (result.success) {\n      return {\n        errors: {} as FieldErrors,\n        values: resolverOptions.raw\n          ? Object.assign({}, values)\n          : (result.data as any),\n      };\n    }\n\n    return {\n      values: {},\n      errors: toNestErrors(\n        parseErrorSchema(\n          result.issues,\n          !options.shouldUseNativeValidation && options.criteriaMode === 'all',\n        ),\n        options,\n      ),\n    };\n  };\n"],"names":["parseErrorSchema","typeschemaErrors","validateAllFieldCriteria","errors","length","error","path","_path","join","message","type","types","messages","appendErrors","concat","shift","typeschemaResolver","schema","_","resolverOptions","values","options","Promise","resolve","validate","then","result","shouldUseNativeValidation","validateFieldsNatively","success","raw","Object","assign","data","toNestErrors","issues","criteriaMode","e","reject"],"mappings":"0KAMA,IAAMA,EAAmB,SACvBC,EACAC,GAIA,IAFA,IAAMC,EAAqC,CAAE,EAEtCF,EAAiBG,QAAU,CAChC,IAAMC,EAAQJ,EAAiB,GAE/B,GAAKI,EAAMC,KAAX,CAGA,IAAMC,EAAQF,EAAMC,KAAKE,KAAK,KAM9B,GAJKL,EAAOI,KACVJ,EAAOI,GAAS,CAAEE,QAASJ,EAAMI,QAASC,KAAM,KAG9CR,EAA0B,CAC5B,IAAMS,EAAQR,EAAOI,GAAOI,MACtBC,EAAWD,GAASA,EAAM,IAEhCR,EAAOI,GAASM,EACdN,EACAL,EACAC,EACA,GACAS,EACK,GAAgBE,OAAOF,EAAsBP,EAAMI,SACpDJ,EAAMI,QAEd,CAEAR,EAAiBc,OAtBjB,CAuBF,CAEA,OAAOZ,CACT,EAmBaa,EACX,SAACC,EAAQC,EAAGC,GACLC,YADoB,IAAfD,IAAAA,EAAkB,IACvBC,SAAAA,EAAQF,EAAGG,GAAO,WAAIC,QAAAC,QACNC,EAASP,EAAQG,IAAOK,KAAA,SAAvCC,GAEmE,OAAzEL,EAAQM,2BAA6BC,EAAuB,CAAA,EAAIP,GAE5DK,EAAOG,QACF,CACL1B,OAAQ,CAAA,EACRiB,OAAQD,EAAgBW,IACpBC,OAAOC,OAAO,GAAIZ,GACjBM,EAAOO,MAIT,CACLb,OAAQ,CAAA,EACRjB,OAAQ+B,EACNlC,EACE0B,EAAOS,QACNd,EAAQM,2BAAsD,QAAzBN,EAAQe,cAEhDf,GAEH,EACH,CAAC,MAAAgB,GAAAf,OAAAA,QAAAgB,OAAAD,EAAA,CAAA,CAAA"}
+{"version":3,"file":"typeschema.module.js","sources":["../src/typeschema.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport {\n  FieldError,\n  FieldErrors,\n  FieldValues,\n  Resolver,\n  appendErrors,\n} from 'react-hook-form';\nimport { StandardSchemaV1 } from 'zod/lib/standard-schema';\n\nconst parseErrorSchema = (\n  typeschemaErrors: readonly StandardSchemaV1.Issue[],\n  validateAllFieldCriteria: boolean,\n): FieldErrors => {\n  const schemaErrors = Object.assign([], typeschemaErrors);\n  const errors: Record<string, FieldError> = {};\n\n  for (; schemaErrors.length; ) {\n    const error = typeschemaErrors[0];\n\n    if (!error.path) {\n      continue;\n    }\n    const _path = error.path.join('.');\n\n    if (!errors[_path]) {\n      errors[_path] = { message: error.message, type: '' };\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types[''];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        '',\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    schemaErrors.shift();\n  }\n\n  return errors;\n};\n\nexport function typeschemaResolver<Input extends FieldValues, Context, Output>(\n  schema: StandardSchemaV1<Input, Output>,\n  _schemaOptions?: never,\n  resolverOptions?: {\n    raw?: false;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function typeschemaResolver<Input extends FieldValues, Context, Output>(\n  schema: StandardSchemaV1<Input, Output>,\n  _schemaOptions: never | undefined,\n  resolverOptions: {\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using TypeSchema validation\n * @param {any} schema - The TypeSchema to validate against\n * @param {any} _ - Unused parameter\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {string} [resolverOptions.mode='async'] - Validation mode\n * @returns {Resolver} A resolver function compatible with react-hook-form\n * @example\n * const schema = z.object({\n *   name: z.string().required(),\n *   age: z.number().required(),\n * });\n *\n * useForm({\n *   resolver: typeschemaResolver(schema)\n * });\n */\nexport function typeschemaResolver<Input extends FieldValues, Context, Output>(\n  schema: StandardSchemaV1<Input, Output>,\n  _schemaOptions?: never,\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Output | Input> {\n  return async (values, _, options) => {\n    let result = schema['~standard'].validate(values);\n    if (result instanceof Promise) {\n      result = await result;\n    }\n\n    if (result.issues) {\n      const errors = parseErrorSchema(\n        result.issues,\n        !options.shouldUseNativeValidation && options.criteriaMode === 'all',\n      );\n\n      return {\n        values: {},\n        errors: toNestErrors(errors, options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      values: resolverOptions.raw ? Object.assign({}, values) : result.value,\n      errors: {},\n    };\n  };\n}\n"],"names":["typeschemaResolver","schema","_schemaOptions","resolverOptions","values","_","options","_temp2","result","issues","errors","typeschemaErrors","validateAllFieldCriteria","schemaErrors","Object","assign","length","error","path","_path","join","message","type","types","messages","appendErrors","concat","shift","parseErrorSchema","shouldUseNativeValidation","criteriaMode","toNestErrors","validateFieldsNatively","raw","value","validate","_temp","Promise","resolve","then","_result","e","reject"],"mappings":"8HAmFM,SAAUA,EACdC,EACAC,EACAC,GAIA,YAJAA,IAAAA,IAAAA,EAEI,IAEUC,SAAAA,EAAQC,EAAGC,GAAO,QAAIC,EAAA,WAMlC,GAAIC,EAAOC,OAAQ,CACjB,IAAMC,EAvFa,SACvBC,EACAC,GAKA,IAHA,IAAMC,EAAeC,OAAOC,OAAO,GAAIJ,GACjCD,EAAqC,GAEpCG,EAAaG,QAAU,CAC5B,IAAMC,EAAQN,EAAiB,GAE/B,GAAKM,EAAMC,KAAX,CAGA,IAAMC,EAAQF,EAAMC,KAAKE,KAAK,KAM9B,GAJKV,EAAOS,KACVT,EAAOS,GAAS,CAAEE,QAASJ,EAAMI,QAASC,KAAM,KAG9CV,EAA0B,CAC5B,IAAMW,EAAQb,EAAOS,GAAOI,MACtBC,EAAWD,GAASA,EAAM,IAEhCb,EAAOS,GAASM,EACdN,EACAP,EACAF,EACA,GACAc,EACK,GAAgBE,OAAOF,EAAsBP,EAAMI,SACpDJ,EAAMI,QAEd,CAEAR,EAAac,OAtBb,CAuBF,CAEA,OAAOjB,CACT,CAiDqBkB,CACbpB,EAAOC,QACNH,EAAQuB,2BAAsD,QAAzBvB,EAAQwB,cAGhD,MAAO,CACL1B,OAAQ,CAAE,EACVM,OAAQqB,EAAarB,EAAQJ,GAEjC,CAIA,OAFAA,EAAQuB,2BAA6BG,EAAuB,CAAA,EAAI1B,GAEzD,CACLF,OAAQD,EAAgB8B,IAAMnB,OAAOC,OAAO,CAAA,EAAIX,GAAUI,EAAO0B,MACjExB,OAAQ,CAAA,EACR,EAtBEF,EAASP,EAAO,aAAakC,SAAS/B,GAAQgC,EAC9C5B,WAAAA,GAAAA,aAAkB6B,QAAOA,OAAAA,QAAAC,QACZ9B,GAAM+B,cAAAC,GAArBhC,EAAMgC,CAAgB,GADpBhC,UACoB6B,QAAAC,QAAAF,GAAAA,EAAAG,KAAAH,EAAAG,KAAAhC,GAAAA,IAqB1B,CAAC,MAAAkC,GAAAJ,OAAAA,QAAAK,OAAAD,EACH,CAAA,CAAA"}

package/typeschema/dist/typeschema.umd.js

@@ -1,2 +1,2 @@
-!function(e,o){"object"==typeof exports&&"undefined"!=typeof module?o(exports,require("@hookform/resolvers"),require("@typeschema/main"),require("react-hook-form")):"function"==typeof define&&define.amd?define(["exports","@hookform/resolvers","@typeschema/main","react-hook-form"],o):o((e||self).hookformResolversTypeschema={},e.hookformResolvers,e.main,e.ReactHookForm)}(this,function(e,o,r,s){var t=function(e,o){for(var r={};e.length;){var t=e[0];if(t.path){var a=t.path.join(".");if(r[a]||(r[a]={message:t.message,type:""}),o){var i=r[a].types,n=i&&i[""];r[a]=s.appendErrors(a,o,r,"",n?[].concat(n,t.message):t.message)}e.shift()}}return r};e.typeschemaResolver=function(e,s,a){return void 0===a&&(a={}),function(s,i,n){try{return Promise.resolve(r.validate(e,s)).then(function(e){return n.shouldUseNativeValidation&&o.validateFieldsNatively({},n),e.success?{errors:{},values:a.raw?Object.assign({},s):e.data}:{values:{},errors:o.toNestErrors(t(e.issues,!n.shouldUseNativeValidation&&"all"===n.criteriaMode),n)}})}catch(e){return Promise.reject(e)}}}});
+!function(e,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports,require("@hookform/resolvers"),require("react-hook-form")):"function"==typeof define&&define.amd?define(["exports","@hookform/resolvers","react-hook-form"],r):r((e||self).hookformResolversTypeschema={},e.hookformResolvers,e.ReactHookForm)}(this,function(e,r,o){e.typeschemaResolver=function(e,s,t){return void 0===t&&(t={}),function(s,i,n){try{var a=function(){if(f.issues){var e=function(e,r){for(var s=Object.assign([],e),t={};s.length;){var i=e[0];if(i.path){var n=i.path.join(".");if(t[n]||(t[n]={message:i.message,type:""}),r){var a=t[n].types,f=a&&a[""];t[n]=o.appendErrors(n,r,t,"",f?[].concat(f,i.message):i.message)}s.shift()}}return t}(f.issues,!n.shouldUseNativeValidation&&"all"===n.criteriaMode);return{values:{},errors:r.toNestErrors(e,n)}}return n.shouldUseNativeValidation&&r.validateFieldsNatively({},n),{values:t.raw?Object.assign({},s):f.value,errors:{}}},f=e["~standard"].validate(s),u=function(){if(f instanceof Promise)return Promise.resolve(f).then(function(e){f=e})}();return Promise.resolve(u&&u.then?u.then(a):a())}catch(e){return Promise.reject(e)}}}});
 //# sourceMappingURL=typeschema.umd.js.map

package/typeschema/dist/typeschema.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"typeschema.umd.js","sources":["../src/typeschema.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport type { ValidationIssue } from '@typeschema/core';\nimport { validate } from '@typeschema/main';\nimport { FieldError, FieldErrors, appendErrors } from 'react-hook-form';\nimport type { Resolver } from './types';\n\nconst parseErrorSchema = (\n  typeschemaErrors: ValidationIssue[],\n  validateAllFieldCriteria: boolean,\n): FieldErrors => {\n  const errors: Record<string, FieldError> = {};\n\n  for (; typeschemaErrors.length; ) {\n    const error = typeschemaErrors[0];\n\n    if (!error.path) {\n      continue;\n    }\n    const _path = error.path.join('.');\n\n    if (!errors[_path]) {\n      errors[_path] = { message: error.message, type: '' };\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types[''];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        '',\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    typeschemaErrors.shift();\n  }\n\n  return errors;\n};\n\n/**\n * Creates a resolver for react-hook-form using TypeSchema validation\n * @param {any} schema - The TypeSchema to validate against\n * @param {any} _ - Unused parameter\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {string} [resolverOptions.mode='async'] - Validation mode\n * @returns {Resolver} A resolver function compatible with react-hook-form\n * @example\n * const schema = z.object({\n *   name: z.string().required(),\n *   age: z.number().required(),\n * });\n *\n * useForm({\n *   resolver: typeschemaResolver(schema)\n * });\n */\nexport const typeschemaResolver: Resolver =\n  (schema, _, resolverOptions = {}) =>\n  async (values, _, options) => {\n    const result = await validate(schema, values);\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    if (result.success) {\n      return {\n        errors: {} as FieldErrors,\n        values: resolverOptions.raw\n          ? Object.assign({}, values)\n          : (result.data as any),\n      };\n    }\n\n    return {\n      values: {},\n      errors: toNestErrors(\n        parseErrorSchema(\n          result.issues,\n          !options.shouldUseNativeValidation && options.criteriaMode === 'all',\n        ),\n        options,\n      ),\n    };\n  };\n"],"names":["parseErrorSchema","typeschemaErrors","validateAllFieldCriteria","errors","length","error","path","_path","join","message","type","types","messages","appendErrors","concat","shift","schema","_","resolverOptions","values","options","Promise","resolve","validate","then","result","shouldUseNativeValidation","validateFieldsNatively","success","raw","Object","assign","data","toNestErrors","issues","criteriaMode","e","reject"],"mappings":"ubAMA,IAAMA,EAAmB,SACvBC,EACAC,GAIA,IAFA,IAAMC,EAAqC,CAAE,EAEtCF,EAAiBG,QAAU,CAChC,IAAMC,EAAQJ,EAAiB,GAE/B,GAAKI,EAAMC,KAAX,CAGA,IAAMC,EAAQF,EAAMC,KAAKE,KAAK,KAM9B,GAJKL,EAAOI,KACVJ,EAAOI,GAAS,CAAEE,QAASJ,EAAMI,QAASC,KAAM,KAG9CR,EAA0B,CAC5B,IAAMS,EAAQR,EAAOI,GAAOI,MACtBC,EAAWD,GAASA,EAAM,IAEhCR,EAAOI,GAASM,EAAYA,aAC1BN,EACAL,EACAC,EACA,GACAS,EACK,GAAgBE,OAAOF,EAAsBP,EAAMI,SACpDJ,EAAMI,QAEd,CAEAR,EAAiBc,OAtBjB,CAuBF,CAEA,OAAOZ,CACT,uBAoBE,SAACa,EAAQC,EAAGC,GACLC,YADoB,IAAfD,IAAAA,EAAkB,IACvBC,SAAAA,EAAQF,EAAGG,GAAO,WAAIC,QAAAC,QACNC,WAASP,EAAQG,IAAOK,KAAA,SAAvCC,GAEmE,OAAzEL,EAAQM,2BAA6BC,yBAAuB,CAAA,EAAIP,GAE5DK,EAAOG,QACF,CACLzB,OAAQ,CAAA,EACRgB,OAAQD,EAAgBW,IACpBC,OAAOC,OAAO,GAAIZ,GACjBM,EAAOO,MAIT,CACLb,OAAQ,CAAA,EACRhB,OAAQ8B,EAAAA,aACNjC,EACEyB,EAAOS,QACNd,EAAQM,2BAAsD,QAAzBN,EAAQe,cAEhDf,GAEH,EACH,CAAC,MAAAgB,GAAAf,OAAAA,QAAAgB,OAAAD,EAAA,CAAA,CAAA"}
+{"version":3,"file":"typeschema.umd.js","sources":["../src/typeschema.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport {\n  FieldError,\n  FieldErrors,\n  FieldValues,\n  Resolver,\n  appendErrors,\n} from 'react-hook-form';\nimport { StandardSchemaV1 } from 'zod/lib/standard-schema';\n\nconst parseErrorSchema = (\n  typeschemaErrors: readonly StandardSchemaV1.Issue[],\n  validateAllFieldCriteria: boolean,\n): FieldErrors => {\n  const schemaErrors = Object.assign([], typeschemaErrors);\n  const errors: Record<string, FieldError> = {};\n\n  for (; schemaErrors.length; ) {\n    const error = typeschemaErrors[0];\n\n    if (!error.path) {\n      continue;\n    }\n    const _path = error.path.join('.');\n\n    if (!errors[_path]) {\n      errors[_path] = { message: error.message, type: '' };\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types[''];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        '',\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    schemaErrors.shift();\n  }\n\n  return errors;\n};\n\nexport function typeschemaResolver<Input extends FieldValues, Context, Output>(\n  schema: StandardSchemaV1<Input, Output>,\n  _schemaOptions?: never,\n  resolverOptions?: {\n    raw?: false;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function typeschemaResolver<Input extends FieldValues, Context, Output>(\n  schema: StandardSchemaV1<Input, Output>,\n  _schemaOptions: never | undefined,\n  resolverOptions: {\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using TypeSchema validation\n * @param {any} schema - The TypeSchema to validate against\n * @param {any} _ - Unused parameter\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {string} [resolverOptions.mode='async'] - Validation mode\n * @returns {Resolver} A resolver function compatible with react-hook-form\n * @example\n * const schema = z.object({\n *   name: z.string().required(),\n *   age: z.number().required(),\n * });\n *\n * useForm({\n *   resolver: typeschemaResolver(schema)\n * });\n */\nexport function typeschemaResolver<Input extends FieldValues, Context, Output>(\n  schema: StandardSchemaV1<Input, Output>,\n  _schemaOptions?: never,\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Output | Input> {\n  return async (values, _, options) => {\n    let result = schema['~standard'].validate(values);\n    if (result instanceof Promise) {\n      result = await result;\n    }\n\n    if (result.issues) {\n      const errors = parseErrorSchema(\n        result.issues,\n        !options.shouldUseNativeValidation && options.criteriaMode === 'all',\n      );\n\n      return {\n        values: {},\n        errors: toNestErrors(errors, options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      values: resolverOptions.raw ? Object.assign({}, values) : result.value,\n      errors: {},\n    };\n  };\n}\n"],"names":["schema","_schemaOptions","resolverOptions","values","_","options","_temp2","result","issues","errors","typeschemaErrors","validateAllFieldCriteria","schemaErrors","Object","assign","length","error","path","_path","join","message","type","types","messages","appendErrors","concat","shift","parseErrorSchema","shouldUseNativeValidation","criteriaMode","toNestErrors","validateFieldsNatively","raw","value","validate","_temp","Promise","resolve","then","_result","e","reject"],"mappings":"oZAmFM,SACJA,EACAC,EACAC,GAIA,YAJAA,IAAAA,IAAAA,EAEI,IAEUC,SAAAA,EAAQC,EAAGC,GAAO,QAAIC,EAAA,WAMlC,GAAIC,EAAOC,OAAQ,CACjB,IAAMC,EAvFa,SACvBC,EACAC,GAKA,IAHA,IAAMC,EAAeC,OAAOC,OAAO,GAAIJ,GACjCD,EAAqC,GAEpCG,EAAaG,QAAU,CAC5B,IAAMC,EAAQN,EAAiB,GAE/B,GAAKM,EAAMC,KAAX,CAGA,IAAMC,EAAQF,EAAMC,KAAKE,KAAK,KAM9B,GAJKV,EAAOS,KACVT,EAAOS,GAAS,CAAEE,QAASJ,EAAMI,QAASC,KAAM,KAG9CV,EAA0B,CAC5B,IAAMW,EAAQb,EAAOS,GAAOI,MACtBC,EAAWD,GAASA,EAAM,IAEhCb,EAAOS,GAASM,EAAYA,aAC1BN,EACAP,EACAF,EACA,GACAc,EACK,GAAgBE,OAAOF,EAAsBP,EAAMI,SACpDJ,EAAMI,QAEd,CAEAR,EAAac,OAtBb,CAuBF,CAEA,OAAOjB,CACT,CAiDqBkB,CACbpB,EAAOC,QACNH,EAAQuB,2BAAsD,QAAzBvB,EAAQwB,cAGhD,MAAO,CACL1B,OAAQ,CAAE,EACVM,OAAQqB,EAAAA,aAAarB,EAAQJ,GAEjC,CAIA,OAFAA,EAAQuB,2BAA6BG,yBAAuB,CAAA,EAAI1B,GAEzD,CACLF,OAAQD,EAAgB8B,IAAMnB,OAAOC,OAAO,CAAA,EAAIX,GAAUI,EAAO0B,MACjExB,OAAQ,CAAA,EACR,EAtBEF,EAASP,EAAO,aAAakC,SAAS/B,GAAQgC,EAC9C5B,WAAAA,GAAAA,aAAkB6B,QAAOA,OAAAA,QAAAC,QACZ9B,GAAM+B,cAAAC,GAArBhC,EAAMgC,CAAgB,GADpBhC,UACoB6B,QAAAC,QAAAF,GAAAA,EAAAG,KAAAH,EAAAG,KAAAhC,GAAAA,IAqB1B,CAAC,MAAAkC,GAAAJ,OAAAA,QAAAK,OAAAD,EACH,CAAA,CAAA"}

package/typeschema/package.json

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

package/typeschema/src/__tests__/Form.tsx

@@ -11,10 +11,8 @@ const schema = z.object({
   password: z.string().min(1, { message: 'password field is required' }),
 });
 
-type FormData = Infer<typeof schema> & { unusedProperty: string };
-
 interface Props {
-  onSubmit: (data: FormData) => void;
+  onSubmit: (data: Infer<typeof schema>) => void;
 }
 
 function TestComponent({ onSubmit }: Props) {
@@ -22,7 +20,7 @@ function TestComponent({ onSubmit }: Props) {
     register,
     handleSubmit,
     formState: { errors },
-  } = useForm<FormData>({
+  } = useForm({
     resolver: typeschemaResolver(schema), // Useful to check TypeScript regressions
   });
 

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

@@ -66,7 +66,7 @@ export const invalidData = {
   birthYear: 'birthYear',
   like: [{ id: 'z' }],
   url: 'abc',
-};
+} as unknown as z.input<typeof schema>;
 
 export const fields: Record<InternalFieldName, Field['_f']> = {
   username: {

package/typeschema/src/__tests__/typeschema.ts

@@ -1,4 +1,6 @@
 import * as typeschema from '@typeschema/main';
+import { Resolver, SubmitHandler, useForm } from 'react-hook-form';
+import { z } from 'zod';
 import { typeschemaResolver } from '..';
 import { fields, invalidData, schema, validData } from './__fixtures__/data';
 
@@ -67,4 +69,79 @@ describe('typeschemaResolver', () => {
 
     await expect(promise).rejects.toThrow('custom error');
   });
+
+  /**
+   * Type inference tests
+   */
+  it('should correctly infer the output type from a typeschema schema', () => {
+    const resolver = typeschemaResolver(z.object({ id: z.number() }));
+
+    expectTypeOf(resolver).toEqualTypeOf<
+      Resolver<{ id: number }, unknown, { id: number }>
+    >();
+  });
+
+  it('should correctly infer the output type from a typeschema schema using a transform', () => {
+    const resolver = typeschemaResolver(
+      z.object({ id: z.number().transform((val) => String(val)) }),
+    );
+
+    expectTypeOf(resolver).toEqualTypeOf<
+      Resolver<{ id: number }, unknown, { id: string }>
+    >();
+  });
+
+  it('should correctly infer the output type from a typeschema schema when a different input type is specified', () => {
+    const schema = z.object({ id: z.number() }).transform(({ id }) => {
+      return { id: String(id) };
+    });
+
+    const resolver = typeschemaResolver<
+      { id: number },
+      any,
+      z.output<typeof schema>
+    >(schema);
+
+    expectTypeOf(resolver).toEqualTypeOf<
+      Resolver<{ id: number }, any, { id: string }>
+    >();
+  });
+
+  it('should correctly infer the output type from a typeschema schema for the handleSubmit function in useForm', () => {
+    const schema = z.object({ id: z.number() });
+
+    const form = useForm({
+      resolver: typeschemaResolver(schema),
+      defaultValues: {
+        id: 3,
+      },
+    });
+
+    expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
+
+    expectTypeOf(form.handleSubmit).parameter(0).toEqualTypeOf<
+      SubmitHandler<{
+        id: number;
+      }>
+    >();
+  });
+
+  it('should correctly infer the output type from a typeschema schema with a transform for the handleSubmit function in useForm', () => {
+    const schema = z.object({ id: z.number().transform((val) => String(val)) });
+
+    const form = useForm({
+      resolver: typeschemaResolver(schema),
+      defaultValues: {
+        id: 3,
+      },
+    });
+
+    expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
+
+    expectTypeOf(form.handleSubmit).parameter(0).toEqualTypeOf<
+      SubmitHandler<{
+        id: string;
+      }>
+    >();
+  });
 });

package/typeschema/src/index.ts

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

package/typeschema/src/typeschema.ts

@@ -1,16 +1,21 @@
 import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';
-import type { ValidationIssue } from '@typeschema/core';
-import { validate } from '@typeschema/main';
-import { FieldError, FieldErrors, appendErrors } from 'react-hook-form';
-import type { Resolver } from './types';
+import {
+  FieldError,
+  FieldErrors,
+  FieldValues,
+  Resolver,
+  appendErrors,
+} from 'react-hook-form';
+import { StandardSchemaV1 } from 'zod/lib/standard-schema';
 
 const parseErrorSchema = (
-  typeschemaErrors: ValidationIssue[],
+  typeschemaErrors: readonly StandardSchemaV1.Issue[],
   validateAllFieldCriteria: boolean,
 ): FieldErrors => {
+  const schemaErrors = Object.assign([], typeschemaErrors);
   const errors: Record<string, FieldError> = {};
 
-  for (; typeschemaErrors.length; ) {
+  for (; schemaErrors.length; ) {
     const error = typeschemaErrors[0];
 
     if (!error.path) {
@@ -37,12 +42,28 @@ const parseErrorSchema = (
       ) as FieldError;
     }
 
-    typeschemaErrors.shift();
+    schemaErrors.shift();
   }
 
   return errors;
 };
 
+export function typeschemaResolver<Input extends FieldValues, Context, Output>(
+  schema: StandardSchemaV1<Input, Output>,
+  _schemaOptions?: never,
+  resolverOptions?: {
+    raw?: false;
+  },
+): Resolver<Input, Context, Output>;
+
+export function typeschemaResolver<Input extends FieldValues, Context, Output>(
+  schema: StandardSchemaV1<Input, Output>,
+  _schemaOptions: never | undefined,
+  resolverOptions: {
+    raw: true;
+  },
+): Resolver<Input, Context, Input>;
+
 /**
  * Creates a resolver for react-hook-form using TypeSchema validation
  * @param {any} schema - The TypeSchema to validate against
@@ -60,30 +81,36 @@ const parseErrorSchema = (
  *   resolver: typeschemaResolver(schema)
  * });
  */
-export const typeschemaResolver: Resolver =
-  (schema, _, resolverOptions = {}) =>
-  async (values, _, options) => {
-    const result = await validate(schema, values);
+export function typeschemaResolver<Input extends FieldValues, Context, Output>(
+  schema: StandardSchemaV1<Input, Output>,
+  _schemaOptions?: never,
+  resolverOptions: {
+    raw?: boolean;
+  } = {},
+): Resolver<Input, Context, Output | Input> {
+  return async (values, _, options) => {
+    let result = schema['~standard'].validate(values);
+    if (result instanceof Promise) {
+      result = await result;
+    }
 
-    options.shouldUseNativeValidation && validateFieldsNatively({}, options);
+    if (result.issues) {
+      const errors = parseErrorSchema(
+        result.issues,
+        !options.shouldUseNativeValidation && options.criteriaMode === 'all',
+      );
 
-    if (result.success) {
       return {
-        errors: {} as FieldErrors,
-        values: resolverOptions.raw
-          ? Object.assign({}, values)
-          : (result.data as any),
+        values: {},
+        errors: toNestErrors(errors, options),
       };
     }
 
+    options.shouldUseNativeValidation && validateFieldsNatively({}, options);
+
     return {
-      values: {},
-      errors: toNestErrors(
-        parseErrorSchema(
-          result.issues,
-          !options.shouldUseNativeValidation && options.criteriaMode === 'all',
-        ),
-        options,
-      ),
+      values: resolverOptions.raw ? Object.assign({}, values) : result.value,
+      errors: {},
     };
   };
+}

package/valibot/dist/valibot.d.ts

@@ -1,31 +1,10 @@
 import { FieldValues, Resolver } from 'react-hook-form';
-import { BaseSchema, BaseSchemaAsync, Config, InferIssue, InferOutput } from 'valibot';
-/**
- * Creates a resolver for react-hook-form using Valibot schema validation
- * @param {BaseSchema<TFieldValues, TFieldValues, any> | BaseSchemaAsync<TFieldValues, TFieldValues, any>} schema - The Valibot schema to validate against
- * @param {Partial<Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>>} [schemaOptions] - Optional Valibot validation options
- * @param {Object} resolverOptions - Additional resolver configuration
- * @param {('sync' | 'async')} [resolverOptions.mode] - Validation mode
- * @param {boolean} [resolverOptions.raw] - If true, returns raw values rather than validated results
- * @returns {Resolver<InferOutput<typeof schema>>} A resolver function compatible with react-hook-form
- * @example
- * const schema = valibot.object({
- *   name: valibot.string().minLength(2),
- *   age: valibot.number().min(18)
- * });
- *
- * useForm({
- *   resolver: valibotResolver(schema)
- * });
- */
-export declare function valibotResolver<TFieldValues extends FieldValues>(schema: BaseSchema<TFieldValues, TFieldValues, any> | BaseSchemaAsync<TFieldValues, TFieldValues, any>, schemaOptions?: Partial<Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>>, resolverOptions?: {
-    /**
-     * @default async
-     */
-    mode?: 'sync' | 'async';
-    /**
-     * Return the raw input values rather than the parsed values.
-     * @default false
-     */
-    raw?: boolean;
-}): Resolver<InferOutput<typeof schema>>;
+import { BaseSchema, BaseSchemaAsync, Config, InferIssue } from 'valibot';
+export declare function valibotResolver<Input extends FieldValues, Context, Output>(schema: BaseSchema<Input, Output, any> | BaseSchemaAsync<Input, Output, any>, schemaOptions?: Partial<Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>>, resolverOptions?: {
+    mode?: 'async' | 'sync';
+    raw?: false;
+}): Resolver<Input, Context, Output>;
+export declare function valibotResolver<Input extends FieldValues, Context, Output>(schema: BaseSchema<Input, Output, any> | BaseSchemaAsync<Input, Output, any>, schemaOptions: Partial<Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>> | undefined, resolverOptions: {
+    mode?: 'async' | 'sync';
+    raw: true;
+}): Resolver<Input, Context, Input>;

package/valibot/dist/valibot.js.map

@@ -1 +1 @@
-{"version":3,"file":"valibot.js","sources":["../src/valibot.ts"],"sourcesContent":["import { toNestErrors } from '@hookform/resolvers';\nimport {\n  FieldError,\n  FieldValues,\n  Resolver,\n  appendErrors,\n} from 'react-hook-form';\nimport { getDotPath, safeParseAsync } from 'valibot';\nimport {\n  BaseSchema,\n  BaseSchemaAsync,\n  Config,\n  InferIssue,\n  InferOutput,\n} from 'valibot';\n\n/**\n * Creates a resolver for react-hook-form using Valibot schema validation\n * @param {BaseSchema<TFieldValues, TFieldValues, any> | BaseSchemaAsync<TFieldValues, TFieldValues, any>} schema - The Valibot schema to validate against\n * @param {Partial<Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>>} [schemaOptions] - Optional Valibot validation options\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {('sync' | 'async')} [resolverOptions.mode] - Validation mode\n * @param {boolean} [resolverOptions.raw] - If true, returns raw values rather than validated results\n * @returns {Resolver<InferOutput<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = valibot.object({\n *   name: valibot.string().minLength(2),\n *   age: valibot.number().min(18)\n * });\n *\n * useForm({\n *   resolver: valibotResolver(schema)\n * });\n */\nexport function valibotResolver<TFieldValues extends FieldValues>(\n  schema:\n    | BaseSchema<TFieldValues, TFieldValues, any>\n    | BaseSchemaAsync<TFieldValues, TFieldValues, any>,\n  schemaOptions?: Partial<\n    Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>\n  >,\n  resolverOptions: {\n    /**\n     * @default async\n     */\n    mode?: 'sync' | 'async';\n    /**\n     * Return the raw input values rather than the parsed values.\n     * @default false\n     */\n    raw?: boolean;\n  } = {},\n): Resolver<InferOutput<typeof schema>> {\n  return async (values, _, options) => {\n    // Check if we should validate all field criteria\n    const validateAllFieldCriteria =\n      !options.shouldUseNativeValidation && options.criteriaMode === 'all';\n\n    // Parse values with Valibot schema\n    const result = await safeParseAsync(\n      schema,\n      values,\n      Object.assign({}, schemaOptions, {\n        abortPipeEarly: !validateAllFieldCriteria,\n      }),\n    );\n\n    // If there are issues, return them as errors\n    if (result.issues) {\n      // Create errors object\n      const errors: Record<string, FieldError> = {};\n\n      // Iterate over issues to add them to errors object\n      for (; result.issues.length; ) {\n        const issue = result.issues[0];\n        // Create dot path from issue\n        const path = getDotPath(issue);\n\n        if (path) {\n          // Add first error of path to errors object\n          if (!errors[path]) {\n            errors[path] = { message: issue.message, type: issue.type };\n          }\n\n          // If configured, add all errors of path to errors object\n          if (validateAllFieldCriteria) {\n            const types = errors[path].types;\n            const messages = types && types[issue.type];\n            errors[path] = appendErrors(\n              path,\n              validateAllFieldCriteria,\n              errors,\n              issue.type,\n              messages\n                ? ([] as string[]).concat(\n                    messages as string | string[],\n                    issue.message,\n                  )\n                : issue.message,\n            ) as FieldError;\n          }\n        }\n\n        result.issues.shift();\n      }\n\n      // Return resolver result with errors\n      return {\n        values: {},\n        errors: toNestErrors(errors, options),\n      } as const;\n    }\n\n    // Otherwise, return resolver result with values\n    return {\n      values: resolverOptions.raw\n        ? Object.assign({}, values)\n        : (result.output as FieldValues),\n      errors: {},\n    };\n  };\n}\n"],"names":["schema","schemaOptions","resolverOptions","values","_","options","validateAllFieldCriteria","shouldUseNativeValidation","criteriaMode","Promise","resolve","safeParseAsync","Object","assign","abortPipeEarly","then","result","issues","errors","length","issue","path","getDotPath","message","type","types","messages","appendErrors","concat","shift","toNestErrors","raw","output","e","reject"],"mappings":"+GAkCM,SACJA,EAGAC,EAGAC,GAYA,YAZAA,IAAAA,IAAAA,EAUI,CAAA,GAEJ,SAAcC,EAAQC,EAAGC,GAAW,IAElC,IAAMC,GACHD,EAAQE,2BAAsD,QAAzBF,EAAQG,aAAuB,OAAAC,QAAAC,QAGlDC,EAAAA,eACnBX,EACAG,EACAS,OAAOC,OAAO,CAAE,EAAEZ,EAAe,CAC/Ba,gBAAiBR,MAEpBS,KAAA,SANKC,GASN,GAAIA,EAAOC,OAAQ,CAKjB,IAHA,IAAMC,EAAqC,CAAA,EAGpCF,EAAOC,OAAOE,QAAU,CAC7B,IAAMC,EAAQJ,EAAOC,OAAO,GAEtBI,EAAOC,EAAAA,WAAWF,GAExB,GAAIC,IAEGH,EAAOG,KACVH,EAAOG,GAAQ,CAAEE,QAASH,EAAMG,QAASC,KAAMJ,EAAMI,OAInDlB,GAA0B,CAC5B,IAAMmB,EAAQP,EAAOG,GAAMI,MACrBC,EAAWD,GAASA,EAAML,EAAMI,MACtCN,EAAOG,GAAQM,EAAAA,aACbN,EACAf,EACAY,EACAE,EAAMI,KACNE,EACK,GAAgBE,OACfF,EACAN,EAAMG,SAERH,EAAMG,QAEd,CAGFP,EAAOC,OAAOY,OAChB,CAGA,MAAO,CACL1B,OAAQ,CAAA,EACRe,OAAQY,EAAAA,aAAaZ,EAAQb,GAEjC,CAGA,MAAO,CACLF,OAAQD,EAAgB6B,IACpBnB,OAAOC,OAAO,CAAA,EAAIV,GACjBa,EAAOgB,OACZd,OAAQ,CAAA,EACR,EACJ,CAAC,MAAAe,UAAAxB,QAAAyB,OAAAD,EACH,CAAA,CAAA"}
+{"version":3,"file":"valibot.js","sources":["../src/valibot.ts"],"sourcesContent":["import { toNestErrors } from '@hookform/resolvers';\nimport {\n  FieldError,\n  FieldValues,\n  Resolver,\n  appendErrors,\n} from 'react-hook-form';\nimport { getDotPath, safeParseAsync } from 'valibot';\nimport { BaseSchema, BaseSchemaAsync, Config, InferIssue } from 'valibot';\n\nexport function valibotResolver<Input extends FieldValues, Context, Output>(\n  schema: BaseSchema<Input, Output, any> | BaseSchemaAsync<Input, Output, any>,\n  schemaOptions?: Partial<\n    Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>\n  >,\n  resolverOptions?: {\n    mode?: 'async' | 'sync';\n    raw?: false;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function valibotResolver<Input extends FieldValues, Context, Output>(\n  schema: BaseSchema<Input, Output, any> | BaseSchemaAsync<Input, Output, any>,\n  schemaOptions:\n    | Partial<\n        Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>\n      >\n    | undefined,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Valibot schema validation\n * @param {BaseSchema<TFieldValues, TFieldValues, any> | BaseSchemaAsync<TFieldValues, TFieldValues, any>} schema - The Valibot schema to validate against\n * @param {Partial<Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>>} [schemaOptions] - Optional Valibot validation options\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {('sync' | 'async')} [resolverOptions.mode] - Validation mode\n * @param {boolean} [resolverOptions.raw] - If true, returns raw values rather than validated results\n * @returns {Resolver<InferOutput<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = valibot.object({\n *   name: valibot.string().minLength(2),\n *   age: valibot.number().min(18)\n * });\n *\n * useForm({\n *   resolver: valibotResolver(schema)\n * });\n */\nexport function valibotResolver<Input extends FieldValues, Context, Output>(\n  schema: BaseSchema<Input, Output, any> | BaseSchemaAsync<Input, Output, any>,\n  schemaOptions?: Partial<\n    Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>\n  >,\n  resolverOptions: {\n    /**\n     * @default async\n     */\n    mode?: 'sync' | 'async';\n    /**\n     * Return the raw input values rather than the parsed values.\n     * @default false\n     */\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Output | Input> {\n  return async (values: Input, _, options) => {\n    // Check if we should validate all field criteria\n    const validateAllFieldCriteria =\n      !options.shouldUseNativeValidation && options.criteriaMode === 'all';\n\n    // Parse values with Valibot schema\n    const result = await safeParseAsync(\n      schema,\n      values,\n      Object.assign({}, schemaOptions, {\n        abortPipeEarly: !validateAllFieldCriteria,\n      }),\n    );\n\n    // If there are issues, return them as errors\n    if (result.issues) {\n      // Create errors object\n      const errors: Record<string, FieldError> = {};\n\n      // Iterate over issues to add them to errors object\n      for (; result.issues.length; ) {\n        const issue = result.issues[0];\n        // Create dot path from issue\n        const path = getDotPath(issue);\n\n        if (path) {\n          // Add first error of path to errors object\n          if (!errors[path]) {\n            errors[path] = { message: issue.message, type: issue.type };\n          }\n\n          // If configured, add all errors of path to errors object\n          if (validateAllFieldCriteria) {\n            const types = errors[path].types;\n            const messages = types && types[issue.type];\n            errors[path] = appendErrors(\n              path,\n              validateAllFieldCriteria,\n              errors,\n              issue.type,\n              messages\n                ? ([] as string[]).concat(\n                    messages as string | string[],\n                    issue.message,\n                  )\n                : issue.message,\n            ) as FieldError;\n          }\n        }\n\n        result.issues.shift();\n      }\n\n      // Return resolver result with errors\n      return {\n        values: {},\n        errors: toNestErrors(errors, options),\n      } as const;\n    }\n\n    // Otherwise, return resolver result with values\n    return {\n      values: resolverOptions.raw\n        ? Object.assign({}, values)\n        : (result.output as FieldValues),\n      errors: {},\n    };\n  };\n}\n"],"names":["schema","schemaOptions","resolverOptions","values","_","options","validateAllFieldCriteria","shouldUseNativeValidation","criteriaMode","Promise","resolve","safeParseAsync","Object","assign","abortPipeEarly","then","result","issues","errors","length","issue","path","getDotPath","message","type","types","messages","appendErrors","concat","shift","toNestErrors","raw","output","e","reject"],"mappings":"+GAoDM,SACJA,EACAC,EAGAC,GAYA,YAZAA,IAAAA,IAAAA,EAUI,CAAA,GAEJ,SAAcC,EAAeC,EAAGC,GAAW,IAEzC,IAAMC,GACHD,EAAQE,2BAAsD,QAAzBF,EAAQG,aAAuB,OAAAC,QAAAC,QAGlDC,EAAAA,eACnBX,EACAG,EACAS,OAAOC,OAAO,CAAE,EAAEZ,EAAe,CAC/Ba,gBAAiBR,MAEpBS,KAAA,SANKC,GASN,GAAIA,EAAOC,OAAQ,CAKjB,IAHA,IAAMC,EAAqC,CAAA,EAGpCF,EAAOC,OAAOE,QAAU,CAC7B,IAAMC,EAAQJ,EAAOC,OAAO,GAEtBI,EAAOC,EAAAA,WAAWF,GAExB,GAAIC,IAEGH,EAAOG,KACVH,EAAOG,GAAQ,CAAEE,QAASH,EAAMG,QAASC,KAAMJ,EAAMI,OAInDlB,GAA0B,CAC5B,IAAMmB,EAAQP,EAAOG,GAAMI,MACrBC,EAAWD,GAASA,EAAML,EAAMI,MACtCN,EAAOG,GAAQM,EAAAA,aACbN,EACAf,EACAY,EACAE,EAAMI,KACNE,EACK,GAAgBE,OACfF,EACAN,EAAMG,SAERH,EAAMG,QAEd,CAGFP,EAAOC,OAAOY,OAChB,CAGA,MAAO,CACL1B,OAAQ,CAAA,EACRe,OAAQY,EAAAA,aAAaZ,EAAQb,GAEjC,CAGA,MAAO,CACLF,OAAQD,EAAgB6B,IACpBnB,OAAOC,OAAO,CAAA,EAAIV,GACjBa,EAAOgB,OACZd,OAAQ,CAAA,EACR,EACJ,CAAC,MAAAe,UAAAxB,QAAAyB,OAAAD,EACH,CAAA,CAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"valibot.modern.mjs","sources":["../src/valibot.ts"],"sourcesContent":["import { toNestErrors } from '@hookform/resolvers';\nimport {\n  FieldError,\n  FieldValues,\n  Resolver,\n  appendErrors,\n} from 'react-hook-form';\nimport { getDotPath, safeParseAsync } from 'valibot';\nimport {\n  BaseSchema,\n  BaseSchemaAsync,\n  Config,\n  InferIssue,\n  InferOutput,\n} from 'valibot';\n\n/**\n * Creates a resolver for react-hook-form using Valibot schema validation\n * @param {BaseSchema<TFieldValues, TFieldValues, any> | BaseSchemaAsync<TFieldValues, TFieldValues, any>} schema - The Valibot schema to validate against\n * @param {Partial<Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>>} [schemaOptions] - Optional Valibot validation options\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {('sync' | 'async')} [resolverOptions.mode] - Validation mode\n * @param {boolean} [resolverOptions.raw] - If true, returns raw values rather than validated results\n * @returns {Resolver<InferOutput<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = valibot.object({\n *   name: valibot.string().minLength(2),\n *   age: valibot.number().min(18)\n * });\n *\n * useForm({\n *   resolver: valibotResolver(schema)\n * });\n */\nexport function valibotResolver<TFieldValues extends FieldValues>(\n  schema:\n    | BaseSchema<TFieldValues, TFieldValues, any>\n    | BaseSchemaAsync<TFieldValues, TFieldValues, any>,\n  schemaOptions?: Partial<\n    Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>\n  >,\n  resolverOptions: {\n    /**\n     * @default async\n     */\n    mode?: 'sync' | 'async';\n    /**\n     * Return the raw input values rather than the parsed values.\n     * @default false\n     */\n    raw?: boolean;\n  } = {},\n): Resolver<InferOutput<typeof schema>> {\n  return async (values, _, options) => {\n    // Check if we should validate all field criteria\n    const validateAllFieldCriteria =\n      !options.shouldUseNativeValidation && options.criteriaMode === 'all';\n\n    // Parse values with Valibot schema\n    const result = await safeParseAsync(\n      schema,\n      values,\n      Object.assign({}, schemaOptions, {\n        abortPipeEarly: !validateAllFieldCriteria,\n      }),\n    );\n\n    // If there are issues, return them as errors\n    if (result.issues) {\n      // Create errors object\n      const errors: Record<string, FieldError> = {};\n\n      // Iterate over issues to add them to errors object\n      for (; result.issues.length; ) {\n        const issue = result.issues[0];\n        // Create dot path from issue\n        const path = getDotPath(issue);\n\n        if (path) {\n          // Add first error of path to errors object\n          if (!errors[path]) {\n            errors[path] = { message: issue.message, type: issue.type };\n          }\n\n          // If configured, add all errors of path to errors object\n          if (validateAllFieldCriteria) {\n            const types = errors[path].types;\n            const messages = types && types[issue.type];\n            errors[path] = appendErrors(\n              path,\n              validateAllFieldCriteria,\n              errors,\n              issue.type,\n              messages\n                ? ([] as string[]).concat(\n                    messages as string | string[],\n                    issue.message,\n                  )\n                : issue.message,\n            ) as FieldError;\n          }\n        }\n\n        result.issues.shift();\n      }\n\n      // Return resolver result with errors\n      return {\n        values: {},\n        errors: toNestErrors(errors, options),\n      } as const;\n    }\n\n    // Otherwise, return resolver result with values\n    return {\n      values: resolverOptions.raw\n        ? Object.assign({}, values)\n        : (result.output as FieldValues),\n      errors: {},\n    };\n  };\n}\n"],"names":["valibotResolver","schema","schemaOptions","resolverOptions","values","_","options","validateAllFieldCriteria","shouldUseNativeValidation","criteriaMode","result","safeParseAsync","Object","assign","abortPipeEarly","issues","errors","length","issue","path","getDotPath","message","type","types","messages","appendErrors","concat","shift","toNestErrors","raw","output"],"mappings":"2JAkCgB,SAAAA,EACdC,EAGAC,EAGAC,EAUI,CAAA,GAEJ,OAAcC,MAAAA,EAAQC,EAAGC,KAEvB,MAAMC,GACHD,EAAQE,2BAAsD,QAAzBF,EAAQG,aAG1CC,QAAeC,EACnBV,EACAG,EACAQ,OAAOC,OAAO,CAAE,EAAEX,EAAe,CAC/BY,gBAAiBP,KAKrB,GAAIG,EAAOK,OAAQ,CAEjB,MAAMC,EAAqC,CAAA,EAG3C,KAAON,EAAOK,OAAOE,QAAU,CAC7B,MAAMC,EAAQR,EAAOK,OAAO,GAEtBI,EAAOC,EAAWF,GAExB,GAAIC,IAEGH,EAAOG,KACVH,EAAOG,GAAQ,CAAEE,QAASH,EAAMG,QAASC,KAAMJ,EAAMI,OAInDf,GAA0B,CAC5B,MAAMgB,EAAQP,EAAOG,GAAMI,MACrBC,EAAWD,GAASA,EAAML,EAAMI,MACtCN,EAAOG,GAAQM,EACbN,EACAZ,EACAS,EACAE,EAAMI,KACNE,EACK,GAAgBE,OACfF,EACAN,EAAMG,SAERH,EAAMG,QAEd,CAGFX,EAAOK,OAAOY,OAChB,CAGA,MAAO,CACLvB,OAAQ,CAAE,EACVY,OAAQY,EAAaZ,EAAQV,GAEjC,CAGA,MAAO,CACLF,OAAQD,EAAgB0B,IACpBjB,OAAOC,OAAO,CAAA,EAAIT,GACjBM,EAAOoB,OACZd,OAAQ,IAGd"}
+{"version":3,"file":"valibot.modern.mjs","sources":["../src/valibot.ts"],"sourcesContent":["import { toNestErrors } from '@hookform/resolvers';\nimport {\n  FieldError,\n  FieldValues,\n  Resolver,\n  appendErrors,\n} from 'react-hook-form';\nimport { getDotPath, safeParseAsync } from 'valibot';\nimport { BaseSchema, BaseSchemaAsync, Config, InferIssue } from 'valibot';\n\nexport function valibotResolver<Input extends FieldValues, Context, Output>(\n  schema: BaseSchema<Input, Output, any> | BaseSchemaAsync<Input, Output, any>,\n  schemaOptions?: Partial<\n    Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>\n  >,\n  resolverOptions?: {\n    mode?: 'async' | 'sync';\n    raw?: false;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function valibotResolver<Input extends FieldValues, Context, Output>(\n  schema: BaseSchema<Input, Output, any> | BaseSchemaAsync<Input, Output, any>,\n  schemaOptions:\n    | Partial<\n        Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>\n      >\n    | undefined,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Valibot schema validation\n * @param {BaseSchema<TFieldValues, TFieldValues, any> | BaseSchemaAsync<TFieldValues, TFieldValues, any>} schema - The Valibot schema to validate against\n * @param {Partial<Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>>} [schemaOptions] - Optional Valibot validation options\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {('sync' | 'async')} [resolverOptions.mode] - Validation mode\n * @param {boolean} [resolverOptions.raw] - If true, returns raw values rather than validated results\n * @returns {Resolver<InferOutput<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = valibot.object({\n *   name: valibot.string().minLength(2),\n *   age: valibot.number().min(18)\n * });\n *\n * useForm({\n *   resolver: valibotResolver(schema)\n * });\n */\nexport function valibotResolver<Input extends FieldValues, Context, Output>(\n  schema: BaseSchema<Input, Output, any> | BaseSchemaAsync<Input, Output, any>,\n  schemaOptions?: Partial<\n    Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>\n  >,\n  resolverOptions: {\n    /**\n     * @default async\n     */\n    mode?: 'sync' | 'async';\n    /**\n     * Return the raw input values rather than the parsed values.\n     * @default false\n     */\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Output | Input> {\n  return async (values: Input, _, options) => {\n    // Check if we should validate all field criteria\n    const validateAllFieldCriteria =\n      !options.shouldUseNativeValidation && options.criteriaMode === 'all';\n\n    // Parse values with Valibot schema\n    const result = await safeParseAsync(\n      schema,\n      values,\n      Object.assign({}, schemaOptions, {\n        abortPipeEarly: !validateAllFieldCriteria,\n      }),\n    );\n\n    // If there are issues, return them as errors\n    if (result.issues) {\n      // Create errors object\n      const errors: Record<string, FieldError> = {};\n\n      // Iterate over issues to add them to errors object\n      for (; result.issues.length; ) {\n        const issue = result.issues[0];\n        // Create dot path from issue\n        const path = getDotPath(issue);\n\n        if (path) {\n          // Add first error of path to errors object\n          if (!errors[path]) {\n            errors[path] = { message: issue.message, type: issue.type };\n          }\n\n          // If configured, add all errors of path to errors object\n          if (validateAllFieldCriteria) {\n            const types = errors[path].types;\n            const messages = types && types[issue.type];\n            errors[path] = appendErrors(\n              path,\n              validateAllFieldCriteria,\n              errors,\n              issue.type,\n              messages\n                ? ([] as string[]).concat(\n                    messages as string | string[],\n                    issue.message,\n                  )\n                : issue.message,\n            ) as FieldError;\n          }\n        }\n\n        result.issues.shift();\n      }\n\n      // Return resolver result with errors\n      return {\n        values: {},\n        errors: toNestErrors(errors, options),\n      } as const;\n    }\n\n    // Otherwise, return resolver result with values\n    return {\n      values: resolverOptions.raw\n        ? Object.assign({}, values)\n        : (result.output as FieldValues),\n      errors: {},\n    };\n  };\n}\n"],"names":["valibotResolver","schema","schemaOptions","resolverOptions","values","_","options","validateAllFieldCriteria","shouldUseNativeValidation","criteriaMode","result","safeParseAsync","Object","assign","abortPipeEarly","issues","errors","length","issue","path","getDotPath","message","type","types","messages","appendErrors","concat","shift","toNestErrors","raw","output"],"mappings":"2JAoDgB,SAAAA,EACdC,EACAC,EAGAC,EAUI,CAAA,GAEJ,OAAcC,MAAAA,EAAeC,EAAGC,KAE9B,MAAMC,GACHD,EAAQE,2BAAsD,QAAzBF,EAAQG,aAG1CC,QAAeC,EACnBV,EACAG,EACAQ,OAAOC,OAAO,CAAE,EAAEX,EAAe,CAC/BY,gBAAiBP,KAKrB,GAAIG,EAAOK,OAAQ,CAEjB,MAAMC,EAAqC,CAAA,EAG3C,KAAON,EAAOK,OAAOE,QAAU,CAC7B,MAAMC,EAAQR,EAAOK,OAAO,GAEtBI,EAAOC,EAAWF,GAExB,GAAIC,IAEGH,EAAOG,KACVH,EAAOG,GAAQ,CAAEE,QAASH,EAAMG,QAASC,KAAMJ,EAAMI,OAInDf,GAA0B,CAC5B,MAAMgB,EAAQP,EAAOG,GAAMI,MACrBC,EAAWD,GAASA,EAAML,EAAMI,MACtCN,EAAOG,GAAQM,EACbN,EACAZ,EACAS,EACAE,EAAMI,KACNE,EACK,GAAgBE,OACfF,EACAN,EAAMG,SAERH,EAAMG,QAEd,CAGFX,EAAOK,OAAOY,OAChB,CAGA,MAAO,CACLvB,OAAQ,CAAE,EACVY,OAAQY,EAAaZ,EAAQV,GAEjC,CAGA,MAAO,CACLF,OAAQD,EAAgB0B,IACpBjB,OAAOC,OAAO,CAAA,EAAIT,GACjBM,EAAOoB,OACZd,OAAQ,IAGd"}

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

@@ -1 +1 @@
-{"version":3,"file":"valibot.module.js","sources":["../src/valibot.ts"],"sourcesContent":["import { toNestErrors } from '@hookform/resolvers';\nimport {\n  FieldError,\n  FieldValues,\n  Resolver,\n  appendErrors,\n} from 'react-hook-form';\nimport { getDotPath, safeParseAsync } from 'valibot';\nimport {\n  BaseSchema,\n  BaseSchemaAsync,\n  Config,\n  InferIssue,\n  InferOutput,\n} from 'valibot';\n\n/**\n * Creates a resolver for react-hook-form using Valibot schema validation\n * @param {BaseSchema<TFieldValues, TFieldValues, any> | BaseSchemaAsync<TFieldValues, TFieldValues, any>} schema - The Valibot schema to validate against\n * @param {Partial<Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>>} [schemaOptions] - Optional Valibot validation options\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {('sync' | 'async')} [resolverOptions.mode] - Validation mode\n * @param {boolean} [resolverOptions.raw] - If true, returns raw values rather than validated results\n * @returns {Resolver<InferOutput<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = valibot.object({\n *   name: valibot.string().minLength(2),\n *   age: valibot.number().min(18)\n * });\n *\n * useForm({\n *   resolver: valibotResolver(schema)\n * });\n */\nexport function valibotResolver<TFieldValues extends FieldValues>(\n  schema:\n    | BaseSchema<TFieldValues, TFieldValues, any>\n    | BaseSchemaAsync<TFieldValues, TFieldValues, any>,\n  schemaOptions?: Partial<\n    Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>\n  >,\n  resolverOptions: {\n    /**\n     * @default async\n     */\n    mode?: 'sync' | 'async';\n    /**\n     * Return the raw input values rather than the parsed values.\n     * @default false\n     */\n    raw?: boolean;\n  } = {},\n): Resolver<InferOutput<typeof schema>> {\n  return async (values, _, options) => {\n    // Check if we should validate all field criteria\n    const validateAllFieldCriteria =\n      !options.shouldUseNativeValidation && options.criteriaMode === 'all';\n\n    // Parse values with Valibot schema\n    const result = await safeParseAsync(\n      schema,\n      values,\n      Object.assign({}, schemaOptions, {\n        abortPipeEarly: !validateAllFieldCriteria,\n      }),\n    );\n\n    // If there are issues, return them as errors\n    if (result.issues) {\n      // Create errors object\n      const errors: Record<string, FieldError> = {};\n\n      // Iterate over issues to add them to errors object\n      for (; result.issues.length; ) {\n        const issue = result.issues[0];\n        // Create dot path from issue\n        const path = getDotPath(issue);\n\n        if (path) {\n          // Add first error of path to errors object\n          if (!errors[path]) {\n            errors[path] = { message: issue.message, type: issue.type };\n          }\n\n          // If configured, add all errors of path to errors object\n          if (validateAllFieldCriteria) {\n            const types = errors[path].types;\n            const messages = types && types[issue.type];\n            errors[path] = appendErrors(\n              path,\n              validateAllFieldCriteria,\n              errors,\n              issue.type,\n              messages\n                ? ([] as string[]).concat(\n                    messages as string | string[],\n                    issue.message,\n                  )\n                : issue.message,\n            ) as FieldError;\n          }\n        }\n\n        result.issues.shift();\n      }\n\n      // Return resolver result with errors\n      return {\n        values: {},\n        errors: toNestErrors(errors, options),\n      } as const;\n    }\n\n    // Otherwise, return resolver result with values\n    return {\n      values: resolverOptions.raw\n        ? Object.assign({}, values)\n        : (result.output as FieldValues),\n      errors: {},\n    };\n  };\n}\n"],"names":["valibotResolver","schema","schemaOptions","resolverOptions","values","_","options","validateAllFieldCriteria","shouldUseNativeValidation","criteriaMode","Promise","resolve","safeParseAsync","Object","assign","abortPipeEarly","then","result","issues","errors","length","issue","path","getDotPath","message","type","types","messages","appendErrors","concat","shift","toNestErrors","raw","output","e","reject"],"mappings":"2JAkCM,SAAUA,EACdC,EAGAC,EAGAC,GAYA,YAZAA,IAAAA,IAAAA,EAUI,CAAA,GAEJ,SAAcC,EAAQC,EAAGC,GAAW,IAElC,IAAMC,GACHD,EAAQE,2BAAsD,QAAzBF,EAAQG,aAAuB,OAAAC,QAAAC,QAGlDC,EACnBX,EACAG,EACAS,OAAOC,OAAO,CAAE,EAAEZ,EAAe,CAC/Ba,gBAAiBR,MAEpBS,KAAA,SANKC,GASN,GAAIA,EAAOC,OAAQ,CAKjB,IAHA,IAAMC,EAAqC,CAAA,EAGpCF,EAAOC,OAAOE,QAAU,CAC7B,IAAMC,EAAQJ,EAAOC,OAAO,GAEtBI,EAAOC,EAAWF,GAExB,GAAIC,IAEGH,EAAOG,KACVH,EAAOG,GAAQ,CAAEE,QAASH,EAAMG,QAASC,KAAMJ,EAAMI,OAInDlB,GAA0B,CAC5B,IAAMmB,EAAQP,EAAOG,GAAMI,MACrBC,EAAWD,GAASA,EAAML,EAAMI,MACtCN,EAAOG,GAAQM,EACbN,EACAf,EACAY,EACAE,EAAMI,KACNE,EACK,GAAgBE,OACfF,EACAN,EAAMG,SAERH,EAAMG,QAEd,CAGFP,EAAOC,OAAOY,OAChB,CAGA,MAAO,CACL1B,OAAQ,CAAA,EACRe,OAAQY,EAAaZ,EAAQb,GAEjC,CAGA,MAAO,CACLF,OAAQD,EAAgB6B,IACpBnB,OAAOC,OAAO,CAAA,EAAIV,GACjBa,EAAOgB,OACZd,OAAQ,CAAA,EACR,EACJ,CAAC,MAAAe,UAAAxB,QAAAyB,OAAAD,EACH,CAAA,CAAA"}
+{"version":3,"file":"valibot.module.js","sources":["../src/valibot.ts"],"sourcesContent":["import { toNestErrors } from '@hookform/resolvers';\nimport {\n  FieldError,\n  FieldValues,\n  Resolver,\n  appendErrors,\n} from 'react-hook-form';\nimport { getDotPath, safeParseAsync } from 'valibot';\nimport { BaseSchema, BaseSchemaAsync, Config, InferIssue } from 'valibot';\n\nexport function valibotResolver<Input extends FieldValues, Context, Output>(\n  schema: BaseSchema<Input, Output, any> | BaseSchemaAsync<Input, Output, any>,\n  schemaOptions?: Partial<\n    Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>\n  >,\n  resolverOptions?: {\n    mode?: 'async' | 'sync';\n    raw?: false;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function valibotResolver<Input extends FieldValues, Context, Output>(\n  schema: BaseSchema<Input, Output, any> | BaseSchemaAsync<Input, Output, any>,\n  schemaOptions:\n    | Partial<\n        Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>\n      >\n    | undefined,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Valibot schema validation\n * @param {BaseSchema<TFieldValues, TFieldValues, any> | BaseSchemaAsync<TFieldValues, TFieldValues, any>} schema - The Valibot schema to validate against\n * @param {Partial<Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>>} [schemaOptions] - Optional Valibot validation options\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {('sync' | 'async')} [resolverOptions.mode] - Validation mode\n * @param {boolean} [resolverOptions.raw] - If true, returns raw values rather than validated results\n * @returns {Resolver<InferOutput<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = valibot.object({\n *   name: valibot.string().minLength(2),\n *   age: valibot.number().min(18)\n * });\n *\n * useForm({\n *   resolver: valibotResolver(schema)\n * });\n */\nexport function valibotResolver<Input extends FieldValues, Context, Output>(\n  schema: BaseSchema<Input, Output, any> | BaseSchemaAsync<Input, Output, any>,\n  schemaOptions?: Partial<\n    Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>\n  >,\n  resolverOptions: {\n    /**\n     * @default async\n     */\n    mode?: 'sync' | 'async';\n    /**\n     * Return the raw input values rather than the parsed values.\n     * @default false\n     */\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Output | Input> {\n  return async (values: Input, _, options) => {\n    // Check if we should validate all field criteria\n    const validateAllFieldCriteria =\n      !options.shouldUseNativeValidation && options.criteriaMode === 'all';\n\n    // Parse values with Valibot schema\n    const result = await safeParseAsync(\n      schema,\n      values,\n      Object.assign({}, schemaOptions, {\n        abortPipeEarly: !validateAllFieldCriteria,\n      }),\n    );\n\n    // If there are issues, return them as errors\n    if (result.issues) {\n      // Create errors object\n      const errors: Record<string, FieldError> = {};\n\n      // Iterate over issues to add them to errors object\n      for (; result.issues.length; ) {\n        const issue = result.issues[0];\n        // Create dot path from issue\n        const path = getDotPath(issue);\n\n        if (path) {\n          // Add first error of path to errors object\n          if (!errors[path]) {\n            errors[path] = { message: issue.message, type: issue.type };\n          }\n\n          // If configured, add all errors of path to errors object\n          if (validateAllFieldCriteria) {\n            const types = errors[path].types;\n            const messages = types && types[issue.type];\n            errors[path] = appendErrors(\n              path,\n              validateAllFieldCriteria,\n              errors,\n              issue.type,\n              messages\n                ? ([] as string[]).concat(\n                    messages as string | string[],\n                    issue.message,\n                  )\n                : issue.message,\n            ) as FieldError;\n          }\n        }\n\n        result.issues.shift();\n      }\n\n      // Return resolver result with errors\n      return {\n        values: {},\n        errors: toNestErrors(errors, options),\n      } as const;\n    }\n\n    // Otherwise, return resolver result with values\n    return {\n      values: resolverOptions.raw\n        ? Object.assign({}, values)\n        : (result.output as FieldValues),\n      errors: {},\n    };\n  };\n}\n"],"names":["valibotResolver","schema","schemaOptions","resolverOptions","values","_","options","validateAllFieldCriteria","shouldUseNativeValidation","criteriaMode","Promise","resolve","safeParseAsync","Object","assign","abortPipeEarly","then","result","issues","errors","length","issue","path","getDotPath","message","type","types","messages","appendErrors","concat","shift","toNestErrors","raw","output","e","reject"],"mappings":"2JAoDM,SAAUA,EACdC,EACAC,EAGAC,GAYA,YAZAA,IAAAA,IAAAA,EAUI,CAAA,GAEJ,SAAcC,EAAeC,EAAGC,GAAW,IAEzC,IAAMC,GACHD,EAAQE,2BAAsD,QAAzBF,EAAQG,aAAuB,OAAAC,QAAAC,QAGlDC,EACnBX,EACAG,EACAS,OAAOC,OAAO,CAAE,EAAEZ,EAAe,CAC/Ba,gBAAiBR,MAEpBS,KAAA,SANKC,GASN,GAAIA,EAAOC,OAAQ,CAKjB,IAHA,IAAMC,EAAqC,CAAA,EAGpCF,EAAOC,OAAOE,QAAU,CAC7B,IAAMC,EAAQJ,EAAOC,OAAO,GAEtBI,EAAOC,EAAWF,GAExB,GAAIC,IAEGH,EAAOG,KACVH,EAAOG,GAAQ,CAAEE,QAASH,EAAMG,QAASC,KAAMJ,EAAMI,OAInDlB,GAA0B,CAC5B,IAAMmB,EAAQP,EAAOG,GAAMI,MACrBC,EAAWD,GAASA,EAAML,EAAMI,MACtCN,EAAOG,GAAQM,EACbN,EACAf,EACAY,EACAE,EAAMI,KACNE,EACK,GAAgBE,OACfF,EACAN,EAAMG,SAERH,EAAMG,QAEd,CAGFP,EAAOC,OAAOY,OAChB,CAGA,MAAO,CACL1B,OAAQ,CAAA,EACRe,OAAQY,EAAaZ,EAAQb,GAEjC,CAGA,MAAO,CACLF,OAAQD,EAAgB6B,IACpBnB,OAAOC,OAAO,CAAA,EAAIV,GACjBa,EAAOgB,OACZd,OAAQ,CAAA,EACR,EACJ,CAAC,MAAAe,UAAAxB,QAAAyB,OAAAD,EACH,CAAA,CAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"valibot.umd.js","sources":["../src/valibot.ts"],"sourcesContent":["import { toNestErrors } from '@hookform/resolvers';\nimport {\n  FieldError,\n  FieldValues,\n  Resolver,\n  appendErrors,\n} from 'react-hook-form';\nimport { getDotPath, safeParseAsync } from 'valibot';\nimport {\n  BaseSchema,\n  BaseSchemaAsync,\n  Config,\n  InferIssue,\n  InferOutput,\n} from 'valibot';\n\n/**\n * Creates a resolver for react-hook-form using Valibot schema validation\n * @param {BaseSchema<TFieldValues, TFieldValues, any> | BaseSchemaAsync<TFieldValues, TFieldValues, any>} schema - The Valibot schema to validate against\n * @param {Partial<Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>>} [schemaOptions] - Optional Valibot validation options\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {('sync' | 'async')} [resolverOptions.mode] - Validation mode\n * @param {boolean} [resolverOptions.raw] - If true, returns raw values rather than validated results\n * @returns {Resolver<InferOutput<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = valibot.object({\n *   name: valibot.string().minLength(2),\n *   age: valibot.number().min(18)\n * });\n *\n * useForm({\n *   resolver: valibotResolver(schema)\n * });\n */\nexport function valibotResolver<TFieldValues extends FieldValues>(\n  schema:\n    | BaseSchema<TFieldValues, TFieldValues, any>\n    | BaseSchemaAsync<TFieldValues, TFieldValues, any>,\n  schemaOptions?: Partial<\n    Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>\n  >,\n  resolverOptions: {\n    /**\n     * @default async\n     */\n    mode?: 'sync' | 'async';\n    /**\n     * Return the raw input values rather than the parsed values.\n     * @default false\n     */\n    raw?: boolean;\n  } = {},\n): Resolver<InferOutput<typeof schema>> {\n  return async (values, _, options) => {\n    // Check if we should validate all field criteria\n    const validateAllFieldCriteria =\n      !options.shouldUseNativeValidation && options.criteriaMode === 'all';\n\n    // Parse values with Valibot schema\n    const result = await safeParseAsync(\n      schema,\n      values,\n      Object.assign({}, schemaOptions, {\n        abortPipeEarly: !validateAllFieldCriteria,\n      }),\n    );\n\n    // If there are issues, return them as errors\n    if (result.issues) {\n      // Create errors object\n      const errors: Record<string, FieldError> = {};\n\n      // Iterate over issues to add them to errors object\n      for (; result.issues.length; ) {\n        const issue = result.issues[0];\n        // Create dot path from issue\n        const path = getDotPath(issue);\n\n        if (path) {\n          // Add first error of path to errors object\n          if (!errors[path]) {\n            errors[path] = { message: issue.message, type: issue.type };\n          }\n\n          // If configured, add all errors of path to errors object\n          if (validateAllFieldCriteria) {\n            const types = errors[path].types;\n            const messages = types && types[issue.type];\n            errors[path] = appendErrors(\n              path,\n              validateAllFieldCriteria,\n              errors,\n              issue.type,\n              messages\n                ? ([] as string[]).concat(\n                    messages as string | string[],\n                    issue.message,\n                  )\n                : issue.message,\n            ) as FieldError;\n          }\n        }\n\n        result.issues.shift();\n      }\n\n      // Return resolver result with errors\n      return {\n        values: {},\n        errors: toNestErrors(errors, options),\n      } as const;\n    }\n\n    // Otherwise, return resolver result with values\n    return {\n      values: resolverOptions.raw\n        ? Object.assign({}, values)\n        : (result.output as FieldValues),\n      errors: {},\n    };\n  };\n}\n"],"names":["schema","schemaOptions","resolverOptions","values","_","options","validateAllFieldCriteria","shouldUseNativeValidation","criteriaMode","Promise","resolve","safeParseAsync","Object","assign","abortPipeEarly","then","result","issues","errors","length","issue","path","getDotPath","message","type","types","messages","appendErrors","concat","shift","toNestErrors","raw","output","e","reject"],"mappings":"ubAkCM,SACJA,EAGAC,EAGAC,GAYA,YAZAA,IAAAA,IAAAA,EAUI,CAAA,GAEJ,SAAcC,EAAQC,EAAGC,GAAW,IAElC,IAAMC,GACHD,EAAQE,2BAAsD,QAAzBF,EAAQG,aAAuB,OAAAC,QAAAC,QAGlDC,EAAAA,eACnBX,EACAG,EACAS,OAAOC,OAAO,CAAE,EAAEZ,EAAe,CAC/Ba,gBAAiBR,MAEpBS,KAAA,SANKC,GASN,GAAIA,EAAOC,OAAQ,CAKjB,IAHA,IAAMC,EAAqC,CAAA,EAGpCF,EAAOC,OAAOE,QAAU,CAC7B,IAAMC,EAAQJ,EAAOC,OAAO,GAEtBI,EAAOC,EAAAA,WAAWF,GAExB,GAAIC,IAEGH,EAAOG,KACVH,EAAOG,GAAQ,CAAEE,QAASH,EAAMG,QAASC,KAAMJ,EAAMI,OAInDlB,GAA0B,CAC5B,IAAMmB,EAAQP,EAAOG,GAAMI,MACrBC,EAAWD,GAASA,EAAML,EAAMI,MACtCN,EAAOG,GAAQM,EAAAA,aACbN,EACAf,EACAY,EACAE,EAAMI,KACNE,EACK,GAAgBE,OACfF,EACAN,EAAMG,SAERH,EAAMG,QAEd,CAGFP,EAAOC,OAAOY,OAChB,CAGA,MAAO,CACL1B,OAAQ,CAAA,EACRe,OAAQY,EAAAA,aAAaZ,EAAQb,GAEjC,CAGA,MAAO,CACLF,OAAQD,EAAgB6B,IACpBnB,OAAOC,OAAO,CAAA,EAAIV,GACjBa,EAAOgB,OACZd,OAAQ,CAAA,EACR,EACJ,CAAC,MAAAe,UAAAxB,QAAAyB,OAAAD,EACH,CAAA,CAAA"}
+{"version":3,"file":"valibot.umd.js","sources":["../src/valibot.ts"],"sourcesContent":["import { toNestErrors } from '@hookform/resolvers';\nimport {\n  FieldError,\n  FieldValues,\n  Resolver,\n  appendErrors,\n} from 'react-hook-form';\nimport { getDotPath, safeParseAsync } from 'valibot';\nimport { BaseSchema, BaseSchemaAsync, Config, InferIssue } from 'valibot';\n\nexport function valibotResolver<Input extends FieldValues, Context, Output>(\n  schema: BaseSchema<Input, Output, any> | BaseSchemaAsync<Input, Output, any>,\n  schemaOptions?: Partial<\n    Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>\n  >,\n  resolverOptions?: {\n    mode?: 'async' | 'sync';\n    raw?: false;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function valibotResolver<Input extends FieldValues, Context, Output>(\n  schema: BaseSchema<Input, Output, any> | BaseSchemaAsync<Input, Output, any>,\n  schemaOptions:\n    | Partial<\n        Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>\n      >\n    | undefined,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Valibot schema validation\n * @param {BaseSchema<TFieldValues, TFieldValues, any> | BaseSchemaAsync<TFieldValues, TFieldValues, any>} schema - The Valibot schema to validate against\n * @param {Partial<Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>>} [schemaOptions] - Optional Valibot validation options\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {('sync' | 'async')} [resolverOptions.mode] - Validation mode\n * @param {boolean} [resolverOptions.raw] - If true, returns raw values rather than validated results\n * @returns {Resolver<InferOutput<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = valibot.object({\n *   name: valibot.string().minLength(2),\n *   age: valibot.number().min(18)\n * });\n *\n * useForm({\n *   resolver: valibotResolver(schema)\n * });\n */\nexport function valibotResolver<Input extends FieldValues, Context, Output>(\n  schema: BaseSchema<Input, Output, any> | BaseSchemaAsync<Input, Output, any>,\n  schemaOptions?: Partial<\n    Omit<Config<InferIssue<typeof schema>>, 'abortPipeEarly' | 'skipPipe'>\n  >,\n  resolverOptions: {\n    /**\n     * @default async\n     */\n    mode?: 'sync' | 'async';\n    /**\n     * Return the raw input values rather than the parsed values.\n     * @default false\n     */\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Output | Input> {\n  return async (values: Input, _, options) => {\n    // Check if we should validate all field criteria\n    const validateAllFieldCriteria =\n      !options.shouldUseNativeValidation && options.criteriaMode === 'all';\n\n    // Parse values with Valibot schema\n    const result = await safeParseAsync(\n      schema,\n      values,\n      Object.assign({}, schemaOptions, {\n        abortPipeEarly: !validateAllFieldCriteria,\n      }),\n    );\n\n    // If there are issues, return them as errors\n    if (result.issues) {\n      // Create errors object\n      const errors: Record<string, FieldError> = {};\n\n      // Iterate over issues to add them to errors object\n      for (; result.issues.length; ) {\n        const issue = result.issues[0];\n        // Create dot path from issue\n        const path = getDotPath(issue);\n\n        if (path) {\n          // Add first error of path to errors object\n          if (!errors[path]) {\n            errors[path] = { message: issue.message, type: issue.type };\n          }\n\n          // If configured, add all errors of path to errors object\n          if (validateAllFieldCriteria) {\n            const types = errors[path].types;\n            const messages = types && types[issue.type];\n            errors[path] = appendErrors(\n              path,\n              validateAllFieldCriteria,\n              errors,\n              issue.type,\n              messages\n                ? ([] as string[]).concat(\n                    messages as string | string[],\n                    issue.message,\n                  )\n                : issue.message,\n            ) as FieldError;\n          }\n        }\n\n        result.issues.shift();\n      }\n\n      // Return resolver result with errors\n      return {\n        values: {},\n        errors: toNestErrors(errors, options),\n      } as const;\n    }\n\n    // Otherwise, return resolver result with values\n    return {\n      values: resolverOptions.raw\n        ? Object.assign({}, values)\n        : (result.output as FieldValues),\n      errors: {},\n    };\n  };\n}\n"],"names":["schema","schemaOptions","resolverOptions","values","_","options","validateAllFieldCriteria","shouldUseNativeValidation","criteriaMode","Promise","resolve","safeParseAsync","Object","assign","abortPipeEarly","then","result","issues","errors","length","issue","path","getDotPath","message","type","types","messages","appendErrors","concat","shift","toNestErrors","raw","output","e","reject"],"mappings":"ubAoDM,SACJA,EACAC,EAGAC,GAYA,YAZAA,IAAAA,IAAAA,EAUI,CAAA,GAEJ,SAAcC,EAAeC,EAAGC,GAAW,IAEzC,IAAMC,GACHD,EAAQE,2BAAsD,QAAzBF,EAAQG,aAAuB,OAAAC,QAAAC,QAGlDC,EAAAA,eACnBX,EACAG,EACAS,OAAOC,OAAO,CAAE,EAAEZ,EAAe,CAC/Ba,gBAAiBR,MAEpBS,KAAA,SANKC,GASN,GAAIA,EAAOC,OAAQ,CAKjB,IAHA,IAAMC,EAAqC,CAAA,EAGpCF,EAAOC,OAAOE,QAAU,CAC7B,IAAMC,EAAQJ,EAAOC,OAAO,GAEtBI,EAAOC,EAAAA,WAAWF,GAExB,GAAIC,IAEGH,EAAOG,KACVH,EAAOG,GAAQ,CAAEE,QAASH,EAAMG,QAASC,KAAMJ,EAAMI,OAInDlB,GAA0B,CAC5B,IAAMmB,EAAQP,EAAOG,GAAMI,MACrBC,EAAWD,GAASA,EAAML,EAAMI,MACtCN,EAAOG,GAAQM,EAAAA,aACbN,EACAf,EACAY,EACAE,EAAMI,KACNE,EACK,GAAgBE,OACfF,EACAN,EAAMG,SAERH,EAAMG,QAEd,CAGFP,EAAOC,OAAOY,OAChB,CAGA,MAAO,CACL1B,OAAQ,CAAA,EACRe,OAAQY,EAAAA,aAAaZ,EAAQb,GAEjC,CAGA,MAAO,CACLF,OAAQD,EAAgB6B,IACpBnB,OAAOC,OAAO,CAAA,EAAIV,GACjBa,EAAOgB,OACZd,OAAQ,CAAA,EACR,EACJ,CAAC,MAAAe,UAAAxB,QAAAyB,OAAAD,EACH,CAAA,CAAA"}

package/valibot/package.json

@@ -12,7 +12,7 @@
   "license": "MIT",
   "peerDependencies": {
     "@hookform/resolvers": "^2.0.0",
-    "react-hook-form": "^7.0.0",
+    "react-hook-form": "7.55.0",
     "valibot": "^1.0.0 || ^1.0.0-beta.4 || ^1.0.0-rc"
   }
 }