@hookform/resolvers 4.1.0 → 4.1.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hookform/resolvers",
   "amdName": "hookformResolvers",
-  "version": "4.1.0",
+  "version": "4.1.1",
   "description": "React Hook Form validation resolvers: Yup, Joi, Superstruct, Zod, Vest, Class Validator, io-ts, Nope, computed-types, TypeBox, arktype, Typanion, Effect-TS and VineJS",
   "main": "dist/resolvers.js",
   "module": "dist/resolvers.module.js",
@@ -269,6 +269,7 @@
   "devDependencies": {
     "@sinclair/typebox": "^0.34.15",
     "@standard-schema/spec": "^1.0.0",
+    "@standard-schema/utils": "^0.3.0",
     "@testing-library/dom": "^10.4.0",
     "@testing-library/jest-dom": "^6.6.3",
     "@testing-library/react": "^16.2.0",

package/standard-schema/dist/standard-schema.d.ts

@@ -20,6 +20,6 @@ import { FieldValues, Resolver } from 'react-hook-form';
  * });
  * ```
  */
-export declare function standardSchemaResolver<TFieldValues extends FieldValues, Schema extends StandardSchemaV1<TFieldValues, any>>(schema: Schema, resolverOptions?: {
+export declare function standardSchemaResolver<Schema extends StandardSchemaV1<FieldValues>>(schema: Schema, resolverOptions?: {
     raw?: boolean;
-}): Resolver<NonNullable<(typeof schema)['~standard']['types']>['output']>;
+}): Resolver<StandardSchemaV1.InferOutput<Schema>>;

package/standard-schema/dist/standard-schema.js

@@ -1,2 +1,2 @@
-var e=require("@hookform/resolvers");function r(){return r=Object.assign?Object.assign.bind():function(e){for(var r=1;r<arguments.length;r++){var t=arguments[r];for(var n in t)({}).hasOwnProperty.call(t,n)&&(e[n]=t[n])}return e},r.apply(null,arguments)}exports.standardSchemaResolver=function(t,n){return void 0===n&&(n={}),function(s,a,i){try{var o=function(){if(l.issues){var t=function(e,t){for(var n={},s=0;s<e.length;s++){var a,i=e[s],o=null==(a=i.path)?void 0:a.join(".");if(o&&(n[o]||(n[o]={message:i.message,type:""}),t)){var l,u=n[o].types||{};n[o].types=r({},u,((l={})[Object.keys(u).length]=i.message,l))}}return n}(l.issues,!i.shouldUseNativeValidation&&"all"===i.criteriaMode);return{values:{},errors:e.toNestErrors(t,i)}}return i.shouldUseNativeValidation&&e.validateFieldsNatively({},i),{values:n.raw?Object.assign({},s):l.value,errors:{}}},l=t["~standard"].validate(s),u=function(){if(l instanceof Promise)return Promise.resolve(l).then(function(e){l=e})}();return Promise.resolve(u&&u.then?u.then(o):o())}catch(e){return Promise.reject(e)}}};
+var e=require("@hookform/resolvers"),r=require("@standard-schema/utils");function t(){return t=Object.assign?Object.assign.bind():function(e){for(var r=1;r<arguments.length;r++){var t=arguments[r];for(var s in t)({}).hasOwnProperty.call(t,s)&&(e[s]=t[s])}return e},t.apply(null,arguments)}exports.standardSchemaResolver=function(s,a){return void 0===a&&(a={}),function(n,i,o){try{var u=function(){if(l.issues){var s=function(e,s){for(var a={},n=0;n<e.length;n++){var i=e[n],o=r.getDotPath(i);if(o&&(a[o]||(a[o]={message:i.message,type:""}),s)){var u,l=a[o].types||{};a[o].types=t({},l,((u={})[Object.keys(l).length]=i.message,u))}}return a}(l.issues,!o.shouldUseNativeValidation&&"all"===o.criteriaMode);return{values:{},errors:e.toNestErrors(s,o)}}return o.shouldUseNativeValidation&&e.validateFieldsNatively({},o),{values:a.raw?Object.assign({},n):l.value,errors:{}}},l=s["~standard"].validate(n),v=function(){if(l instanceof Promise)return Promise.resolve(l).then(function(e){l=e})}();return Promise.resolve(v&&v.then?v.then(u):u())}catch(e){return Promise.reject(e)}}};
 //# sourceMappingURL=standard-schema.js.map

package/standard-schema/dist/standard-schema.js.map

@@ -1 +1 @@
-{"version":3,"file":"standard-schema.js","sources":["../src/standard-schema.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { StandardSchemaV1 } from '@standard-schema/spec';\nimport { FieldError, FieldValues, Resolver } from 'react-hook-form';\n\nfunction parseIssues(\n  issues: readonly StandardSchemaV1.Issue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n\n  for (let i = 0; i < issues.length; i++) {\n    const error = issues[i];\n    const path = error.path?.join('.');\n\n    if (path) {\n      if (!errors[path]) {\n        errors[path] = { message: error.message, type: '' };\n      }\n\n      if (validateAllFieldCriteria) {\n        const types = errors[path].types || {};\n\n        errors[path].types = {\n          ...types,\n          [Object.keys(types).length]: error.message,\n        };\n      }\n    }\n  }\n\n  return errors;\n}\n\n/**\n * Creates a resolver for react-hook-form that validates data using a Standard Schema.\n *\n * @param {Schema} schema - The Standard Schema to validate against\n * @param {Object} resolverOptions - Options for the resolver\n * @param {boolean} [resolverOptions.raw=false] - Whether to return raw input values instead of parsed values\n * @returns {Resolver} A resolver function compatible with react-hook-form\n *\n * @example\n * ```ts\n * const schema = z.object({\n *   name: z.string().min(2),\n *   age: z.number().min(18)\n * });\n *\n * useForm({\n *   resolver: standardSchemaResolver(schema)\n * });\n * ```\n */\nexport function standardSchemaResolver<\n  TFieldValues extends FieldValues,\n  Schema extends StandardSchemaV1<TFieldValues, any>,\n>(\n  schema: Schema,\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<NonNullable<(typeof schema)['~standard']['types']>['output']> {\n  return async (values: TFieldValues, _, 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 = parseIssues(\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","resolverOptions","values","_","options","_temp2","result","issues","errors","validateAllFieldCriteria","i","length","_error$path","error","path","join","message","type","_extends2","types","_extends","Object","keys","parseIssues","shouldUseNativeValidation","criteriaMode","toNestErrors","validateFieldsNatively","raw","assign","value","validate","_temp","Promise","resolve","then","_result","e","reject"],"mappings":"qSAyDEA,EACAC,GAIA,YAJAA,IAAAA,IAAAA,EAEI,CAAE,GAEN,SAAcC,EAAsBC,EAAGC,GAAW,IAAA,IAAAC,EAAAA,WAMhD,GAAIC,EAAOC,OAAQ,CACjB,IAAMC,EAjEZ,SACED,EACAE,GAIA,IAFA,IAAMD,EAAqC,CAAA,EAElCE,EAAI,EAAGA,EAAIH,EAAOI,OAAQD,IAAK,CAAAE,IAAAA,EAChCC,EAAQN,EAAOG,GACfI,EAAOF,OAAHA,EAAGC,EAAMC,WAANF,EAAAA,EAAYG,KAAK,KAE9B,GAAID,IACGN,EAAOM,KACVN,EAAOM,GAAQ,CAAEE,QAASH,EAAMG,QAASC,KAAM,KAG7CR,GAA0B,CAAA,IAAAS,EACtBC,EAAQX,EAAOM,GAAMK,OAAS,CAAA,EAEpCX,EAAOM,GAAMK,MAAKC,EACbD,CAAAA,EAAAA,IAAKD,EAAA,IACPG,OAAOC,KAAKH,GAAOR,QAASE,EAAMG,QAAOE,GAE9C,CAEJ,CAEA,OAAOV,CACT,CAsCqBe,CACbjB,EAAOC,QACNH,EAAQoB,2BAAsD,QAAzBpB,EAAQqB,cAGhD,MAAO,CACLvB,OAAQ,CAAA,EACRM,OAAQkB,EAAYA,aAAClB,EAAQJ,GAEjC,CAIA,OAFAA,EAAQoB,2BAA6BG,EAAAA,uBAAuB,CAAE,EAAEvB,GAEzD,CACLF,OAAQD,EAAgB2B,IAAMP,OAAOQ,OAAO,CAAE,EAAE3B,GAAUI,EAAOwB,MACjEtB,OAAQ,GACR,EAtBEF,EAASN,EAAO,aAAa+B,SAAS7B,GAAQ8B,gBAC9C1B,aAAkB2B,QAAO,OAAAA,QAAAC,QACZ5B,GAAM6B,KAAA,SAAAC,GAArB9B,EAAM8B,CAAgB,EAAAH,IAAAA,OAAAA,QAAAC,QAAAF,GAAAA,EAAAG,KAAAH,EAAAG,KAAA9B,GAAAA,IAqB1B,CAAC,MAAAgC,GAAAJ,OAAAA,QAAAK,OAAAD,EACH,CAAA,CAAA"}
+{"version":3,"file":"standard-schema.js","sources":["../src/standard-schema.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { StandardSchemaV1 } from '@standard-schema/spec';\nimport { getDotPath } from '@standard-schema/utils';\nimport { FieldError, FieldValues, Resolver } from 'react-hook-form';\n\nfunction parseIssues(\n  issues: readonly StandardSchemaV1.Issue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n\n  for (let i = 0; i < issues.length; i++) {\n    const error = issues[i];\n    const path = getDotPath(error);\n\n    if (path) {\n      if (!errors[path]) {\n        errors[path] = { message: error.message, type: '' };\n      }\n\n      if (validateAllFieldCriteria) {\n        const types = errors[path].types || {};\n\n        errors[path].types = {\n          ...types,\n          [Object.keys(types).length]: error.message,\n        };\n      }\n    }\n  }\n\n  return errors;\n}\n\n/**\n * Creates a resolver for react-hook-form that validates data using a Standard Schema.\n *\n * @param {Schema} schema - The Standard Schema to validate against\n * @param {Object} resolverOptions - Options for the resolver\n * @param {boolean} [resolverOptions.raw=false] - Whether to return raw input values instead of parsed values\n * @returns {Resolver} A resolver function compatible with react-hook-form\n *\n * @example\n * ```ts\n * const schema = z.object({\n *   name: z.string().min(2),\n *   age: z.number().min(18)\n * });\n *\n * useForm({\n *   resolver: standardSchemaResolver(schema)\n * });\n * ```\n */\nexport function standardSchemaResolver<\n  Schema extends StandardSchemaV1<FieldValues>,\n>(\n  schema: Schema,\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<StandardSchemaV1.InferOutput<Schema>> {\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 = parseIssues(\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","resolverOptions","values","_","options","_temp2","result","issues","errors","validateAllFieldCriteria","i","length","error","path","getDotPath","message","type","_extends2","types","_extends","Object","keys","parseIssues","shouldUseNativeValidation","criteriaMode","toNestErrors","validateFieldsNatively","raw","assign","value","validate","_temp","Promise","resolve","then","_result","e","reject"],"mappings":"yUAyDEA,EACAC,GAIA,gBAJAA,IAAAA,EAEI,aAEUC,EAAQC,EAAGC,GAAW,IAAA,IAAAC,EAAA,WAMlC,GAAIC,EAAOC,OAAQ,CACjB,IAAMC,EAhEZ,SACED,EACAE,GAIA,IAFA,IAAMD,EAAqC,GAElCE,EAAI,EAAGA,EAAIH,EAAOI,OAAQD,IAAK,CACtC,IAAME,EAAQL,EAAOG,GACfG,EAAOC,EAAAA,WAAWF,GAExB,GAAIC,IACGL,EAAOK,KACVL,EAAOK,GAAQ,CAAEE,QAASH,EAAMG,QAASC,KAAM,KAG7CP,GAA0B,CAAA,IAAAQ,EACtBC,EAAQV,EAAOK,GAAMK,OAAS,CAAE,EAEtCV,EAAOK,GAAMK,MAAKC,EACbD,CAAAA,EAAAA,IAAKD,MACPG,OAAOC,KAAKH,GAAOP,QAASC,EAAMG,QAAOE,GAE9C,CAEJ,CAEA,OAAOT,CACT,CAqCqBc,CACbhB,EAAOC,QACNH,EAAQmB,2BAAsD,QAAzBnB,EAAQoB,cAGhD,MAAO,CACLtB,OAAQ,CAAE,EACVM,OAAQiB,EAAAA,aAAajB,EAAQJ,GAEjC,CAIA,OAFAA,EAAQmB,2BAA6BG,EAAsBA,uBAAC,CAAE,EAAEtB,GAEzD,CACLF,OAAQD,EAAgB0B,IAAMP,OAAOQ,OAAO,CAAA,EAAI1B,GAAUI,EAAOuB,MACjErB,OAAQ,CAAA,EACR,EAtBEF,EAASN,EAAO,aAAa8B,SAAS5B,GAAQ6B,gBAC9CzB,aAAkB0B,QAAO,OAAAA,QAAAC,QACZ3B,GAAM4B,KAAA,SAAAC,GAArB7B,EAAM6B,CAAgB,EAAAH,IAAAA,OAAAA,QAAAC,QAAAF,GAAAA,EAAAG,KAAAH,EAAAG,KAAA7B,GAAAA,IAqB1B,CAAC,MAAA+B,GAAAJ,OAAAA,QAAAK,OAAAD,EACH,CAAA,CAAA"}

package/standard-schema/dist/standard-schema.mjs

@@ -1,2 +1,2 @@
-import{toNestErrors as e,validateFieldsNatively as r}from"@hookform/resolvers";function n(){return n=Object.assign?Object.assign.bind():function(e){for(var r=1;r<arguments.length;r++){var n=arguments[r];for(var t in n)({}).hasOwnProperty.call(n,t)&&(e[t]=n[t])}return e},n.apply(null,arguments)}function t(t,s){return void 0===s&&(s={}),function(a,i,o){try{var u=function(){if(l.issues){var t=function(e,r){for(var t={},s=0;s<e.length;s++){var a,i=e[s],o=null==(a=i.path)?void 0:a.join(".");if(o&&(t[o]||(t[o]={message:i.message,type:""}),r)){var u,l=t[o].types||{};t[o].types=n({},l,((u={})[Object.keys(l).length]=i.message,u))}}return t}(l.issues,!o.shouldUseNativeValidation&&"all"===o.criteriaMode);return{values:{},errors:e(t,o)}}return o.shouldUseNativeValidation&&r({},o),{values:s.raw?Object.assign({},a):l.value,errors:{}}},l=t["~standard"].validate(a),v=function(){if(l instanceof Promise)return Promise.resolve(l).then(function(e){l=e})}();return Promise.resolve(v&&v.then?v.then(u):u())}catch(e){return Promise.reject(e)}}}export{t as standardSchemaResolver};
+import{toNestErrors as e,validateFieldsNatively as r}from"@hookform/resolvers";import{getDotPath as t}from"@standard-schema/utils";function n(){return n=Object.assign?Object.assign.bind():function(e){for(var r=1;r<arguments.length;r++){var t=arguments[r];for(var n in t)({}).hasOwnProperty.call(t,n)&&(e[n]=t[n])}return e},n.apply(null,arguments)}function s(s,a){return void 0===a&&(a={}),function(i,o,u){try{var l=function(){if(c.issues){var s=function(e,r){for(var s={},a=0;a<e.length;a++){var i=e[a],o=t(i);if(o&&(s[o]||(s[o]={message:i.message,type:""}),r)){var u,l=s[o].types||{};s[o].types=n({},l,((u={})[Object.keys(l).length]=i.message,u))}}return s}(c.issues,!u.shouldUseNativeValidation&&"all"===u.criteriaMode);return{values:{},errors:e(s,u)}}return u.shouldUseNativeValidation&&r({},u),{values:a.raw?Object.assign({},i):c.value,errors:{}}},c=s["~standard"].validate(i),f=function(){if(c instanceof Promise)return Promise.resolve(c).then(function(e){c=e})}();return Promise.resolve(f&&f.then?f.then(l):l())}catch(e){return Promise.reject(e)}}}export{s as standardSchemaResolver};
 //# sourceMappingURL=standard-schema.module.js.map

package/standard-schema/dist/standard-schema.modern.mjs

@@ -1,2 +1,2 @@
-import{toNestErrors as e,validateFieldsNatively as s}from"@hookform/resolvers";function t(){return t=Object.assign?Object.assign.bind():function(e){for(var s=1;s<arguments.length;s++){var t=arguments[s];for(var r in t)({}).hasOwnProperty.call(t,r)&&(e[r]=t[r])}return e},t.apply(null,arguments)}function r(r,n={}){return async(a,o,i)=>{let l=r["~standard"].validate(a);if(l instanceof Promise&&(l=await l),l.issues){const s=function(e,s){const r={};for(let a=0;a<e.length;a++){var n;const o=e[a],i=null==(n=o.path)?void 0:n.join(".");if(i&&(r[i]||(r[i]={message:o.message,type:""}),s)){const e=r[i].types||{};r[i].types=t({},e,{[Object.keys(e).length]:o.message})}}return r}(l.issues,!i.shouldUseNativeValidation&&"all"===i.criteriaMode);return{values:{},errors:e(s,i)}}return i.shouldUseNativeValidation&&s({},i),{values:n.raw?Object.assign({},a):l.value,errors:{}}}}export{r as standardSchemaResolver};
+import{toNestErrors as e,validateFieldsNatively as s}from"@hookform/resolvers";import{getDotPath as t}from"@standard-schema/utils";function r(){return r=Object.assign?Object.assign.bind():function(e){for(var s=1;s<arguments.length;s++){var t=arguments[s];for(var r in t)({}).hasOwnProperty.call(t,r)&&(e[r]=t[r])}return e},r.apply(null,arguments)}function a(a,n={}){return async(o,i,l)=>{let u=a["~standard"].validate(o);if(u instanceof Promise&&(u=await u),u.issues){const s=function(e,s){const a={};for(let n=0;n<e.length;n++){const o=e[n],i=t(o);if(i&&(a[i]||(a[i]={message:o.message,type:""}),s)){const e=a[i].types||{};a[i].types=r({},e,{[Object.keys(e).length]:o.message})}}return a}(u.issues,!l.shouldUseNativeValidation&&"all"===l.criteriaMode);return{values:{},errors:e(s,l)}}return l.shouldUseNativeValidation&&s({},l),{values:n.raw?Object.assign({},o):u.value,errors:{}}}}export{a as standardSchemaResolver};
 //# sourceMappingURL=standard-schema.modern.mjs.map

package/standard-schema/dist/standard-schema.modern.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"standard-schema.modern.mjs","sources":["../src/standard-schema.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { StandardSchemaV1 } from '@standard-schema/spec';\nimport { FieldError, FieldValues, Resolver } from 'react-hook-form';\n\nfunction parseIssues(\n  issues: readonly StandardSchemaV1.Issue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n\n  for (let i = 0; i < issues.length; i++) {\n    const error = issues[i];\n    const path = error.path?.join('.');\n\n    if (path) {\n      if (!errors[path]) {\n        errors[path] = { message: error.message, type: '' };\n      }\n\n      if (validateAllFieldCriteria) {\n        const types = errors[path].types || {};\n\n        errors[path].types = {\n          ...types,\n          [Object.keys(types).length]: error.message,\n        };\n      }\n    }\n  }\n\n  return errors;\n}\n\n/**\n * Creates a resolver for react-hook-form that validates data using a Standard Schema.\n *\n * @param {Schema} schema - The Standard Schema to validate against\n * @param {Object} resolverOptions - Options for the resolver\n * @param {boolean} [resolverOptions.raw=false] - Whether to return raw input values instead of parsed values\n * @returns {Resolver} A resolver function compatible with react-hook-form\n *\n * @example\n * ```ts\n * const schema = z.object({\n *   name: z.string().min(2),\n *   age: z.number().min(18)\n * });\n *\n * useForm({\n *   resolver: standardSchemaResolver(schema)\n * });\n * ```\n */\nexport function standardSchemaResolver<\n  TFieldValues extends FieldValues,\n  Schema extends StandardSchemaV1<TFieldValues, any>,\n>(\n  schema: Schema,\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<NonNullable<(typeof schema)['~standard']['types']>['output']> {\n  return async (values: TFieldValues, _, 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 = parseIssues(\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":["standardSchemaResolver","schema","resolverOptions","values","_","options","result","validate","Promise","issues","errors","validateAllFieldCriteria","i","length","_error$path","error","path","join","message","type","types","_extends","Object","keys","parseIssues","shouldUseNativeValidation","criteriaMode","toNestErrors","validateFieldsNatively","raw","assign","value"],"mappings":"uSAqDgB,SAAAA,EAIdC,EACAC,EAEI,CAAA,GAEJ,OAAcC,MAAAA,EAAsBC,EAAGC,KACrC,IAAIC,EAASL,EAAO,aAAaM,SAASJ,GAK1C,GAJIG,aAAkBE,UACpBF,QAAeA,GAGbA,EAAOG,OAAQ,CACjB,MAAMC,EAjEZ,SACED,EACAE,GAEA,MAAMD,EAAqC,CAAE,EAE7C,IAAK,IAAIE,EAAI,EAAGA,EAAIH,EAAOI,OAAQD,IAAK,CAAA,IAAAE,EACtC,MAAMC,EAAQN,EAAOG,GACfI,EAAOF,OAAHA,EAAGC,EAAMC,WAANF,EAAAA,EAAYG,KAAK,KAE9B,GAAID,IACGN,EAAOM,KACVN,EAAOM,GAAQ,CAAEE,QAASH,EAAMG,QAASC,KAAM,KAG7CR,GAA0B,CAC5B,MAAMS,EAAQV,EAAOM,GAAMI,OAAS,CAAA,EAEpCV,EAAOM,GAAMI,MAAKC,EAAA,CAAA,EACbD,EAAK,CACR,CAACE,OAAOC,KAAKH,GAAOP,QAASE,EAAMG,SAEvC,CAEJ,CAEA,OAAOR,CACT,CAsCqBc,CACblB,EAAOG,QACNJ,EAAQoB,2BAAsD,QAAzBpB,EAAQqB,cAGhD,MAAO,CACLvB,OAAQ,CAAA,EACRO,OAAQiB,EAAajB,EAAQL,GAEjC,CAIA,OAFAA,EAAQoB,2BAA6BG,EAAuB,CAAE,EAAEvB,GAEzD,CACLF,OAAQD,EAAgB2B,IAAMP,OAAOQ,OAAO,CAAE,EAAE3B,GAAUG,EAAOyB,MACjErB,OAAQ,CAAA,GAGd"}
+{"version":3,"file":"standard-schema.modern.mjs","sources":["../src/standard-schema.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { StandardSchemaV1 } from '@standard-schema/spec';\nimport { getDotPath } from '@standard-schema/utils';\nimport { FieldError, FieldValues, Resolver } from 'react-hook-form';\n\nfunction parseIssues(\n  issues: readonly StandardSchemaV1.Issue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n\n  for (let i = 0; i < issues.length; i++) {\n    const error = issues[i];\n    const path = getDotPath(error);\n\n    if (path) {\n      if (!errors[path]) {\n        errors[path] = { message: error.message, type: '' };\n      }\n\n      if (validateAllFieldCriteria) {\n        const types = errors[path].types || {};\n\n        errors[path].types = {\n          ...types,\n          [Object.keys(types).length]: error.message,\n        };\n      }\n    }\n  }\n\n  return errors;\n}\n\n/**\n * Creates a resolver for react-hook-form that validates data using a Standard Schema.\n *\n * @param {Schema} schema - The Standard Schema to validate against\n * @param {Object} resolverOptions - Options for the resolver\n * @param {boolean} [resolverOptions.raw=false] - Whether to return raw input values instead of parsed values\n * @returns {Resolver} A resolver function compatible with react-hook-form\n *\n * @example\n * ```ts\n * const schema = z.object({\n *   name: z.string().min(2),\n *   age: z.number().min(18)\n * });\n *\n * useForm({\n *   resolver: standardSchemaResolver(schema)\n * });\n * ```\n */\nexport function standardSchemaResolver<\n  Schema extends StandardSchemaV1<FieldValues>,\n>(\n  schema: Schema,\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<StandardSchemaV1.InferOutput<Schema>> {\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 = parseIssues(\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":["standardSchemaResolver","schema","resolverOptions","async","values","_","options","result","validate","Promise","issues","errors","validateAllFieldCriteria","i","length","error","path","getDotPath","message","type","types","_extends","Object","keys","parseIssues","shouldUseNativeValidation","criteriaMode","toNestErrors","validateFieldsNatively","raw","assign","value"],"mappings":"oWAsDgBA,EAGdC,EACAC,EAEI,CAAA,GAEJ,OAAOC,MAAOC,EAAQC,EAAGC,KACvB,IAAIC,EAASN,EAAO,aAAaO,SAASJ,GAK1C,GAJIG,aAAkBE,UACpBF,QAAeA,GAGbA,EAAOG,OAAQ,CACjB,MAAMC,EAhEZ,SACED,EACAE,GAEA,MAAMD,EAAqC,CAAA,EAE3C,IAAK,IAAIE,EAAI,EAAGA,EAAIH,EAAOI,OAAQD,IAAK,CACtC,MAAME,EAAQL,EAAOG,GACfG,EAAOC,EAAWF,GAExB,GAAIC,IACGL,EAAOK,KACVL,EAAOK,GAAQ,CAAEE,QAASH,EAAMG,QAASC,KAAM,KAG7CP,GAA0B,CAC5B,MAAMQ,EAAQT,EAAOK,GAAMI,OAAS,CAAE,EAEtCT,EAAOK,GAAMI,MAAKC,EACbD,CAAAA,EAAAA,EACH,CAAA,CAACE,OAAOC,KAAKH,GAAON,QAASC,EAAMG,SAEvC,CAEJ,CAEA,OAAOP,CACT,CAqCqBa,CACbjB,EAAOG,QACNJ,EAAQmB,2BAAsD,QAAzBnB,EAAQoB,cAGhD,MAAO,CACLtB,OAAQ,CAAE,EACVO,OAAQgB,EAAahB,EAAQL,GAEjC,CAIA,OAFAA,EAAQmB,2BAA6BG,EAAuB,CAAE,EAAEtB,GAEzD,CACLF,OAAQF,EAAgB2B,IAAMP,OAAOQ,OAAO,CAAA,EAAI1B,GAAUG,EAAOwB,MACjEpB,OAAQ,IAGd"}

package/standard-schema/dist/standard-schema.module.js

@@ -1,2 +1,2 @@
-import{toNestErrors as e,validateFieldsNatively as r}from"@hookform/resolvers";function n(){return n=Object.assign?Object.assign.bind():function(e){for(var r=1;r<arguments.length;r++){var n=arguments[r];for(var t in n)({}).hasOwnProperty.call(n,t)&&(e[t]=n[t])}return e},n.apply(null,arguments)}function t(t,s){return void 0===s&&(s={}),function(a,i,o){try{var u=function(){if(l.issues){var t=function(e,r){for(var t={},s=0;s<e.length;s++){var a,i=e[s],o=null==(a=i.path)?void 0:a.join(".");if(o&&(t[o]||(t[o]={message:i.message,type:""}),r)){var u,l=t[o].types||{};t[o].types=n({},l,((u={})[Object.keys(l).length]=i.message,u))}}return t}(l.issues,!o.shouldUseNativeValidation&&"all"===o.criteriaMode);return{values:{},errors:e(t,o)}}return o.shouldUseNativeValidation&&r({},o),{values:s.raw?Object.assign({},a):l.value,errors:{}}},l=t["~standard"].validate(a),v=function(){if(l instanceof Promise)return Promise.resolve(l).then(function(e){l=e})}();return Promise.resolve(v&&v.then?v.then(u):u())}catch(e){return Promise.reject(e)}}}export{t as standardSchemaResolver};
+import{toNestErrors as e,validateFieldsNatively as r}from"@hookform/resolvers";import{getDotPath as t}from"@standard-schema/utils";function n(){return n=Object.assign?Object.assign.bind():function(e){for(var r=1;r<arguments.length;r++){var t=arguments[r];for(var n in t)({}).hasOwnProperty.call(t,n)&&(e[n]=t[n])}return e},n.apply(null,arguments)}function s(s,a){return void 0===a&&(a={}),function(i,o,u){try{var l=function(){if(c.issues){var s=function(e,r){for(var s={},a=0;a<e.length;a++){var i=e[a],o=t(i);if(o&&(s[o]||(s[o]={message:i.message,type:""}),r)){var u,l=s[o].types||{};s[o].types=n({},l,((u={})[Object.keys(l).length]=i.message,u))}}return s}(c.issues,!u.shouldUseNativeValidation&&"all"===u.criteriaMode);return{values:{},errors:e(s,u)}}return u.shouldUseNativeValidation&&r({},u),{values:a.raw?Object.assign({},i):c.value,errors:{}}},c=s["~standard"].validate(i),f=function(){if(c instanceof Promise)return Promise.resolve(c).then(function(e){c=e})}();return Promise.resolve(f&&f.then?f.then(l):l())}catch(e){return Promise.reject(e)}}}export{s as standardSchemaResolver};
 //# sourceMappingURL=standard-schema.module.js.map

package/standard-schema/dist/standard-schema.module.js.map

@@ -1 +1 @@
-{"version":3,"file":"standard-schema.module.js","sources":["../src/standard-schema.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { StandardSchemaV1 } from '@standard-schema/spec';\nimport { FieldError, FieldValues, Resolver } from 'react-hook-form';\n\nfunction parseIssues(\n  issues: readonly StandardSchemaV1.Issue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n\n  for (let i = 0; i < issues.length; i++) {\n    const error = issues[i];\n    const path = error.path?.join('.');\n\n    if (path) {\n      if (!errors[path]) {\n        errors[path] = { message: error.message, type: '' };\n      }\n\n      if (validateAllFieldCriteria) {\n        const types = errors[path].types || {};\n\n        errors[path].types = {\n          ...types,\n          [Object.keys(types).length]: error.message,\n        };\n      }\n    }\n  }\n\n  return errors;\n}\n\n/**\n * Creates a resolver for react-hook-form that validates data using a Standard Schema.\n *\n * @param {Schema} schema - The Standard Schema to validate against\n * @param {Object} resolverOptions - Options for the resolver\n * @param {boolean} [resolverOptions.raw=false] - Whether to return raw input values instead of parsed values\n * @returns {Resolver} A resolver function compatible with react-hook-form\n *\n * @example\n * ```ts\n * const schema = z.object({\n *   name: z.string().min(2),\n *   age: z.number().min(18)\n * });\n *\n * useForm({\n *   resolver: standardSchemaResolver(schema)\n * });\n * ```\n */\nexport function standardSchemaResolver<\n  TFieldValues extends FieldValues,\n  Schema extends StandardSchemaV1<TFieldValues, any>,\n>(\n  schema: Schema,\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<NonNullable<(typeof schema)['~standard']['types']>['output']> {\n  return async (values: TFieldValues, _, 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 = parseIssues(\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":["standardSchemaResolver","schema","resolverOptions","values","_","options","_temp2","result","issues","errors","validateAllFieldCriteria","i","length","_error$path","error","path","join","message","type","_extends2","types","_extends","Object","keys","parseIssues","shouldUseNativeValidation","criteriaMode","toNestErrors","validateFieldsNatively","raw","assign","value","validate","_temp","Promise","resolve","then","_result","e","reject"],"mappings":"gTAqDgBA,EAIdC,EACAC,GAIA,YAJAA,IAAAA,IAAAA,EAEI,CAAE,GAEN,SAAcC,EAAsBC,EAAGC,GAAW,IAAA,IAAAC,EAAAA,WAMhD,GAAIC,EAAOC,OAAQ,CACjB,IAAMC,EAjEZ,SACED,EACAE,GAIA,IAFA,IAAMD,EAAqC,CAAA,EAElCE,EAAI,EAAGA,EAAIH,EAAOI,OAAQD,IAAK,CAAAE,IAAAA,EAChCC,EAAQN,EAAOG,GACfI,EAAOF,OAAHA,EAAGC,EAAMC,WAANF,EAAAA,EAAYG,KAAK,KAE9B,GAAID,IACGN,EAAOM,KACVN,EAAOM,GAAQ,CAAEE,QAASH,EAAMG,QAASC,KAAM,KAG7CR,GAA0B,CAAA,IAAAS,EACtBC,EAAQX,EAAOM,GAAMK,OAAS,CAAA,EAEpCX,EAAOM,GAAMK,MAAKC,EACbD,CAAAA,EAAAA,IAAKD,EAAA,IACPG,OAAOC,KAAKH,GAAOR,QAASE,EAAMG,QAAOE,GAE9C,CAEJ,CAEA,OAAOV,CACT,CAsCqBe,CACbjB,EAAOC,QACNH,EAAQoB,2BAAsD,QAAzBpB,EAAQqB,cAGhD,MAAO,CACLvB,OAAQ,CAAA,EACRM,OAAQkB,EAAalB,EAAQJ,GAEjC,CAIA,OAFAA,EAAQoB,2BAA6BG,EAAuB,CAAE,EAAEvB,GAEzD,CACLF,OAAQD,EAAgB2B,IAAMP,OAAOQ,OAAO,CAAE,EAAE3B,GAAUI,EAAOwB,MACjEtB,OAAQ,GACR,EAtBEF,EAASN,EAAO,aAAa+B,SAAS7B,GAAQ8B,gBAC9C1B,aAAkB2B,QAAO,OAAAA,QAAAC,QACZ5B,GAAM6B,KAAA,SAAAC,GAArB9B,EAAM8B,CAAgB,EAAAH,IAAAA,OAAAA,QAAAC,QAAAF,GAAAA,EAAAG,KAAAH,EAAAG,KAAA9B,GAAAA,IAqB1B,CAAC,MAAAgC,GAAAJ,OAAAA,QAAAK,OAAAD,EACH,CAAA,CAAA"}
+{"version":3,"file":"standard-schema.module.js","sources":["../src/standard-schema.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { StandardSchemaV1 } from '@standard-schema/spec';\nimport { getDotPath } from '@standard-schema/utils';\nimport { FieldError, FieldValues, Resolver } from 'react-hook-form';\n\nfunction parseIssues(\n  issues: readonly StandardSchemaV1.Issue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n\n  for (let i = 0; i < issues.length; i++) {\n    const error = issues[i];\n    const path = getDotPath(error);\n\n    if (path) {\n      if (!errors[path]) {\n        errors[path] = { message: error.message, type: '' };\n      }\n\n      if (validateAllFieldCriteria) {\n        const types = errors[path].types || {};\n\n        errors[path].types = {\n          ...types,\n          [Object.keys(types).length]: error.message,\n        };\n      }\n    }\n  }\n\n  return errors;\n}\n\n/**\n * Creates a resolver for react-hook-form that validates data using a Standard Schema.\n *\n * @param {Schema} schema - The Standard Schema to validate against\n * @param {Object} resolverOptions - Options for the resolver\n * @param {boolean} [resolverOptions.raw=false] - Whether to return raw input values instead of parsed values\n * @returns {Resolver} A resolver function compatible with react-hook-form\n *\n * @example\n * ```ts\n * const schema = z.object({\n *   name: z.string().min(2),\n *   age: z.number().min(18)\n * });\n *\n * useForm({\n *   resolver: standardSchemaResolver(schema)\n * });\n * ```\n */\nexport function standardSchemaResolver<\n  Schema extends StandardSchemaV1<FieldValues>,\n>(\n  schema: Schema,\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<StandardSchemaV1.InferOutput<Schema>> {\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 = parseIssues(\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":["standardSchemaResolver","schema","resolverOptions","values","_","options","_temp2","result","issues","errors","validateAllFieldCriteria","i","length","error","path","getDotPath","message","type","_extends2","types","_extends","Object","keys","parseIssues","shouldUseNativeValidation","criteriaMode","toNestErrors","validateFieldsNatively","raw","assign","value","validate","_temp","Promise","resolve","then","_result","e","reject"],"mappings":"oWAsDgBA,EAGdC,EACAC,GAIA,gBAJAA,IAAAA,EAEI,aAEUC,EAAQC,EAAGC,GAAW,IAAA,IAAAC,EAAA,WAMlC,GAAIC,EAAOC,OAAQ,CACjB,IAAMC,EAhEZ,SACED,EACAE,GAIA,IAFA,IAAMD,EAAqC,GAElCE,EAAI,EAAGA,EAAIH,EAAOI,OAAQD,IAAK,CACtC,IAAME,EAAQL,EAAOG,GACfG,EAAOC,EAAWF,GAExB,GAAIC,IACGL,EAAOK,KACVL,EAAOK,GAAQ,CAAEE,QAASH,EAAMG,QAASC,KAAM,KAG7CP,GAA0B,CAAA,IAAAQ,EACtBC,EAAQV,EAAOK,GAAMK,OAAS,CAAE,EAEtCV,EAAOK,GAAMK,MAAKC,EACbD,CAAAA,EAAAA,IAAKD,MACPG,OAAOC,KAAKH,GAAOP,QAASC,EAAMG,QAAOE,GAE9C,CAEJ,CAEA,OAAOT,CACT,CAqCqBc,CACbhB,EAAOC,QACNH,EAAQmB,2BAAsD,QAAzBnB,EAAQoB,cAGhD,MAAO,CACLtB,OAAQ,CAAE,EACVM,OAAQiB,EAAajB,EAAQJ,GAEjC,CAIA,OAFAA,EAAQmB,2BAA6BG,EAAuB,CAAE,EAAEtB,GAEzD,CACLF,OAAQD,EAAgB0B,IAAMP,OAAOQ,OAAO,CAAA,EAAI1B,GAAUI,EAAOuB,MACjErB,OAAQ,CAAA,EACR,EAtBEF,EAASN,EAAO,aAAa8B,SAAS5B,GAAQ6B,gBAC9CzB,aAAkB0B,QAAO,OAAAA,QAAAC,QACZ3B,GAAM4B,KAAA,SAAAC,GAArB7B,EAAM6B,CAAgB,EAAAH,IAAAA,OAAAA,QAAAC,QAAAF,GAAAA,EAAAG,KAAAH,EAAAG,KAAA7B,GAAAA,IAqB1B,CAAC,MAAA+B,GAAAJ,OAAAA,QAAAK,OAAAD,EACH,CAAA,CAAA"}

package/standard-schema/dist/standard-schema.umd.js

@@ -1,2 +1,2 @@
-!function(e,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports,require("@hookform/resolvers")):"function"==typeof define&&define.amd?define(["exports","@hookform/resolvers"],r):r((e||self).hookformResolversStandardSchema={},e.hookformResolvers)}(this,function(e,r){function o(){return o=Object.assign?Object.assign.bind():function(e){for(var r=1;r<arguments.length;r++){var o=arguments[r];for(var t in o)({}).hasOwnProperty.call(o,t)&&(e[t]=o[t])}return e},o.apply(null,arguments)}e.standardSchemaResolver=function(e,t){return void 0===t&&(t={}),function(n,s,i){try{var a=function(){if(l.issues){var e=function(e,r){for(var t={},n=0;n<e.length;n++){var s,i=e[n],a=null==(s=i.path)?void 0:s.join(".");if(a&&(t[a]||(t[a]={message:i.message,type:""}),r)){var l,u=t[a].types||{};t[a].types=o({},u,((l={})[Object.keys(u).length]=i.message,l))}}return t}(l.issues,!i.shouldUseNativeValidation&&"all"===i.criteriaMode);return{values:{},errors:r.toNestErrors(e,i)}}return i.shouldUseNativeValidation&&r.validateFieldsNatively({},i),{values:t.raw?Object.assign({},n):l.value,errors:{}}},l=e["~standard"].validate(n),u=function(){if(l instanceof Promise)return Promise.resolve(l).then(function(e){l=e})}();return Promise.resolve(u&&u.then?u.then(a):a())}catch(e){return Promise.reject(e)}}}});
+!function(e,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports,require("@hookform/resolvers"),require("@standard-schema/utils")):"function"==typeof define&&define.amd?define(["exports","@hookform/resolvers","@standard-schema/utils"],r):r((e||self).hookformResolversStandardSchema={},e.hookformResolvers,e.utils)}(this,function(e,r,t){function s(){return s=Object.assign?Object.assign.bind():function(e){for(var r=1;r<arguments.length;r++){var t=arguments[r];for(var s in t)({}).hasOwnProperty.call(t,s)&&(e[s]=t[s])}return e},s.apply(null,arguments)}e.standardSchemaResolver=function(e,o){return void 0===o&&(o={}),function(n,a,i){try{var l=function(){if(u.issues){var e=function(e,r){for(var o={},n=0;n<e.length;n++){var a=e[n],i=t.getDotPath(a);if(i&&(o[i]||(o[i]={message:a.message,type:""}),r)){var l,u=o[i].types||{};o[i].types=s({},u,((l={})[Object.keys(u).length]=a.message,l))}}return o}(u.issues,!i.shouldUseNativeValidation&&"all"===i.criteriaMode);return{values:{},errors:r.toNestErrors(e,i)}}return i.shouldUseNativeValidation&&r.validateFieldsNatively({},i),{values:o.raw?Object.assign({},n):u.value,errors:{}}},u=e["~standard"].validate(n),f=function(){if(u instanceof Promise)return Promise.resolve(u).then(function(e){u=e})}();return Promise.resolve(f&&f.then?f.then(l):l())}catch(e){return Promise.reject(e)}}}});
 //# sourceMappingURL=standard-schema.umd.js.map

package/standard-schema/dist/standard-schema.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"standard-schema.umd.js","sources":["../src/standard-schema.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { StandardSchemaV1 } from '@standard-schema/spec';\nimport { FieldError, FieldValues, Resolver } from 'react-hook-form';\n\nfunction parseIssues(\n  issues: readonly StandardSchemaV1.Issue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n\n  for (let i = 0; i < issues.length; i++) {\n    const error = issues[i];\n    const path = error.path?.join('.');\n\n    if (path) {\n      if (!errors[path]) {\n        errors[path] = { message: error.message, type: '' };\n      }\n\n      if (validateAllFieldCriteria) {\n        const types = errors[path].types || {};\n\n        errors[path].types = {\n          ...types,\n          [Object.keys(types).length]: error.message,\n        };\n      }\n    }\n  }\n\n  return errors;\n}\n\n/**\n * Creates a resolver for react-hook-form that validates data using a Standard Schema.\n *\n * @param {Schema} schema - The Standard Schema to validate against\n * @param {Object} resolverOptions - Options for the resolver\n * @param {boolean} [resolverOptions.raw=false] - Whether to return raw input values instead of parsed values\n * @returns {Resolver} A resolver function compatible with react-hook-form\n *\n * @example\n * ```ts\n * const schema = z.object({\n *   name: z.string().min(2),\n *   age: z.number().min(18)\n * });\n *\n * useForm({\n *   resolver: standardSchemaResolver(schema)\n * });\n * ```\n */\nexport function standardSchemaResolver<\n  TFieldValues extends FieldValues,\n  Schema extends StandardSchemaV1<TFieldValues, any>,\n>(\n  schema: Schema,\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<NonNullable<(typeof schema)['~standard']['types']>['output']> {\n  return async (values: TFieldValues, _, 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 = parseIssues(\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","resolverOptions","values","_","options","_temp2","result","issues","errors","validateAllFieldCriteria","i","length","_error$path","error","path","join","message","type","_extends2","types","_extends","Object","keys","parseIssues","shouldUseNativeValidation","criteriaMode","toNestErrors","validateFieldsNatively","raw","assign","value","validate","_temp","Promise","resolve","then","_result","e","reject"],"mappings":"8jBAyDEA,EACAC,GAIA,YAJAA,IAAAA,IAAAA,EAEI,CAAE,GAEN,SAAcC,EAAsBC,EAAGC,GAAW,IAAA,IAAAC,EAAAA,WAMhD,GAAIC,EAAOC,OAAQ,CACjB,IAAMC,EAjEZ,SACED,EACAE,GAIA,IAFA,IAAMD,EAAqC,CAAA,EAElCE,EAAI,EAAGA,EAAIH,EAAOI,OAAQD,IAAK,CAAAE,IAAAA,EAChCC,EAAQN,EAAOG,GACfI,EAAOF,OAAHA,EAAGC,EAAMC,WAANF,EAAAA,EAAYG,KAAK,KAE9B,GAAID,IACGN,EAAOM,KACVN,EAAOM,GAAQ,CAAEE,QAASH,EAAMG,QAASC,KAAM,KAG7CR,GAA0B,CAAA,IAAAS,EACtBC,EAAQX,EAAOM,GAAMK,OAAS,CAAA,EAEpCX,EAAOM,GAAMK,MAAKC,EACbD,CAAAA,EAAAA,IAAKD,EAAA,IACPG,OAAOC,KAAKH,GAAOR,QAASE,EAAMG,QAAOE,GAE9C,CAEJ,CAEA,OAAOV,CACT,CAsCqBe,CACbjB,EAAOC,QACNH,EAAQoB,2BAAsD,QAAzBpB,EAAQqB,cAGhD,MAAO,CACLvB,OAAQ,CAAA,EACRM,OAAQkB,EAAYA,aAAClB,EAAQJ,GAEjC,CAIA,OAFAA,EAAQoB,2BAA6BG,EAAAA,uBAAuB,CAAE,EAAEvB,GAEzD,CACLF,OAAQD,EAAgB2B,IAAMP,OAAOQ,OAAO,CAAE,EAAE3B,GAAUI,EAAOwB,MACjEtB,OAAQ,GACR,EAtBEF,EAASN,EAAO,aAAa+B,SAAS7B,GAAQ8B,gBAC9C1B,aAAkB2B,QAAO,OAAAA,QAAAC,QACZ5B,GAAM6B,KAAA,SAAAC,GAArB9B,EAAM8B,CAAgB,EAAAH,IAAAA,OAAAA,QAAAC,QAAAF,GAAAA,EAAAG,KAAAH,EAAAG,KAAA9B,GAAAA,IAqB1B,CAAC,MAAAgC,GAAAJ,OAAAA,QAAAK,OAAAD,EACH,CAAA,CAAA"}
+{"version":3,"file":"standard-schema.umd.js","sources":["../src/standard-schema.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { StandardSchemaV1 } from '@standard-schema/spec';\nimport { getDotPath } from '@standard-schema/utils';\nimport { FieldError, FieldValues, Resolver } from 'react-hook-form';\n\nfunction parseIssues(\n  issues: readonly StandardSchemaV1.Issue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n\n  for (let i = 0; i < issues.length; i++) {\n    const error = issues[i];\n    const path = getDotPath(error);\n\n    if (path) {\n      if (!errors[path]) {\n        errors[path] = { message: error.message, type: '' };\n      }\n\n      if (validateAllFieldCriteria) {\n        const types = errors[path].types || {};\n\n        errors[path].types = {\n          ...types,\n          [Object.keys(types).length]: error.message,\n        };\n      }\n    }\n  }\n\n  return errors;\n}\n\n/**\n * Creates a resolver for react-hook-form that validates data using a Standard Schema.\n *\n * @param {Schema} schema - The Standard Schema to validate against\n * @param {Object} resolverOptions - Options for the resolver\n * @param {boolean} [resolverOptions.raw=false] - Whether to return raw input values instead of parsed values\n * @returns {Resolver} A resolver function compatible with react-hook-form\n *\n * @example\n * ```ts\n * const schema = z.object({\n *   name: z.string().min(2),\n *   age: z.number().min(18)\n * });\n *\n * useForm({\n *   resolver: standardSchemaResolver(schema)\n * });\n * ```\n */\nexport function standardSchemaResolver<\n  Schema extends StandardSchemaV1<FieldValues>,\n>(\n  schema: Schema,\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<StandardSchemaV1.InferOutput<Schema>> {\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 = parseIssues(\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","resolverOptions","values","_","options","_temp2","result","issues","errors","validateAllFieldCriteria","i","length","error","path","getDotPath","message","type","_extends2","types","_extends","Object","keys","parseIssues","shouldUseNativeValidation","criteriaMode","toNestErrors","validateFieldsNatively","raw","assign","value","validate","_temp","Promise","resolve","then","_result","e","reject"],"mappings":"moBAyDEA,EACAC,GAIA,gBAJAA,IAAAA,EAEI,aAEUC,EAAQC,EAAGC,GAAW,IAAA,IAAAC,EAAA,WAMlC,GAAIC,EAAOC,OAAQ,CACjB,IAAMC,EAhEZ,SACED,EACAE,GAIA,IAFA,IAAMD,EAAqC,GAElCE,EAAI,EAAGA,EAAIH,EAAOI,OAAQD,IAAK,CACtC,IAAME,EAAQL,EAAOG,GACfG,EAAOC,EAAAA,WAAWF,GAExB,GAAIC,IACGL,EAAOK,KACVL,EAAOK,GAAQ,CAAEE,QAASH,EAAMG,QAASC,KAAM,KAG7CP,GAA0B,CAAA,IAAAQ,EACtBC,EAAQV,EAAOK,GAAMK,OAAS,CAAE,EAEtCV,EAAOK,GAAMK,MAAKC,EACbD,CAAAA,EAAAA,IAAKD,MACPG,OAAOC,KAAKH,GAAOP,QAASC,EAAMG,QAAOE,GAE9C,CAEJ,CAEA,OAAOT,CACT,CAqCqBc,CACbhB,EAAOC,QACNH,EAAQmB,2BAAsD,QAAzBnB,EAAQoB,cAGhD,MAAO,CACLtB,OAAQ,CAAE,EACVM,OAAQiB,EAAAA,aAAajB,EAAQJ,GAEjC,CAIA,OAFAA,EAAQmB,2BAA6BG,EAAsBA,uBAAC,CAAE,EAAEtB,GAEzD,CACLF,OAAQD,EAAgB0B,IAAMP,OAAOQ,OAAO,CAAA,EAAI1B,GAAUI,EAAOuB,MACjErB,OAAQ,CAAA,EACR,EAtBEF,EAASN,EAAO,aAAa8B,SAAS5B,GAAQ6B,gBAC9CzB,aAAkB0B,QAAO,OAAAA,QAAAC,QACZ3B,GAAM4B,KAAA,SAAAC,GAArB7B,EAAM6B,CAAgB,EAAAH,IAAAA,OAAAA,QAAAC,QAAAF,GAAAA,EAAAG,KAAAH,EAAAG,KAAA7B,GAAAA,IAqB1B,CAAC,MAAA+B,GAAAJ,OAAAA,QAAAK,OAAAD,EACH,CAAA,CAAA"}

package/standard-schema/package.json

@@ -13,6 +13,7 @@
   "peerDependencies": {
     "react-hook-form": "^7.0.0",
     "@standard-schema/spec": "^1.0.0",
+    "@standard-schema/utils": "^0.3.0",
     "@hookform/resolvers": "^2.0.0"
   }
 }

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

@@ -1,3 +1,4 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
 import { Field, InternalFieldName } from 'react-hook-form';
 import { z } from 'zod';
 
@@ -86,3 +87,25 @@ export const fields: Record<InternalFieldName, Field['_f']> = {
     name: 'birthday',
   },
 };
+
+export const customSchema: StandardSchemaV1<
+  StandardSchemaV1.InferInput<typeof schema>,
+  StandardSchemaV1.InferOutput<typeof schema>
+> = {
+  '~standard': {
+    version: 1,
+    vendor: 'custom',
+    validate: () => ({
+      issues: [
+        {
+          path: [{ key: 'username' }],
+          message: 'Custom error',
+        },
+        {
+          path: [{ key: 'like' }, { key: 0 }, { key: 'id' }],
+          message: 'Custom error',
+        },
+      ],
+    }),
+  },
+};

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

@@ -1,5 +1,29 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
+exports[`standardSchemaResolver > should correctly handle path segments that are objects 1`] = `
+{
+  "errors": {
+    "like": [
+      {
+        "id": {
+          "message": "Custom error",
+          "ref": undefined,
+          "type": "",
+        },
+      },
+    ],
+    "username": {
+      "message": "Custom error",
+      "ref": {
+        "name": "username",
+      },
+      "type": "",
+    },
+  },
+  "values": {},
+}
+`;
+
 exports[`standardSchemaResolver > should return a single error from standardSchemaResolver when validation fails 1`] = `
 {
   "errors": {

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

@@ -1,5 +1,11 @@
 import { standardSchemaResolver } from '..';
-import { fields, invalidData, schema, validData } from './__fixtures__/data';
+import {
+  customSchema,
+  fields,
+  invalidData,
+  schema,
+  validData,
+} from './__fixtures__/data';
 
 const shouldUseNativeValidation = false;
 
@@ -53,4 +59,16 @@ describe('standardSchemaResolver', () => {
     expect(validateSpy).toHaveBeenCalledTimes(1);
     expect(result).toMatchSnapshot();
   });
+  it('should correctly handle path segments that are objects', async () => {
+    const result = await standardSchemaResolver(customSchema)(
+      validData,
+      undefined,
+      {
+        fields,
+        shouldUseNativeValidation,
+      },
+    );
+
+    expect(result).toMatchSnapshot();
+  });
 });

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

@@ -1,5 +1,6 @@
 import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';
 import { StandardSchemaV1 } from '@standard-schema/spec';
+import { getDotPath } from '@standard-schema/utils';
 import { FieldError, FieldValues, Resolver } from 'react-hook-form';
 
 function parseIssues(
@@ -10,7 +11,7 @@ function parseIssues(
 
   for (let i = 0; i < issues.length; i++) {
     const error = issues[i];
-    const path = error.path?.join('.');
+    const path = getDotPath(error);
 
     if (path) {
       if (!errors[path]) {
@@ -52,15 +53,14 @@ function parseIssues(
  * ```
  */
 export function standardSchemaResolver<
-  TFieldValues extends FieldValues,
-  Schema extends StandardSchemaV1<TFieldValues, any>,
+  Schema extends StandardSchemaV1<FieldValues>,
 >(
   schema: Schema,
   resolverOptions: {
     raw?: boolean;
   } = {},
-): Resolver<NonNullable<(typeof schema)['~standard']['types']>['output']> {
-  return async (values: TFieldValues, _, options) => {
+): Resolver<StandardSchemaV1.InferOutput<Schema>> {
+  return async (values, _, options) => {
     let result = schema['~standard'].validate(values);
     if (result instanceof Promise) {
       result = await result;