@hookform/resolvers 5.5.4 → 5.5.6

package/README.md

@@ -643,6 +643,26 @@ const App = () => {
 };
 ```
 
+#### Custom/third-party types (e.g. ElysiaJS's `t.Files()`)
+
+`typeboxResolver` validates using `@sinclair/typebox`'s own `Value.Errors`/`Value.Check`, so any schema
+`Kind` not built into TypeBox (custom types, or ones defined by a third-party library such as ElysiaJS)
+must be registered with TypeBox's own `TypeRegistry` (and `FormatRegistry` for string formats) before
+it's used — this is a TypeBox-level extension point, not something `@hookform/resolvers` wraps or needs
+to expose separately:
+
+```typescript jsx
+import { TypeRegistry } from '@sinclair/typebox';
+
+if (!TypeRegistry.Has('Files')) {
+  TypeRegistry.Set('Files', (schema, value) => Array.isArray(value));
+}
+```
+
+Make sure this registration runs against the same `@sinclair/typebox` module instance the schema was
+built with — if a library vendors its own copy of `@sinclair/typebox` instead of relying on the shared
+peer dependency, its registrations won't be visible here, and you'll see a runtime `"Unknown type"` error.
+
 ### [ArkType](https://github.com/arktypeio/arktype)
 
 TypeScript's 1:1 validator, optimized from editor to runtime
@@ -709,6 +729,24 @@ const App = () => {
 };
 ```
 
+> ⚠️ If your schema uses `v.transform(...)` (or `v.pipe(..., v.transform(...))`) on a field, that field's
+> parsed _output_ type can differ from what the user actually types (its _input_ type) — e.g. a string
+> input transformed into a number. Passing a single generic to `useForm<T>` pins both the submitted values
+> and the `handleSubmit` payload to that one type, which conflicts with `valibotResolver`, since it infers
+> input and output separately. Either omit the generic and let it infer from `resolver`, or specify all
+> three explicitly:
+>
+> ```tsx
+> const schema = v.object({
+>   name: v.string(),
+>   number: v.pipe(v.string(), v.transform(Number)),
+> });
+>
+> useForm<v.InferInput<typeof schema>, unknown, v.InferOutput<typeof schema>>({
+>   resolver: valibotResolver(schema),
+> });
+> ```
+
 ### [TypeSchema](https://typeschema.com)
 
 Universal adapter for schema validation, compatible with [any validation library](https://typeschema.com/#coverage)

package/dist/resolvers.js

@@ -1,2 +1,2 @@
-var e=require("react-hook-form"),r=function(r,t,i){if(r&&"reportValidity"in r){var a=e.get(i,t);r.setCustomValidity(a&&a.message||""),r.reportValidity()}},t=function(e,t){var i=function(i){var a=t.fields[i];a&&a.ref&&"reportValidity"in a.ref?r(a.ref,i,e):a&&a.refs&&a.refs.forEach(function(t){return r(t,i,e)})};for(var a in t.fields)i(a)},i=function(e,r){var t=a(r).replace(/[.*+?^${}()|\\]/g,"\\$&");return e.some(function(e){return a(e).match("^"+t+"\\.\\d+")})};function a(e){return e.replace(/[\[\]]/g,"")}exports.toNestErrors=function(r,a){a.shouldUseNativeValidation&&t(r,a);var n={};for(var o in r){var s=e.get(a.fields,o),f=Object.assign(r[o]||{},{ref:s&&s.ref});if(i(a.names||Object.keys(r),o)){var c=Object.assign({},e.get(n,o));e.set(c,"root",f),e.set(n,o,c)}else e.set(n,o,f)}return n},exports.validateFieldsNatively=t;
+var e=require("react-hook-form"),r=function(r,t,i){if(r&&"reportValidity"in r){var a=e.get(i,t);r.setCustomValidity(a&&a.message||""),r.reportValidity()}},t=function(e,t){var i=function(i){var a=t.fields[i];a&&a.ref&&"reportValidity"in a.ref?r(a.ref,i,e):a&&a.refs&&a.refs.forEach(function(t){return r(t,i,e)})};for(var a in t.fields)i(a)},i=function(e,r){var t=a(r).replace(/[.*+?^${}()|\\]/g,"\\$&");return e.some(function(e){return a(e).match("^"+t+"\\.\\d+")})};function a(e){return e.replace(/[\[\]]/g,"")}exports.toNestErrors=function(r,a){a.shouldUseNativeValidation&&t(r,a);var n={};for(var s in r){var o=e.get(a.fields,s),f=Object.assign(r[s]||{},{ref:o&&o.refs?o.refs[0]:o&&o.ref});if(i(a.names||Object.keys(r),s)){var c=Object.assign({},e.get(n,s));e.set(c,"root",f),e.set(n,s,c)}else e.set(n,s,f)}return n},exports.validateFieldsNatively=t;
 //# sourceMappingURL=resolvers.js.map

package/dist/resolvers.js.map

@@ -1 +1 @@
-{"version":3,"file":"resolvers.js","sources":["../src/validateFieldsNatively.ts","../src/toNestErrors.ts"],"sourcesContent":["import {\n  FieldError,\n  FieldErrors,\n  FieldValues,\n  Ref,\n  ResolverOptions,\n  get,\n} from 'react-hook-form';\n\nconst setCustomValidity = (\n  ref: Ref,\n  fieldPath: string,\n  errors: FieldErrors,\n) => {\n  if (ref && 'reportValidity' in ref) {\n    const error = get(errors, fieldPath) as FieldError | undefined;\n    ref.setCustomValidity((error && error.message) || '');\n\n    ref.reportValidity();\n  }\n};\n\n// Native validation (web only)\nexport const validateFieldsNatively = <TFieldValues extends FieldValues>(\n  errors: FieldErrors,\n  options: ResolverOptions<TFieldValues>,\n): void => {\n  for (const fieldPath in options.fields) {\n    const field = options.fields[fieldPath];\n    if (field && field.ref && 'reportValidity' in field.ref) {\n      setCustomValidity(field.ref, fieldPath, errors);\n    } else if (field && field.refs) {\n      field.refs.forEach((ref: HTMLInputElement) =>\n        setCustomValidity(ref, fieldPath, errors),\n      );\n    }\n  }\n};\n","import {\n  Field,\n  FieldErrors,\n  FieldValues,\n  InternalFieldName,\n  ResolverOptions,\n  get,\n  set,\n} from 'react-hook-form';\nimport { validateFieldsNatively } from './validateFieldsNatively';\n\nexport const toNestErrors = <TFieldValues extends FieldValues>(\n  errors: FieldErrors,\n  options: ResolverOptions<TFieldValues>,\n): FieldErrors<TFieldValues> => {\n  options.shouldUseNativeValidation && validateFieldsNatively(errors, options);\n\n  const fieldErrors = {} as FieldErrors<TFieldValues>;\n  for (const path in errors) {\n    const field = get(options.fields, path) as Field['_f'] | undefined;\n    const error = Object.assign(errors[path] || {}, {\n      ref: field && field.ref,\n    });\n\n    if (isNameInFieldArray(options.names || Object.keys(errors), path)) {\n      const fieldArrayErrors = Object.assign({}, get(fieldErrors, path));\n\n      set(fieldArrayErrors, 'root', error);\n      set(fieldErrors, path, fieldArrayErrors);\n    } else {\n      set(fieldErrors, path, error);\n    }\n  }\n\n  return fieldErrors;\n};\n\nconst isNameInFieldArray = (\n  names: InternalFieldName[],\n  name: InternalFieldName,\n) => {\n  const path = escapeForRegex(name);\n  return names.some((n) => escapeBrackets(n).match(`^${path}\\\\.\\\\d+`));\n};\n\n// Removes brackets to match react-hook-form's `set` method behavior.\nfunction escapeBrackets(input: string): string {\n  return input.replace(/[\\[\\]]/g, '');\n}\n\n// Removes brackets then escapes regex metacharacters so a field name can be\n// safely embedded in a regex pattern without causing a SyntaxError.\nfunction escapeForRegex(input: string): string {\n  return escapeBrackets(input).replace(/[.*+?^${}()|\\\\]/g, '\\\\$&');\n}\n"],"names":["setCustomValidity","ref","fieldPath","errors","error","get","message","reportValidity","validateFieldsNatively","options","_loop","field","fields","refs","forEach","isNameInFieldArray","names","name","path","escapeBrackets","replace","some","n","match","input","shouldUseNativeValidation","fieldErrors","Object","assign","keys","fieldArrayErrors","set"],"mappings":"iCASMA,EAAoB,SACxBC,EACAC,EACAC,GAEA,GAAIF,GAAO,mBAAoBA,EAAK,CAClC,IAAMG,EAAQC,EAAAA,IAAIF,EAAQD,GAC1BD,EAAID,kBAAmBI,GAASA,EAAME,SAAY,IAElDL,EAAIM,gBACN,CACF,EAGaC,EAAyB,SACpCL,EACAM,GACQC,IAAAA,WAAAR,GAEN,IAAMS,EAAQF,EAAQG,OAAOV,GACzBS,GAASA,EAAMV,KAAO,mBAAoBU,EAAMV,IAClDD,EAAkBW,EAAMV,IAAKC,EAAWC,GAC/BQ,GAASA,EAAME,MACxBF,EAAME,KAAKC,QAAQ,SAACb,UAClBD,EAAkBC,EAAKC,EAAWC,EAAO,EAG/C,EATA,IAAK,IAAMD,KAAaO,EAAQG,OAAMF,EAAAR,EAUxC,ECAMa,EAAqB,SACzBC,EACAC,GAEA,IAAMC,EAYCC,EAZqBF,GAYCG,QAAQ,mBAAoB,QAXzD,OAAOJ,EAAMK,KAAK,SAACC,GAAC,OAAKH,EAAeG,GAAGC,MAAK,IAAKL,EAAI,UAAU,EACrE,EAGA,SAASC,EAAeK,GACtB,OAAOA,EAAMJ,QAAQ,UAAW,GAClC,sBArC4B,SAC1BjB,EACAM,GAEAA,EAAQgB,2BAA6BjB,EAAuBL,EAAQM,GAEpE,IAAMiB,EAAc,CAA+B,EACnD,IAAK,IAAMR,KAAQf,EAAQ,CACzB,IAAMQ,EAAQN,EAAGA,IAACI,EAAQG,OAAQM,GAC5Bd,EAAQuB,OAAOC,OAAOzB,EAAOe,IAAS,CAAE,EAAE,CAC9CjB,IAAKU,GAASA,EAAMV,MAGtB,GAAIc,EAAmBN,EAAQO,OAASW,OAAOE,KAAK1B,GAASe,GAAO,CAClE,IAAMY,EAAmBH,OAAOC,OAAO,CAAA,EAAIvB,EAAGA,IAACqB,EAAaR,IAE5Da,EAAGA,IAACD,EAAkB,OAAQ1B,GAC9B2B,EAAGA,IAACL,EAAaR,EAAMY,EACzB,MACEC,EAAGA,IAACL,EAAaR,EAAMd,EAE3B,CAEA,OAAOsB,CACT"}
+{"version":3,"file":"resolvers.js","sources":["../src/validateFieldsNatively.ts","../src/toNestErrors.ts"],"sourcesContent":["import {\n  FieldError,\n  FieldErrors,\n  FieldValues,\n  Ref,\n  ResolverOptions,\n  get,\n} from 'react-hook-form';\n\nconst setCustomValidity = (\n  ref: Ref,\n  fieldPath: string,\n  errors: FieldErrors,\n) => {\n  if (ref && 'reportValidity' in ref) {\n    const error = get(errors, fieldPath) as FieldError | undefined;\n    ref.setCustomValidity((error && error.message) || '');\n\n    ref.reportValidity();\n  }\n};\n\n// Native validation (web only)\nexport const validateFieldsNatively = <TFieldValues extends FieldValues>(\n  errors: FieldErrors,\n  options: ResolverOptions<TFieldValues>,\n): void => {\n  for (const fieldPath in options.fields) {\n    const field = options.fields[fieldPath];\n    if (field && field.ref && 'reportValidity' in field.ref) {\n      setCustomValidity(field.ref, fieldPath, errors);\n    } else if (field && field.refs) {\n      field.refs.forEach((ref: HTMLInputElement) =>\n        setCustomValidity(ref, fieldPath, errors),\n      );\n    }\n  }\n};\n","import {\n  Field,\n  FieldErrors,\n  FieldValues,\n  InternalFieldName,\n  ResolverOptions,\n  get,\n  set,\n} from 'react-hook-form';\nimport { validateFieldsNatively } from './validateFieldsNatively';\n\nexport const toNestErrors = <TFieldValues extends FieldValues>(\n  errors: FieldErrors,\n  options: ResolverOptions<TFieldValues>,\n): FieldErrors<TFieldValues> => {\n  options.shouldUseNativeValidation && validateFieldsNatively(errors, options);\n\n  const fieldErrors = {} as FieldErrors<TFieldValues>;\n  for (const path in errors) {\n    const field = get(options.fields, path) as Field['_f'] | undefined;\n    // Radio/checkbox fields keep a placeholder `ref` (`{ name, type }`) and\n    // store the actual DOM elements in `refs`, matching react-hook-form's\n    // own `validateField` behavior for built-in validation.\n    const error = Object.assign(errors[path] || {}, {\n      ref: field && field.refs ? field.refs[0] : field && field.ref,\n    });\n\n    if (isNameInFieldArray(options.names || Object.keys(errors), path)) {\n      const fieldArrayErrors = Object.assign({}, get(fieldErrors, path));\n\n      set(fieldArrayErrors, 'root', error);\n      set(fieldErrors, path, fieldArrayErrors);\n    } else {\n      set(fieldErrors, path, error);\n    }\n  }\n\n  return fieldErrors;\n};\n\nconst isNameInFieldArray = (\n  names: InternalFieldName[],\n  name: InternalFieldName,\n) => {\n  const path = escapeForRegex(name);\n  return names.some((n) => escapeBrackets(n).match(`^${path}\\\\.\\\\d+`));\n};\n\n// Removes brackets to match react-hook-form's `set` method behavior.\nfunction escapeBrackets(input: string): string {\n  return input.replace(/[\\[\\]]/g, '');\n}\n\n// Removes brackets then escapes regex metacharacters so a field name can be\n// safely embedded in a regex pattern without causing a SyntaxError.\nfunction escapeForRegex(input: string): string {\n  return escapeBrackets(input).replace(/[.*+?^${}()|\\\\]/g, '\\\\$&');\n}\n"],"names":["setCustomValidity","ref","fieldPath","errors","error","get","message","reportValidity","validateFieldsNatively","options","_loop","field","fields","refs","forEach","isNameInFieldArray","names","name","path","escapeBrackets","replace","some","n","match","input","shouldUseNativeValidation","fieldErrors","Object","assign","keys","fieldArrayErrors","set"],"mappings":"iCASMA,EAAoB,SACxBC,EACAC,EACAC,GAEA,GAAIF,GAAO,mBAAoBA,EAAK,CAClC,IAAMG,EAAQC,EAAAA,IAAIF,EAAQD,GAC1BD,EAAID,kBAAmBI,GAASA,EAAME,SAAY,IAElDL,EAAIM,gBACN,CACF,EAGaC,EAAyB,SACpCL,EACAM,GACQC,IAAAA,WAAAR,GAEN,IAAMS,EAAQF,EAAQG,OAAOV,GACzBS,GAASA,EAAMV,KAAO,mBAAoBU,EAAMV,IAClDD,EAAkBW,EAAMV,IAAKC,EAAWC,GAC/BQ,GAASA,EAAME,MACxBF,EAAME,KAAKC,QAAQ,SAACb,UAClBD,EAAkBC,EAAKC,EAAWC,EAAO,EAG/C,EATA,IAAK,IAAMD,KAAaO,EAAQG,OAAMF,EAAAR,EAUxC,ECGMa,EAAqB,SACzBC,EACAC,GAEA,IAAMC,EAYCC,EAZqBF,GAYCG,QAAQ,mBAAoB,QAXzD,OAAOJ,EAAMK,KAAK,SAACC,GAAC,OAAKH,EAAeG,GAAGC,MAAUL,IAAAA,EAAa,UAAC,EACrE,EAGA,SAASC,EAAeK,GACtB,OAAOA,EAAMJ,QAAQ,UAAW,GAClC,sBAxC4B,SAC1BjB,EACAM,GAEAA,EAAQgB,2BAA6BjB,EAAuBL,EAAQM,GAEpE,IAAMiB,EAAc,CAA+B,EACnD,IAAK,IAAMR,KAAQf,EAAQ,CACzB,IAAMQ,EAAQN,EAAAA,IAAII,EAAQG,OAAQM,GAI5Bd,EAAQuB,OAAOC,OAAOzB,EAAOe,IAAS,CAAA,EAAI,CAC9CjB,IAAKU,GAASA,EAAME,KAAOF,EAAME,KAAK,GAAKF,GAASA,EAAMV,MAG5D,GAAIc,EAAmBN,EAAQO,OAASW,OAAOE,KAAK1B,GAASe,GAAO,CAClE,IAAMY,EAAmBH,OAAOC,OAAO,CAAE,EAAEvB,EAAGA,IAACqB,EAAaR,IAE5Da,MAAID,EAAkB,OAAQ1B,GAC9B2B,EAAGA,IAACL,EAAaR,EAAMY,EACzB,MACEC,EAAAA,IAAIL,EAAaR,EAAMd,EAE3B,CAEA,OAAOsB,CACT"}

package/dist/resolvers.mjs

@@ -1,2 +1,2 @@
-import{get as e,set as t}from"react-hook-form";const r=(t,r,o)=>{if(t&&"reportValidity"in t){const s=e(o,r);t.setCustomValidity(s&&s.message||""),t.reportValidity()}},o=(e,t)=>{for(const o in t.fields){const s=t.fields[o];s&&s.ref&&"reportValidity"in s.ref?r(s.ref,o,e):s&&s.refs&&s.refs.forEach(t=>r(t,o,e))}},s=(r,s)=>{s.shouldUseNativeValidation&&o(r,s);const n={};for(const o in r){const c=e(s.fields,o),f=Object.assign(r[o]||{},{ref:c&&c.ref});if(i(s.names||Object.keys(r),o)){const r=Object.assign({},e(n,o));t(r,"root",f),t(n,o,r)}else t(n,o,f)}return n},i=(e,t)=>{const r=n(t).replace(/[.*+?^${}()|\\]/g,"\\$&");return e.some(e=>n(e).match(`^${r}\\.\\d+`))};function n(e){return e.replace(/[\[\]]/g,"")}export{s as toNestErrors,o as validateFieldsNatively};
+import{get as e,set as r}from"react-hook-form";const t=(r,t,s)=>{if(r&&"reportValidity"in r){const o=e(s,t);r.setCustomValidity(o&&o.message||""),r.reportValidity()}},s=(e,r)=>{for(const s in r.fields){const o=r.fields[s];o&&o.ref&&"reportValidity"in o.ref?t(o.ref,s,e):o&&o.refs&&o.refs.forEach(r=>t(r,s,e))}},o=(t,o)=>{o.shouldUseNativeValidation&&s(t,o);const n={};for(const s in t){const f=e(o.fields,s),c=Object.assign(t[s]||{},{ref:f&&f.refs?f.refs[0]:f&&f.ref});if(i(o.names||Object.keys(t),s)){const t=Object.assign({},e(n,s));r(t,"root",c),r(n,s,t)}else r(n,s,c)}return n},i=(e,r)=>{const t=n(r).replace(/[.*+?^${}()|\\]/g,"\\$&");return e.some(e=>n(e).match(`^${t}\\.\\d+`))};function n(e){return e.replace(/[\[\]]/g,"")}export{o as toNestErrors,s as validateFieldsNatively};
 //# sourceMappingURL=resolvers.mjs.map

package/dist/resolvers.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"resolvers.mjs","sources":["../src/validateFieldsNatively.ts","../src/toNestErrors.ts"],"sourcesContent":["import {\n  FieldError,\n  FieldErrors,\n  FieldValues,\n  Ref,\n  ResolverOptions,\n  get,\n} from 'react-hook-form';\n\nconst setCustomValidity = (\n  ref: Ref,\n  fieldPath: string,\n  errors: FieldErrors,\n) => {\n  if (ref && 'reportValidity' in ref) {\n    const error = get(errors, fieldPath) as FieldError | undefined;\n    ref.setCustomValidity((error && error.message) || '');\n\n    ref.reportValidity();\n  }\n};\n\n// Native validation (web only)\nexport const validateFieldsNatively = <TFieldValues extends FieldValues>(\n  errors: FieldErrors,\n  options: ResolverOptions<TFieldValues>,\n): void => {\n  for (const fieldPath in options.fields) {\n    const field = options.fields[fieldPath];\n    if (field && field.ref && 'reportValidity' in field.ref) {\n      setCustomValidity(field.ref, fieldPath, errors);\n    } else if (field && field.refs) {\n      field.refs.forEach((ref: HTMLInputElement) =>\n        setCustomValidity(ref, fieldPath, errors),\n      );\n    }\n  }\n};\n","import {\n  Field,\n  FieldErrors,\n  FieldValues,\n  InternalFieldName,\n  ResolverOptions,\n  get,\n  set,\n} from 'react-hook-form';\nimport { validateFieldsNatively } from './validateFieldsNatively';\n\nexport const toNestErrors = <TFieldValues extends FieldValues>(\n  errors: FieldErrors,\n  options: ResolverOptions<TFieldValues>,\n): FieldErrors<TFieldValues> => {\n  options.shouldUseNativeValidation && validateFieldsNatively(errors, options);\n\n  const fieldErrors = {} as FieldErrors<TFieldValues>;\n  for (const path in errors) {\n    const field = get(options.fields, path) as Field['_f'] | undefined;\n    const error = Object.assign(errors[path] || {}, {\n      ref: field && field.ref,\n    });\n\n    if (isNameInFieldArray(options.names || Object.keys(errors), path)) {\n      const fieldArrayErrors = Object.assign({}, get(fieldErrors, path));\n\n      set(fieldArrayErrors, 'root', error);\n      set(fieldErrors, path, fieldArrayErrors);\n    } else {\n      set(fieldErrors, path, error);\n    }\n  }\n\n  return fieldErrors;\n};\n\nconst isNameInFieldArray = (\n  names: InternalFieldName[],\n  name: InternalFieldName,\n) => {\n  const path = escapeForRegex(name);\n  return names.some((n) => escapeBrackets(n).match(`^${path}\\\\.\\\\d+`));\n};\n\n// Removes brackets to match react-hook-form's `set` method behavior.\nfunction escapeBrackets(input: string): string {\n  return input.replace(/[\\[\\]]/g, '');\n}\n\n// Removes brackets then escapes regex metacharacters so a field name can be\n// safely embedded in a regex pattern without causing a SyntaxError.\nfunction escapeForRegex(input: string): string {\n  return escapeBrackets(input).replace(/[.*+?^${}()|\\\\]/g, '\\\\$&');\n}\n"],"names":["setCustomValidity","ref","fieldPath","errors","error","get","message","reportValidity","validateFieldsNatively","options","fields","field","refs","forEach","toNestErrors","shouldUseNativeValidation","fieldErrors","path","Object","assign","isNameInFieldArray","names","keys","fieldArrayErrors","set","name","escapeBrackets","replace","some","n","match","input"],"mappings":"+CASA,MAAMA,EAAoBA,CACxBC,EACAC,EACAC,KAEA,GAAIF,GAAO,mBAAoBA,EAAK,CAClC,MAAMG,EAAQC,EAAIF,EAAQD,GAC1BD,EAAID,kBAAmBI,GAASA,EAAME,SAAY,IAElDL,EAAIM,gBACN,GAIWC,EAAyBA,CACpCL,EACAM,KAEA,IAAK,MAAMP,KAAaO,EAAQC,OAAQ,CACtC,MAAMC,EAAQF,EAAQC,OAAOR,GACzBS,GAASA,EAAMV,KAAO,mBAAoBU,EAAMV,IAClDD,EAAkBW,EAAMV,IAAKC,EAAWC,GAC/BQ,GAASA,EAAMC,MACxBD,EAAMC,KAAKC,QAASZ,GAClBD,EAAkBC,EAAKC,EAAWC,GAGxC,GCzBWW,EAAeA,CAC1BX,EACAM,KAEAA,EAAQM,2BAA6BP,EAAuBL,EAAQM,GAEpE,MAAMO,EAAc,CAAA,EACpB,IAAK,MAAMC,KAAQd,EAAQ,CACzB,MAAMQ,EAAQN,EAAII,EAAQC,OAAQO,GAC5Bb,EAAQc,OAAOC,OAAOhB,EAAOc,IAAS,CAAA,EAAI,CAC9ChB,IAAKU,GAASA,EAAMV,MAGtB,GAAImB,EAAmBX,EAAQY,OAASH,OAAOI,KAAKnB,GAASc,GAAO,CAClE,MAAMM,EAAmBL,OAAOC,OAAO,CAAA,EAAId,EAAIW,EAAaC,IAE5DO,EAAID,EAAkB,OAAQnB,GAC9BoB,EAAIR,EAAaC,EAAMM,EACzB,MACEC,EAAIR,EAAaC,EAAMb,EAE3B,CAEA,OAAOY,CAAW,EAGdI,EAAqBA,CACzBC,EACAI,KAEA,MAAMR,EAYCS,EAZqBD,GAYCE,QAAQ,mBAAoB,QAXzD,OAAON,EAAMO,KAAMC,GAAMH,EAAeG,GAAGC,MAAM,IAAIb,YAAe,EAItE,SAASS,EAAeK,GACtB,OAAOA,EAAMJ,QAAQ,UAAW,GAClC"}
+{"version":3,"file":"resolvers.mjs","sources":["../src/validateFieldsNatively.ts","../src/toNestErrors.ts"],"sourcesContent":["import {\n  FieldError,\n  FieldErrors,\n  FieldValues,\n  Ref,\n  ResolverOptions,\n  get,\n} from 'react-hook-form';\n\nconst setCustomValidity = (\n  ref: Ref,\n  fieldPath: string,\n  errors: FieldErrors,\n) => {\n  if (ref && 'reportValidity' in ref) {\n    const error = get(errors, fieldPath) as FieldError | undefined;\n    ref.setCustomValidity((error && error.message) || '');\n\n    ref.reportValidity();\n  }\n};\n\n// Native validation (web only)\nexport const validateFieldsNatively = <TFieldValues extends FieldValues>(\n  errors: FieldErrors,\n  options: ResolverOptions<TFieldValues>,\n): void => {\n  for (const fieldPath in options.fields) {\n    const field = options.fields[fieldPath];\n    if (field && field.ref && 'reportValidity' in field.ref) {\n      setCustomValidity(field.ref, fieldPath, errors);\n    } else if (field && field.refs) {\n      field.refs.forEach((ref: HTMLInputElement) =>\n        setCustomValidity(ref, fieldPath, errors),\n      );\n    }\n  }\n};\n","import {\n  Field,\n  FieldErrors,\n  FieldValues,\n  InternalFieldName,\n  ResolverOptions,\n  get,\n  set,\n} from 'react-hook-form';\nimport { validateFieldsNatively } from './validateFieldsNatively';\n\nexport const toNestErrors = <TFieldValues extends FieldValues>(\n  errors: FieldErrors,\n  options: ResolverOptions<TFieldValues>,\n): FieldErrors<TFieldValues> => {\n  options.shouldUseNativeValidation && validateFieldsNatively(errors, options);\n\n  const fieldErrors = {} as FieldErrors<TFieldValues>;\n  for (const path in errors) {\n    const field = get(options.fields, path) as Field['_f'] | undefined;\n    // Radio/checkbox fields keep a placeholder `ref` (`{ name, type }`) and\n    // store the actual DOM elements in `refs`, matching react-hook-form's\n    // own `validateField` behavior for built-in validation.\n    const error = Object.assign(errors[path] || {}, {\n      ref: field && field.refs ? field.refs[0] : field && field.ref,\n    });\n\n    if (isNameInFieldArray(options.names || Object.keys(errors), path)) {\n      const fieldArrayErrors = Object.assign({}, get(fieldErrors, path));\n\n      set(fieldArrayErrors, 'root', error);\n      set(fieldErrors, path, fieldArrayErrors);\n    } else {\n      set(fieldErrors, path, error);\n    }\n  }\n\n  return fieldErrors;\n};\n\nconst isNameInFieldArray = (\n  names: InternalFieldName[],\n  name: InternalFieldName,\n) => {\n  const path = escapeForRegex(name);\n  return names.some((n) => escapeBrackets(n).match(`^${path}\\\\.\\\\d+`));\n};\n\n// Removes brackets to match react-hook-form's `set` method behavior.\nfunction escapeBrackets(input: string): string {\n  return input.replace(/[\\[\\]]/g, '');\n}\n\n// Removes brackets then escapes regex metacharacters so a field name can be\n// safely embedded in a regex pattern without causing a SyntaxError.\nfunction escapeForRegex(input: string): string {\n  return escapeBrackets(input).replace(/[.*+?^${}()|\\\\]/g, '\\\\$&');\n}\n"],"names":["setCustomValidity","ref","fieldPath","errors","error","get","message","reportValidity","validateFieldsNatively","options","fields","field","refs","forEach","toNestErrors","shouldUseNativeValidation","fieldErrors","path","Object","assign","isNameInFieldArray","names","keys","fieldArrayErrors","set","name","escapeBrackets","replace","some","n","match","input"],"mappings":"+CASA,MAAMA,EAAoBA,CACxBC,EACAC,EACAC,KAEA,GAAIF,GAAO,mBAAoBA,EAAK,CAClC,MAAMG,EAAQC,EAAIF,EAAQD,GAC1BD,EAAID,kBAAmBI,GAASA,EAAME,SAAY,IAElDL,EAAIM,gBACN,GAIWC,EAAyBA,CACpCL,EACAM,KAEA,IAAK,MAAMP,KAAaO,EAAQC,OAAQ,CACtC,MAAMC,EAAQF,EAAQC,OAAOR,GACzBS,GAASA,EAAMV,KAAO,mBAAoBU,EAAMV,IAClDD,EAAkBW,EAAMV,IAAKC,EAAWC,GAC/BQ,GAASA,EAAMC,MACxBD,EAAMC,KAAKC,QAASZ,GAClBD,EAAkBC,EAAKC,EAAWC,GAGxC,GCzBWW,EAAeA,CAC1BX,EACAM,KAEAA,EAAQM,2BAA6BP,EAAuBL,EAAQM,GAEpE,MAAMO,EAAc,CAAA,EACpB,IAAK,MAAMC,KAAQd,EAAQ,CACzB,MAAMQ,EAAQN,EAAII,EAAQC,OAAQO,GAI5Bb,EAAQc,OAAOC,OAAOhB,EAAOc,IAAS,CAAA,EAAI,CAC9ChB,IAAKU,GAASA,EAAMC,KAAOD,EAAMC,KAAK,GAAKD,GAASA,EAAMV,MAG5D,GAAImB,EAAmBX,EAAQY,OAASH,OAAOI,KAAKnB,GAASc,GAAO,CAClE,MAAMM,EAAmBL,OAAOC,OAAO,CAAA,EAAId,EAAIW,EAAaC,IAE5DO,EAAID,EAAkB,OAAQnB,GAC9BoB,EAAIR,EAAaC,EAAMM,EACzB,MACEC,EAAIR,EAAaC,EAAMb,EAE3B,CAEA,OAAOY,CAAW,EAGdI,EAAqBA,CACzBC,EACAI,KAEA,MAAMR,EAYCS,EAZqBD,GAYCE,QAAQ,mBAAoB,QAXzD,OAAON,EAAMO,KAAMC,GAAMH,EAAeG,GAAGC,MAAM,IAAIb,YAAe,EAItE,SAASS,EAAeK,GACtB,OAAOA,EAAMJ,QAAQ,UAAW,GAClC"}

package/dist/resolvers.module.js

@@ -1,2 +1,2 @@
-import{get as r,set as e}from"react-hook-form";var t=function(e,t,i){if(e&&"reportValidity"in e){var n=r(i,t);e.setCustomValidity(n&&n.message||""),e.reportValidity()}},i=function(r,e){var i=function(i){var n=e.fields[i];n&&n.ref&&"reportValidity"in n.ref?t(n.ref,i,r):n&&n.refs&&n.refs.forEach(function(e){return t(e,i,r)})};for(var n in e.fields)i(n)},n=function(t,n){n.shouldUseNativeValidation&&i(t,n);var o={};for(var f in t){var s=r(n.fields,f),c=Object.assign(t[f]||{},{ref:s&&s.ref});if(a(n.names||Object.keys(t),f)){var u=Object.assign({},r(o,f));e(u,"root",c),e(o,f,u)}else e(o,f,c)}return o},a=function(r,e){var t=o(e).replace(/[.*+?^${}()|\\]/g,"\\$&");return r.some(function(r){return o(r).match("^"+t+"\\.\\d+")})};function o(r){return r.replace(/[\[\]]/g,"")}export{n as toNestErrors,i as validateFieldsNatively};
+import{get as r,set as e}from"react-hook-form";var t=function(e,t,i){if(e&&"reportValidity"in e){var n=r(i,t);e.setCustomValidity(n&&n.message||""),e.reportValidity()}},i=function(r,e){var i=function(i){var n=e.fields[i];n&&n.ref&&"reportValidity"in n.ref?t(n.ref,i,r):n&&n.refs&&n.refs.forEach(function(e){return t(e,i,r)})};for(var n in e.fields)i(n)},n=function(t,n){n.shouldUseNativeValidation&&i(t,n);var a={};for(var o in t){var s=r(n.fields,o),c=Object.assign(t[o]||{},{ref:s&&s.refs?s.refs[0]:s&&s.ref});if(f(n.names||Object.keys(t),o)){var u=Object.assign({},r(a,o));e(u,"root",c),e(a,o,u)}else e(a,o,c)}return a},f=function(r,e){var t=a(e).replace(/[.*+?^${}()|\\]/g,"\\$&");return r.some(function(r){return a(r).match("^"+t+"\\.\\d+")})};function a(r){return r.replace(/[\[\]]/g,"")}export{n as toNestErrors,i as validateFieldsNatively};
 //# sourceMappingURL=resolvers.module.js.map

package/dist/resolvers.module.js.map

@@ -1 +1 @@
-{"version":3,"file":"resolvers.module.js","sources":["../src/validateFieldsNatively.ts","../src/toNestErrors.ts"],"sourcesContent":["import {\n  FieldError,\n  FieldErrors,\n  FieldValues,\n  Ref,\n  ResolverOptions,\n  get,\n} from 'react-hook-form';\n\nconst setCustomValidity = (\n  ref: Ref,\n  fieldPath: string,\n  errors: FieldErrors,\n) => {\n  if (ref && 'reportValidity' in ref) {\n    const error = get(errors, fieldPath) as FieldError | undefined;\n    ref.setCustomValidity((error && error.message) || '');\n\n    ref.reportValidity();\n  }\n};\n\n// Native validation (web only)\nexport const validateFieldsNatively = <TFieldValues extends FieldValues>(\n  errors: FieldErrors,\n  options: ResolverOptions<TFieldValues>,\n): void => {\n  for (const fieldPath in options.fields) {\n    const field = options.fields[fieldPath];\n    if (field && field.ref && 'reportValidity' in field.ref) {\n      setCustomValidity(field.ref, fieldPath, errors);\n    } else if (field && field.refs) {\n      field.refs.forEach((ref: HTMLInputElement) =>\n        setCustomValidity(ref, fieldPath, errors),\n      );\n    }\n  }\n};\n","import {\n  Field,\n  FieldErrors,\n  FieldValues,\n  InternalFieldName,\n  ResolverOptions,\n  get,\n  set,\n} from 'react-hook-form';\nimport { validateFieldsNatively } from './validateFieldsNatively';\n\nexport const toNestErrors = <TFieldValues extends FieldValues>(\n  errors: FieldErrors,\n  options: ResolverOptions<TFieldValues>,\n): FieldErrors<TFieldValues> => {\n  options.shouldUseNativeValidation && validateFieldsNatively(errors, options);\n\n  const fieldErrors = {} as FieldErrors<TFieldValues>;\n  for (const path in errors) {\n    const field = get(options.fields, path) as Field['_f'] | undefined;\n    const error = Object.assign(errors[path] || {}, {\n      ref: field && field.ref,\n    });\n\n    if (isNameInFieldArray(options.names || Object.keys(errors), path)) {\n      const fieldArrayErrors = Object.assign({}, get(fieldErrors, path));\n\n      set(fieldArrayErrors, 'root', error);\n      set(fieldErrors, path, fieldArrayErrors);\n    } else {\n      set(fieldErrors, path, error);\n    }\n  }\n\n  return fieldErrors;\n};\n\nconst isNameInFieldArray = (\n  names: InternalFieldName[],\n  name: InternalFieldName,\n) => {\n  const path = escapeForRegex(name);\n  return names.some((n) => escapeBrackets(n).match(`^${path}\\\\.\\\\d+`));\n};\n\n// Removes brackets to match react-hook-form's `set` method behavior.\nfunction escapeBrackets(input: string): string {\n  return input.replace(/[\\[\\]]/g, '');\n}\n\n// Removes brackets then escapes regex metacharacters so a field name can be\n// safely embedded in a regex pattern without causing a SyntaxError.\nfunction escapeForRegex(input: string): string {\n  return escapeBrackets(input).replace(/[.*+?^${}()|\\\\]/g, '\\\\$&');\n}\n"],"names":["setCustomValidity","ref","fieldPath","errors","error","get","message","reportValidity","validateFieldsNatively","options","_loop","field","fields","refs","forEach","toNestErrors","shouldUseNativeValidation","fieldErrors","path","Object","assign","isNameInFieldArray","names","keys","fieldArrayErrors","set","name","escapeBrackets","replace","some","n","match","input"],"mappings":"+CASA,IAAMA,EAAoB,SACxBC,EACAC,EACAC,GAEA,GAAIF,GAAO,mBAAoBA,EAAK,CAClC,IAAMG,EAAQC,EAAIF,EAAQD,GAC1BD,EAAID,kBAAmBI,GAASA,EAAME,SAAY,IAElDL,EAAIM,gBACN,CACF,EAGaC,EAAyB,SACpCL,EACAM,GACQC,IAAAA,WAAAR,GAEN,IAAMS,EAAQF,EAAQG,OAAOV,GACzBS,GAASA,EAAMV,KAAO,mBAAoBU,EAAMV,IAClDD,EAAkBW,EAAMV,IAAKC,EAAWC,GAC/BQ,GAASA,EAAME,MACxBF,EAAME,KAAKC,QAAQ,SAACb,UAClBD,EAAkBC,EAAKC,EAAWC,EAAO,EAG/C,EATA,IAAK,IAAMD,KAAaO,EAAQG,OAAMF,EAAAR,EAUxC,EC1Baa,EAAe,SAC1BZ,EACAM,GAEAA,EAAQO,2BAA6BR,EAAuBL,EAAQM,GAEpE,IAAMQ,EAAc,CAA+B,EACnD,IAAK,IAAMC,KAAQf,EAAQ,CACzB,IAAMQ,EAAQN,EAAII,EAAQG,OAAQM,GAC5Bd,EAAQe,OAAOC,OAAOjB,EAAOe,IAAS,CAAE,EAAE,CAC9CjB,IAAKU,GAASA,EAAMV,MAGtB,GAAIoB,EAAmBZ,EAAQa,OAASH,OAAOI,KAAKpB,GAASe,GAAO,CAClE,IAAMM,EAAmBL,OAAOC,OAAO,CAAA,EAAIf,EAAIY,EAAaC,IAE5DO,EAAID,EAAkB,OAAQpB,GAC9BqB,EAAIR,EAAaC,EAAMM,EACzB,MACEC,EAAIR,EAAaC,EAAMd,EAE3B,CAEA,OAAOa,CACT,EAEMI,EAAqB,SACzBC,EACAI,GAEA,IAAMR,EAYCS,EAZqBD,GAYCE,QAAQ,mBAAoB,QAXzD,OAAON,EAAMO,KAAK,SAACC,GAAC,OAAKH,EAAeG,GAAGC,MAAK,IAAKb,EAAI,UAAU,EACrE,EAGA,SAASS,EAAeK,GACtB,OAAOA,EAAMJ,QAAQ,UAAW,GAClC"}
+{"version":3,"file":"resolvers.module.js","sources":["../src/validateFieldsNatively.ts","../src/toNestErrors.ts"],"sourcesContent":["import {\n  FieldError,\n  FieldErrors,\n  FieldValues,\n  Ref,\n  ResolverOptions,\n  get,\n} from 'react-hook-form';\n\nconst setCustomValidity = (\n  ref: Ref,\n  fieldPath: string,\n  errors: FieldErrors,\n) => {\n  if (ref && 'reportValidity' in ref) {\n    const error = get(errors, fieldPath) as FieldError | undefined;\n    ref.setCustomValidity((error && error.message) || '');\n\n    ref.reportValidity();\n  }\n};\n\n// Native validation (web only)\nexport const validateFieldsNatively = <TFieldValues extends FieldValues>(\n  errors: FieldErrors,\n  options: ResolverOptions<TFieldValues>,\n): void => {\n  for (const fieldPath in options.fields) {\n    const field = options.fields[fieldPath];\n    if (field && field.ref && 'reportValidity' in field.ref) {\n      setCustomValidity(field.ref, fieldPath, errors);\n    } else if (field && field.refs) {\n      field.refs.forEach((ref: HTMLInputElement) =>\n        setCustomValidity(ref, fieldPath, errors),\n      );\n    }\n  }\n};\n","import {\n  Field,\n  FieldErrors,\n  FieldValues,\n  InternalFieldName,\n  ResolverOptions,\n  get,\n  set,\n} from 'react-hook-form';\nimport { validateFieldsNatively } from './validateFieldsNatively';\n\nexport const toNestErrors = <TFieldValues extends FieldValues>(\n  errors: FieldErrors,\n  options: ResolverOptions<TFieldValues>,\n): FieldErrors<TFieldValues> => {\n  options.shouldUseNativeValidation && validateFieldsNatively(errors, options);\n\n  const fieldErrors = {} as FieldErrors<TFieldValues>;\n  for (const path in errors) {\n    const field = get(options.fields, path) as Field['_f'] | undefined;\n    // Radio/checkbox fields keep a placeholder `ref` (`{ name, type }`) and\n    // store the actual DOM elements in `refs`, matching react-hook-form's\n    // own `validateField` behavior for built-in validation.\n    const error = Object.assign(errors[path] || {}, {\n      ref: field && field.refs ? field.refs[0] : field && field.ref,\n    });\n\n    if (isNameInFieldArray(options.names || Object.keys(errors), path)) {\n      const fieldArrayErrors = Object.assign({}, get(fieldErrors, path));\n\n      set(fieldArrayErrors, 'root', error);\n      set(fieldErrors, path, fieldArrayErrors);\n    } else {\n      set(fieldErrors, path, error);\n    }\n  }\n\n  return fieldErrors;\n};\n\nconst isNameInFieldArray = (\n  names: InternalFieldName[],\n  name: InternalFieldName,\n) => {\n  const path = escapeForRegex(name);\n  return names.some((n) => escapeBrackets(n).match(`^${path}\\\\.\\\\d+`));\n};\n\n// Removes brackets to match react-hook-form's `set` method behavior.\nfunction escapeBrackets(input: string): string {\n  return input.replace(/[\\[\\]]/g, '');\n}\n\n// Removes brackets then escapes regex metacharacters so a field name can be\n// safely embedded in a regex pattern without causing a SyntaxError.\nfunction escapeForRegex(input: string): string {\n  return escapeBrackets(input).replace(/[.*+?^${}()|\\\\]/g, '\\\\$&');\n}\n"],"names":["setCustomValidity","ref","fieldPath","errors","error","get","message","reportValidity","validateFieldsNatively","options","_loop","field","fields","refs","forEach","toNestErrors","shouldUseNativeValidation","fieldErrors","path","Object","assign","isNameInFieldArray","names","keys","fieldArrayErrors","set","name","escapeBrackets","replace","some","n","match","input"],"mappings":"+CASA,IAAMA,EAAoB,SACxBC,EACAC,EACAC,GAEA,GAAIF,GAAO,mBAAoBA,EAAK,CAClC,IAAMG,EAAQC,EAAIF,EAAQD,GAC1BD,EAAID,kBAAmBI,GAASA,EAAME,SAAY,IAElDL,EAAIM,gBACN,CACF,EAGaC,EAAyB,SACpCL,EACAM,GACQC,IAAAA,WAAAR,GAEN,IAAMS,EAAQF,EAAQG,OAAOV,GACzBS,GAASA,EAAMV,KAAO,mBAAoBU,EAAMV,IAClDD,EAAkBW,EAAMV,IAAKC,EAAWC,GAC/BQ,GAASA,EAAME,MACxBF,EAAME,KAAKC,QAAQ,SAACb,UAClBD,EAAkBC,EAAKC,EAAWC,EAAO,EAG/C,EATA,IAAK,IAAMD,KAAaO,EAAQG,OAAMF,EAAAR,EAUxC,EC1Baa,EAAe,SAC1BZ,EACAM,GAEAA,EAAQO,2BAA6BR,EAAuBL,EAAQM,GAEpE,IAAMQ,EAAc,CAA+B,EACnD,IAAK,IAAMC,KAAQf,EAAQ,CACzB,IAAMQ,EAAQN,EAAII,EAAQG,OAAQM,GAI5Bd,EAAQe,OAAOC,OAAOjB,EAAOe,IAAS,CAAA,EAAI,CAC9CjB,IAAKU,GAASA,EAAME,KAAOF,EAAME,KAAK,GAAKF,GAASA,EAAMV,MAG5D,GAAIoB,EAAmBZ,EAAQa,OAASH,OAAOI,KAAKpB,GAASe,GAAO,CAClE,IAAMM,EAAmBL,OAAOC,OAAO,CAAE,EAAEf,EAAIY,EAAaC,IAE5DO,EAAID,EAAkB,OAAQpB,GAC9BqB,EAAIR,EAAaC,EAAMM,EACzB,MACEC,EAAIR,EAAaC,EAAMd,EAE3B,CAEA,OAAOa,CACT,EAEMI,EAAqB,SACzBC,EACAI,GAEA,IAAMR,EAYCS,EAZqBD,GAYCE,QAAQ,mBAAoB,QAXzD,OAAON,EAAMO,KAAK,SAACC,GAAC,OAAKH,EAAeG,GAAGC,MAAUb,IAAAA,EAAa,UAAC,EACrE,EAGA,SAASS,EAAeK,GACtB,OAAOA,EAAMJ,QAAQ,UAAW,GAClC"}

package/dist/resolvers.umd.js

@@ -1,2 +1,2 @@
-!function(e,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports,require("react-hook-form")):"function"==typeof define&&define.amd?define(["exports","react-hook-form"],r):r((e||self).hookformResolvers={},e.ReactHookForm)}(this,function(e,r){var t=function(e,t,o){if(e&&"reportValidity"in e){var i=r.get(o,t);e.setCustomValidity(i&&i.message||""),e.reportValidity()}},o=function(e,r){var o=function(o){var i=r.fields[o];i&&i.ref&&"reportValidity"in i.ref?t(i.ref,o,e):i&&i.refs&&i.refs.forEach(function(r){return t(r,o,e)})};for(var i in r.fields)o(i)},i=function(e,r){var t=n(r).replace(/[.*+?^${}()|\\]/g,"\\$&");return e.some(function(e){return n(e).match("^"+t+"\\.\\d+")})};function n(e){return e.replace(/[\[\]]/g,"")}e.toNestErrors=function(e,t){t.shouldUseNativeValidation&&o(e,t);var n={};for(var f in e){var a=r.get(t.fields,f),s=Object.assign(e[f]||{},{ref:a&&a.ref});if(i(t.names||Object.keys(e),f)){var c=Object.assign({},r.get(n,f));r.set(c,"root",s),r.set(n,f,c)}else r.set(n,f,s)}return n},e.validateFieldsNatively=o});
+!function(e,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports,require("react-hook-form")):"function"==typeof define&&define.amd?define(["exports","react-hook-form"],r):r((e||self).hookformResolvers={},e.ReactHookForm)}(this,function(e,r){var t=function(e,t,o){if(e&&"reportValidity"in e){var i=r.get(o,t);e.setCustomValidity(i&&i.message||""),e.reportValidity()}},o=function(e,r){var o=function(o){var i=r.fields[o];i&&i.ref&&"reportValidity"in i.ref?t(i.ref,o,e):i&&i.refs&&i.refs.forEach(function(r){return t(r,o,e)})};for(var i in r.fields)o(i)},i=function(e,r){var t=n(r).replace(/[.*+?^${}()|\\]/g,"\\$&");return e.some(function(e){return n(e).match("^"+t+"\\.\\d+")})};function n(e){return e.replace(/[\[\]]/g,"")}e.toNestErrors=function(e,t){t.shouldUseNativeValidation&&o(e,t);var n={};for(var f in e){var s=r.get(t.fields,f),a=Object.assign(e[f]||{},{ref:s&&s.refs?s.refs[0]:s&&s.ref});if(i(t.names||Object.keys(e),f)){var c=Object.assign({},r.get(n,f));r.set(c,"root",a),r.set(n,f,c)}else r.set(n,f,a)}return n},e.validateFieldsNatively=o});
 //# sourceMappingURL=resolvers.umd.js.map

package/dist/resolvers.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"resolvers.umd.js","sources":["../src/validateFieldsNatively.ts","../src/toNestErrors.ts"],"sourcesContent":["import {\n  FieldError,\n  FieldErrors,\n  FieldValues,\n  Ref,\n  ResolverOptions,\n  get,\n} from 'react-hook-form';\n\nconst setCustomValidity = (\n  ref: Ref,\n  fieldPath: string,\n  errors: FieldErrors,\n) => {\n  if (ref && 'reportValidity' in ref) {\n    const error = get(errors, fieldPath) as FieldError | undefined;\n    ref.setCustomValidity((error && error.message) || '');\n\n    ref.reportValidity();\n  }\n};\n\n// Native validation (web only)\nexport const validateFieldsNatively = <TFieldValues extends FieldValues>(\n  errors: FieldErrors,\n  options: ResolverOptions<TFieldValues>,\n): void => {\n  for (const fieldPath in options.fields) {\n    const field = options.fields[fieldPath];\n    if (field && field.ref && 'reportValidity' in field.ref) {\n      setCustomValidity(field.ref, fieldPath, errors);\n    } else if (field && field.refs) {\n      field.refs.forEach((ref: HTMLInputElement) =>\n        setCustomValidity(ref, fieldPath, errors),\n      );\n    }\n  }\n};\n","import {\n  Field,\n  FieldErrors,\n  FieldValues,\n  InternalFieldName,\n  ResolverOptions,\n  get,\n  set,\n} from 'react-hook-form';\nimport { validateFieldsNatively } from './validateFieldsNatively';\n\nexport const toNestErrors = <TFieldValues extends FieldValues>(\n  errors: FieldErrors,\n  options: ResolverOptions<TFieldValues>,\n): FieldErrors<TFieldValues> => {\n  options.shouldUseNativeValidation && validateFieldsNatively(errors, options);\n\n  const fieldErrors = {} as FieldErrors<TFieldValues>;\n  for (const path in errors) {\n    const field = get(options.fields, path) as Field['_f'] | undefined;\n    const error = Object.assign(errors[path] || {}, {\n      ref: field && field.ref,\n    });\n\n    if (isNameInFieldArray(options.names || Object.keys(errors), path)) {\n      const fieldArrayErrors = Object.assign({}, get(fieldErrors, path));\n\n      set(fieldArrayErrors, 'root', error);\n      set(fieldErrors, path, fieldArrayErrors);\n    } else {\n      set(fieldErrors, path, error);\n    }\n  }\n\n  return fieldErrors;\n};\n\nconst isNameInFieldArray = (\n  names: InternalFieldName[],\n  name: InternalFieldName,\n) => {\n  const path = escapeForRegex(name);\n  return names.some((n) => escapeBrackets(n).match(`^${path}\\\\.\\\\d+`));\n};\n\n// Removes brackets to match react-hook-form's `set` method behavior.\nfunction escapeBrackets(input: string): string {\n  return input.replace(/[\\[\\]]/g, '');\n}\n\n// Removes brackets then escapes regex metacharacters so a field name can be\n// safely embedded in a regex pattern without causing a SyntaxError.\nfunction escapeForRegex(input: string): string {\n  return escapeBrackets(input).replace(/[.*+?^${}()|\\\\]/g, '\\\\$&');\n}\n"],"names":["setCustomValidity","ref","fieldPath","errors","error","get","message","reportValidity","validateFieldsNatively","options","_loop","field","fields","refs","forEach","isNameInFieldArray","names","name","path","escapeBrackets","replace","some","n","match","input","shouldUseNativeValidation","fieldErrors","Object","assign","keys","fieldArrayErrors","set"],"mappings":"0SASA,IAAMA,EAAoB,SACxBC,EACAC,EACAC,GAEA,GAAIF,GAAO,mBAAoBA,EAAK,CAClC,IAAMG,EAAQC,EAAAA,IAAIF,EAAQD,GAC1BD,EAAID,kBAAmBI,GAASA,EAAME,SAAY,IAElDL,EAAIM,gBACN,CACF,EAGaC,EAAyB,SACpCL,EACAM,GACQC,IAAAA,WAAAR,GAEN,IAAMS,EAAQF,EAAQG,OAAOV,GACzBS,GAASA,EAAMV,KAAO,mBAAoBU,EAAMV,IAClDD,EAAkBW,EAAMV,IAAKC,EAAWC,GAC/BQ,GAASA,EAAME,MACxBF,EAAME,KAAKC,QAAQ,SAACb,UAClBD,EAAkBC,EAAKC,EAAWC,EAAO,EAG/C,EATA,IAAK,IAAMD,KAAaO,EAAQG,OAAMF,EAAAR,EAUxC,ECAMa,EAAqB,SACzBC,EACAC,GAEA,IAAMC,EAYCC,EAZqBF,GAYCG,QAAQ,mBAAoB,QAXzD,OAAOJ,EAAMK,KAAK,SAACC,GAAC,OAAKH,EAAeG,GAAGC,MAAK,IAAKL,EAAI,UAAU,EACrE,EAGA,SAASC,EAAeK,GACtB,OAAOA,EAAMJ,QAAQ,UAAW,GAClC,gBArC4B,SAC1BjB,EACAM,GAEAA,EAAQgB,2BAA6BjB,EAAuBL,EAAQM,GAEpE,IAAMiB,EAAc,CAA+B,EACnD,IAAK,IAAMR,KAAQf,EAAQ,CACzB,IAAMQ,EAAQN,EAAGA,IAACI,EAAQG,OAAQM,GAC5Bd,EAAQuB,OAAOC,OAAOzB,EAAOe,IAAS,CAAE,EAAE,CAC9CjB,IAAKU,GAASA,EAAMV,MAGtB,GAAIc,EAAmBN,EAAQO,OAASW,OAAOE,KAAK1B,GAASe,GAAO,CAClE,IAAMY,EAAmBH,OAAOC,OAAO,CAAA,EAAIvB,EAAGA,IAACqB,EAAaR,IAE5Da,EAAGA,IAACD,EAAkB,OAAQ1B,GAC9B2B,EAAGA,IAACL,EAAaR,EAAMY,EACzB,MACEC,EAAGA,IAACL,EAAaR,EAAMd,EAE3B,CAEA,OAAOsB,CACT"}
+{"version":3,"file":"resolvers.umd.js","sources":["../src/validateFieldsNatively.ts","../src/toNestErrors.ts"],"sourcesContent":["import {\n  FieldError,\n  FieldErrors,\n  FieldValues,\n  Ref,\n  ResolverOptions,\n  get,\n} from 'react-hook-form';\n\nconst setCustomValidity = (\n  ref: Ref,\n  fieldPath: string,\n  errors: FieldErrors,\n) => {\n  if (ref && 'reportValidity' in ref) {\n    const error = get(errors, fieldPath) as FieldError | undefined;\n    ref.setCustomValidity((error && error.message) || '');\n\n    ref.reportValidity();\n  }\n};\n\n// Native validation (web only)\nexport const validateFieldsNatively = <TFieldValues extends FieldValues>(\n  errors: FieldErrors,\n  options: ResolverOptions<TFieldValues>,\n): void => {\n  for (const fieldPath in options.fields) {\n    const field = options.fields[fieldPath];\n    if (field && field.ref && 'reportValidity' in field.ref) {\n      setCustomValidity(field.ref, fieldPath, errors);\n    } else if (field && field.refs) {\n      field.refs.forEach((ref: HTMLInputElement) =>\n        setCustomValidity(ref, fieldPath, errors),\n      );\n    }\n  }\n};\n","import {\n  Field,\n  FieldErrors,\n  FieldValues,\n  InternalFieldName,\n  ResolverOptions,\n  get,\n  set,\n} from 'react-hook-form';\nimport { validateFieldsNatively } from './validateFieldsNatively';\n\nexport const toNestErrors = <TFieldValues extends FieldValues>(\n  errors: FieldErrors,\n  options: ResolverOptions<TFieldValues>,\n): FieldErrors<TFieldValues> => {\n  options.shouldUseNativeValidation && validateFieldsNatively(errors, options);\n\n  const fieldErrors = {} as FieldErrors<TFieldValues>;\n  for (const path in errors) {\n    const field = get(options.fields, path) as Field['_f'] | undefined;\n    // Radio/checkbox fields keep a placeholder `ref` (`{ name, type }`) and\n    // store the actual DOM elements in `refs`, matching react-hook-form's\n    // own `validateField` behavior for built-in validation.\n    const error = Object.assign(errors[path] || {}, {\n      ref: field && field.refs ? field.refs[0] : field && field.ref,\n    });\n\n    if (isNameInFieldArray(options.names || Object.keys(errors), path)) {\n      const fieldArrayErrors = Object.assign({}, get(fieldErrors, path));\n\n      set(fieldArrayErrors, 'root', error);\n      set(fieldErrors, path, fieldArrayErrors);\n    } else {\n      set(fieldErrors, path, error);\n    }\n  }\n\n  return fieldErrors;\n};\n\nconst isNameInFieldArray = (\n  names: InternalFieldName[],\n  name: InternalFieldName,\n) => {\n  const path = escapeForRegex(name);\n  return names.some((n) => escapeBrackets(n).match(`^${path}\\\\.\\\\d+`));\n};\n\n// Removes brackets to match react-hook-form's `set` method behavior.\nfunction escapeBrackets(input: string): string {\n  return input.replace(/[\\[\\]]/g, '');\n}\n\n// Removes brackets then escapes regex metacharacters so a field name can be\n// safely embedded in a regex pattern without causing a SyntaxError.\nfunction escapeForRegex(input: string): string {\n  return escapeBrackets(input).replace(/[.*+?^${}()|\\\\]/g, '\\\\$&');\n}\n"],"names":["setCustomValidity","ref","fieldPath","errors","error","get","message","reportValidity","validateFieldsNatively","options","_loop","field","fields","refs","forEach","isNameInFieldArray","names","name","path","escapeBrackets","replace","some","n","match","input","shouldUseNativeValidation","fieldErrors","Object","assign","keys","fieldArrayErrors","set"],"mappings":"0SASA,IAAMA,EAAoB,SACxBC,EACAC,EACAC,GAEA,GAAIF,GAAO,mBAAoBA,EAAK,CAClC,IAAMG,EAAQC,EAAAA,IAAIF,EAAQD,GAC1BD,EAAID,kBAAmBI,GAASA,EAAME,SAAY,IAElDL,EAAIM,gBACN,CACF,EAGaC,EAAyB,SACpCL,EACAM,GACQC,IAAAA,WAAAR,GAEN,IAAMS,EAAQF,EAAQG,OAAOV,GACzBS,GAASA,EAAMV,KAAO,mBAAoBU,EAAMV,IAClDD,EAAkBW,EAAMV,IAAKC,EAAWC,GAC/BQ,GAASA,EAAME,MACxBF,EAAME,KAAKC,QAAQ,SAACb,UAClBD,EAAkBC,EAAKC,EAAWC,EAAO,EAG/C,EATA,IAAK,IAAMD,KAAaO,EAAQG,OAAMF,EAAAR,EAUxC,ECGMa,EAAqB,SACzBC,EACAC,GAEA,IAAMC,EAYCC,EAZqBF,GAYCG,QAAQ,mBAAoB,QAXzD,OAAOJ,EAAMK,KAAK,SAACC,GAAC,OAAKH,EAAeG,GAAGC,MAAUL,IAAAA,EAAa,UAAC,EACrE,EAGA,SAASC,EAAeK,GACtB,OAAOA,EAAMJ,QAAQ,UAAW,GAClC,gBAxC4B,SAC1BjB,EACAM,GAEAA,EAAQgB,2BAA6BjB,EAAuBL,EAAQM,GAEpE,IAAMiB,EAAc,CAA+B,EACnD,IAAK,IAAMR,KAAQf,EAAQ,CACzB,IAAMQ,EAAQN,EAAAA,IAAII,EAAQG,OAAQM,GAI5Bd,EAAQuB,OAAOC,OAAOzB,EAAOe,IAAS,CAAA,EAAI,CAC9CjB,IAAKU,GAASA,EAAME,KAAOF,EAAME,KAAK,GAAKF,GAASA,EAAMV,MAG5D,GAAIc,EAAmBN,EAAQO,OAASW,OAAOE,KAAK1B,GAASe,GAAO,CAClE,IAAMY,EAAmBH,OAAOC,OAAO,CAAE,EAAEvB,EAAGA,IAACqB,EAAaR,IAE5Da,MAAID,EAAkB,OAAQ1B,GAC9B2B,EAAGA,IAACL,EAAaR,EAAMY,EACzB,MACEC,EAAAA,IAAIL,EAAaR,EAAMd,EAE3B,CAEA,OAAOsB,CACT"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hookform/resolvers",
   "amdName": "hookformResolvers",
-  "version": "5.5.4",
+  "version": "5.5.6",
   "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",

package/typebox/dist/typebox.d.ts

@@ -16,5 +16,10 @@ import { Resolver } from 'react-hook-form';
  * useForm({
  *   resolver: typeboxResolver(schema)
  * });
+ *
+ * // Schemas using a custom/third-party `Kind` (e.g. ElysiaJS's `t.Files()`) must have
+ * // that kind registered with TypeBox's own `TypeRegistry` before validating, since
+ * // this resolver validates via `@sinclair/typebox`'s `Value.Errors`/`Value.Check`:
+ * // TypeRegistry.Set('Files', (schema, value) => Array.isArray(value));
  */
 export declare function typeboxResolver<Schema extends TObject, Context>(schema: Schema | TypeCheck<Schema>): Resolver<Static<Schema>, Context, StaticDecode<Schema>>;

package/typebox/dist/typebox.js.map

@@ -1 +1 @@
-{"version":3,"file":"typebox.js","sources":["../src/typebox.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { Static, StaticDecode, TObject } from '@sinclair/typebox';\nimport { TypeCheck } from '@sinclair/typebox/compiler';\nimport { Value, type ValueError } from '@sinclair/typebox/value';\nimport { FieldError, Resolver, appendErrors } from 'react-hook-form';\n\nfunction parseErrorSchema(\n  _errors: ValueError[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n  for (; _errors.length; ) {\n    const error = _errors[0];\n    const { type, message, path } = error;\n    const _path = path.substring(1).replace(/\\//g, '.');\n\n    if (!errors[_path]) {\n      errors[_path] = { message, type: '' + type };\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types['' + type];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        '' + type,\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    _errors.shift();\n  }\n\n  return errors;\n}\n\n/**\n * Creates a resolver for react-hook-form using Typebox schema validation\n * @param {Schema | TypeCheck<Schema>} schema - The Typebox schema to validate against\n * @param {Object} options - Additional resolver configuration\n * @param {string} [options.mode='async'] - Validation mode\n * @returns {Resolver<Static<Schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Type.Object({\n *   name: Type.String(),\n *   age: Type.Number()\n * });\n *\n * useForm({\n *   resolver: typeboxResolver(schema)\n * });\n */\nexport function typeboxResolver<Schema extends TObject, Context>(\n  schema: Schema | TypeCheck<Schema>,\n): Resolver<Static<Schema>, Context, StaticDecode<Schema>> {\n  return async (values: Static<Schema>, _, options) => {\n    const errors = Array.from(\n      schema instanceof TypeCheck\n        ? schema.Errors(values)\n        : Value.Errors(schema, values),\n    );\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    if (!errors.length) {\n      return {\n        errors: {},\n        values,\n      };\n    }\n\n    return {\n      values: {},\n      errors: toNestErrors(\n        parseErrorSchema(\n          errors,\n          !options.shouldUseNativeValidation && options.criteriaMode === 'all',\n        ),\n        options,\n      ),\n    };\n  };\n}\n"],"names":["parseErrorSchema","_errors","validateAllFieldCriteria","errors","length","error","type","message","_path","path","substring","replace","types","messages","appendErrors","concat","shift","schema","values","_","options","Array","from","TypeCheck","Errors","Value","shouldUseNativeValidation","validateFieldsNatively","Promise","resolve","toNestErrors","criteriaMode","e","reject"],"mappings":"+IAMA,SAASA,EACPC,EACAC,GAGA,IADA,IAAMC,EAAqC,CAAA,EACpCF,EAAQG,QAAU,CACvB,IAAMC,EAAQJ,EAAQ,GACdK,EAAwBD,EAAxBC,KAAMC,EAAkBF,EAAlBE,QACRC,EAD0BH,EAATI,KACJC,UAAU,GAAGC,QAAQ,MAAO,KAM/C,GAJKR,EAAOK,KACVL,EAAOK,GAAS,CAAED,QAAAA,EAASD,KAAM,GAAKA,IAGpCJ,EAA0B,CAC5B,IAAMU,EAAQT,EAAOK,GAAOI,MACtBC,EAAWD,GAASA,EAAM,GAAKN,GAErCH,EAAOK,GAASM,EAAAA,aACdN,EACAN,EACAC,EACA,GAAKG,EACLO,EACK,GAAgBE,OAAOF,EAAsBR,EAAME,SACpDF,EAAME,QAEd,CAEAN,EAAQe,OACV,CAEA,OAAOb,CACT,yBAkBM,SACJc,GAEA,OAAA,SAAcC,EAAwBC,EAAGC,OACvC,IAAMjB,EAASkB,MAAMC,KACnBL,aAAkBM,YACdN,EAAOO,OAAON,GACdO,QAAMD,OAAOP,EAAQC,IAK3B,OAFAE,EAAQM,2BAA6BC,yBAAuB,CAAA,EAAIP,GAShEQ,QAAAC,QAPK1B,EAAOC,OAOL,CACLc,OAAQ,CAAA,EACRf,OAAQ2B,EAAYA,aAClB9B,EACEG,GACCiB,EAAQM,2BAAsD,QAAzBN,EAAQW,cAEhDX,IAbK,CACLjB,OAAQ,CAAA,EACRe,OAAAA,GAcN,CAAC,MAAAc,GAAAJ,OAAAA,QAAAK,OAAAD,EACH,CAAA,CAAA"}
+{"version":3,"file":"typebox.js","sources":["../src/typebox.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { Static, StaticDecode, TObject } from '@sinclair/typebox';\nimport { TypeCheck } from '@sinclair/typebox/compiler';\nimport { Value, type ValueError } from '@sinclair/typebox/value';\nimport { FieldError, Resolver, appendErrors } from 'react-hook-form';\n\nfunction parseErrorSchema(\n  _errors: ValueError[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n  for (; _errors.length; ) {\n    const error = _errors[0];\n    const { type, message, path } = error;\n    const _path = path.substring(1).replace(/\\//g, '.');\n\n    if (!errors[_path]) {\n      errors[_path] = { message, type: '' + type };\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types['' + type];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        '' + type,\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    _errors.shift();\n  }\n\n  return errors;\n}\n\n/**\n * Creates a resolver for react-hook-form using Typebox schema validation\n * @param {Schema | TypeCheck<Schema>} schema - The Typebox schema to validate against\n * @param {Object} options - Additional resolver configuration\n * @param {string} [options.mode='async'] - Validation mode\n * @returns {Resolver<Static<Schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Type.Object({\n *   name: Type.String(),\n *   age: Type.Number()\n * });\n *\n * useForm({\n *   resolver: typeboxResolver(schema)\n * });\n *\n * // Schemas using a custom/third-party `Kind` (e.g. ElysiaJS's `t.Files()`) must have\n * // that kind registered with TypeBox's own `TypeRegistry` before validating, since\n * // this resolver validates via `@sinclair/typebox`'s `Value.Errors`/`Value.Check`:\n * // TypeRegistry.Set('Files', (schema, value) => Array.isArray(value));\n */\nexport function typeboxResolver<Schema extends TObject, Context>(\n  schema: Schema | TypeCheck<Schema>,\n): Resolver<Static<Schema>, Context, StaticDecode<Schema>> {\n  return async (values: Static<Schema>, _, options) => {\n    const errors = Array.from(\n      schema instanceof TypeCheck\n        ? schema.Errors(values)\n        : Value.Errors(schema, values),\n    );\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    if (!errors.length) {\n      return {\n        errors: {},\n        values,\n      };\n    }\n\n    return {\n      values: {},\n      errors: toNestErrors(\n        parseErrorSchema(\n          errors,\n          !options.shouldUseNativeValidation && options.criteriaMode === 'all',\n        ),\n        options,\n      ),\n    };\n  };\n}\n"],"names":["parseErrorSchema","_errors","validateAllFieldCriteria","errors","length","error","type","message","_path","path","substring","replace","types","messages","appendErrors","concat","shift","schema","values","_","options","Array","from","TypeCheck","Errors","Value","shouldUseNativeValidation","validateFieldsNatively","Promise","resolve","toNestErrors","criteriaMode","e","reject"],"mappings":"+IAMA,SAASA,EACPC,EACAC,GAGA,IADA,IAAMC,EAAqC,CAAA,EACpCF,EAAQG,QAAU,CACvB,IAAMC,EAAQJ,EAAQ,GACdK,EAAwBD,EAAxBC,KAAMC,EAAkBF,EAAlBE,QACRC,EAD0BH,EAATI,KACJC,UAAU,GAAGC,QAAQ,MAAO,KAM/C,GAJKR,EAAOK,KACVL,EAAOK,GAAS,CAAED,QAAAA,EAASD,KAAM,GAAKA,IAGpCJ,EAA0B,CAC5B,IAAMU,EAAQT,EAAOK,GAAOI,MACtBC,EAAWD,GAASA,EAAM,GAAKN,GAErCH,EAAOK,GAASM,EAAAA,aACdN,EACAN,EACAC,EACA,GAAKG,EACLO,EACK,GAAgBE,OAAOF,EAAsBR,EAAME,SACpDF,EAAME,QAEd,CAEAN,EAAQe,OACV,CAEA,OAAOb,CACT,yBAuBM,SACJc,GAEA,OAAA,SAAcC,EAAwBC,EAAGC,OACvC,IAAMjB,EAASkB,MAAMC,KACnBL,aAAkBM,YACdN,EAAOO,OAAON,GACdO,QAAMD,OAAOP,EAAQC,IAK3B,OAFAE,EAAQM,2BAA6BC,yBAAuB,CAAA,EAAIP,GAShEQ,QAAAC,QAPK1B,EAAOC,OAOL,CACLc,OAAQ,CAAA,EACRf,OAAQ2B,EAAYA,aAClB9B,EACEG,GACCiB,EAAQM,2BAAsD,QAAzBN,EAAQW,cAEhDX,IAbK,CACLjB,OAAQ,CAAA,EACRe,OAAAA,GAcN,CAAC,MAAAc,GAAAJ,OAAAA,QAAAK,OAAAD,EACH,CAAA,CAAA"}

package/typebox/dist/typebox.modern.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"typebox.modern.mjs","sources":["../src/typebox.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { Static, StaticDecode, TObject } from '@sinclair/typebox';\nimport { TypeCheck } from '@sinclair/typebox/compiler';\nimport { Value, type ValueError } from '@sinclair/typebox/value';\nimport { FieldError, Resolver, appendErrors } from 'react-hook-form';\n\nfunction parseErrorSchema(\n  _errors: ValueError[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n  for (; _errors.length; ) {\n    const error = _errors[0];\n    const { type, message, path } = error;\n    const _path = path.substring(1).replace(/\\//g, '.');\n\n    if (!errors[_path]) {\n      errors[_path] = { message, type: '' + type };\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types['' + type];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        '' + type,\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    _errors.shift();\n  }\n\n  return errors;\n}\n\n/**\n * Creates a resolver for react-hook-form using Typebox schema validation\n * @param {Schema | TypeCheck<Schema>} schema - The Typebox schema to validate against\n * @param {Object} options - Additional resolver configuration\n * @param {string} [options.mode='async'] - Validation mode\n * @returns {Resolver<Static<Schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Type.Object({\n *   name: Type.String(),\n *   age: Type.Number()\n * });\n *\n * useForm({\n *   resolver: typeboxResolver(schema)\n * });\n */\nexport function typeboxResolver<Schema extends TObject, Context>(\n  schema: Schema | TypeCheck<Schema>,\n): Resolver<Static<Schema>, Context, StaticDecode<Schema>> {\n  return async (values: Static<Schema>, _, options) => {\n    const errors = Array.from(\n      schema instanceof TypeCheck\n        ? schema.Errors(values)\n        : Value.Errors(schema, values),\n    );\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    if (!errors.length) {\n      return {\n        errors: {},\n        values,\n      };\n    }\n\n    return {\n      values: {},\n      errors: toNestErrors(\n        parseErrorSchema(\n          errors,\n          !options.shouldUseNativeValidation && options.criteriaMode === 'all',\n        ),\n        options,\n      ),\n    };\n  };\n}\n"],"names":["parseErrorSchema","_errors","validateAllFieldCriteria","errors","length","error","type","message","path","_path","substring","replace","types","messages","appendErrors","concat","shift","typeboxResolver","schema","values","_","options","Array","from","TypeCheck","Errors","Value","shouldUseNativeValidation","validateFieldsNatively","toNestErrors","criteriaMode"],"mappings":"qOAMA,SAASA,EACPC,EACAC,GAEA,MAAMC,EAAqC,CAAE,EAC7C,KAAOF,EAAQG,QAAU,CACvB,MAAMC,EAAQJ,EAAQ,IAChBK,KAAEA,EAAIC,QAAEA,EAAOC,KAAEA,GAASH,EAC1BI,EAAQD,EAAKE,UAAU,GAAGC,QAAQ,MAAO,KAM/C,GAJKR,EAAOM,KACVN,EAAOM,GAAS,CAAEF,UAASD,KAAM,GAAKA,IAGpCJ,EAA0B,CAC5B,MAAMU,EAAQT,EAAOM,GAAOG,MACtBC,EAAWD,GAASA,EAAM,GAAKN,GAErCH,EAAOM,GAASK,EACdL,EACAP,EACAC,EACA,GAAKG,EACLO,EACK,GAAgBE,OAAOF,EAAsBR,EAAME,SACpDF,EAAME,QAEd,CAEAN,EAAQe,OACV,CAEA,OAAOb,CACT,CAkBM,SAAUc,EACdC,GAEA,OAAcC,MAAAA,EAAwBC,EAAGC,KACvC,MAAMlB,EAASmB,MAAMC,KACnBL,aAAkBM,EACdN,EAAOO,OAAON,GACdO,EAAMD,OAAOP,EAAQC,IAK3B,OAFAE,EAAQM,2BAA6BC,EAAuB,CAAA,EAAIP,GAE3DlB,EAAOC,OAOL,CACLe,OAAQ,CAAA,EACRhB,OAAQ0B,EACN7B,EACEG,GACCkB,EAAQM,2BAAsD,QAAzBN,EAAQS,cAEhDT,IAbK,CACLlB,OAAQ,CAAA,EACRgB,SAaH,CAEL"}
+{"version":3,"file":"typebox.modern.mjs","sources":["../src/typebox.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { Static, StaticDecode, TObject } from '@sinclair/typebox';\nimport { TypeCheck } from '@sinclair/typebox/compiler';\nimport { Value, type ValueError } from '@sinclair/typebox/value';\nimport { FieldError, Resolver, appendErrors } from 'react-hook-form';\n\nfunction parseErrorSchema(\n  _errors: ValueError[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n  for (; _errors.length; ) {\n    const error = _errors[0];\n    const { type, message, path } = error;\n    const _path = path.substring(1).replace(/\\//g, '.');\n\n    if (!errors[_path]) {\n      errors[_path] = { message, type: '' + type };\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types['' + type];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        '' + type,\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    _errors.shift();\n  }\n\n  return errors;\n}\n\n/**\n * Creates a resolver for react-hook-form using Typebox schema validation\n * @param {Schema | TypeCheck<Schema>} schema - The Typebox schema to validate against\n * @param {Object} options - Additional resolver configuration\n * @param {string} [options.mode='async'] - Validation mode\n * @returns {Resolver<Static<Schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Type.Object({\n *   name: Type.String(),\n *   age: Type.Number()\n * });\n *\n * useForm({\n *   resolver: typeboxResolver(schema)\n * });\n *\n * // Schemas using a custom/third-party `Kind` (e.g. ElysiaJS's `t.Files()`) must have\n * // that kind registered with TypeBox's own `TypeRegistry` before validating, since\n * // this resolver validates via `@sinclair/typebox`'s `Value.Errors`/`Value.Check`:\n * // TypeRegistry.Set('Files', (schema, value) => Array.isArray(value));\n */\nexport function typeboxResolver<Schema extends TObject, Context>(\n  schema: Schema | TypeCheck<Schema>,\n): Resolver<Static<Schema>, Context, StaticDecode<Schema>> {\n  return async (values: Static<Schema>, _, options) => {\n    const errors = Array.from(\n      schema instanceof TypeCheck\n        ? schema.Errors(values)\n        : Value.Errors(schema, values),\n    );\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    if (!errors.length) {\n      return {\n        errors: {},\n        values,\n      };\n    }\n\n    return {\n      values: {},\n      errors: toNestErrors(\n        parseErrorSchema(\n          errors,\n          !options.shouldUseNativeValidation && options.criteriaMode === 'all',\n        ),\n        options,\n      ),\n    };\n  };\n}\n"],"names":["parseErrorSchema","_errors","validateAllFieldCriteria","errors","length","error","type","message","path","_path","substring","replace","types","messages","appendErrors","concat","shift","typeboxResolver","schema","values","_","options","Array","from","TypeCheck","Errors","Value","shouldUseNativeValidation","validateFieldsNatively","toNestErrors","criteriaMode"],"mappings":"qOAMA,SAASA,EACPC,EACAC,GAEA,MAAMC,EAAqC,CAAE,EAC7C,KAAOF,EAAQG,QAAU,CACvB,MAAMC,EAAQJ,EAAQ,IAChBK,KAAEA,EAAIC,QAAEA,EAAOC,KAAEA,GAASH,EAC1BI,EAAQD,EAAKE,UAAU,GAAGC,QAAQ,MAAO,KAM/C,GAJKR,EAAOM,KACVN,EAAOM,GAAS,CAAEF,UAASD,KAAM,GAAKA,IAGpCJ,EAA0B,CAC5B,MAAMU,EAAQT,EAAOM,GAAOG,MACtBC,EAAWD,GAASA,EAAM,GAAKN,GAErCH,EAAOM,GAASK,EACdL,EACAP,EACAC,EACA,GAAKG,EACLO,EACK,GAAgBE,OAAOF,EAAsBR,EAAME,SACpDF,EAAME,QAEd,CAEAN,EAAQe,OACV,CAEA,OAAOb,CACT,CAuBM,SAAUc,EACdC,GAEA,OAAcC,MAAAA,EAAwBC,EAAGC,KACvC,MAAMlB,EAASmB,MAAMC,KACnBL,aAAkBM,EACdN,EAAOO,OAAON,GACdO,EAAMD,OAAOP,EAAQC,IAK3B,OAFAE,EAAQM,2BAA6BC,EAAuB,CAAA,EAAIP,GAE3DlB,EAAOC,OAOL,CACLe,OAAQ,CAAA,EACRhB,OAAQ0B,EACN7B,EACEG,GACCkB,EAAQM,2BAAsD,QAAzBN,EAAQS,cAEhDT,IAbK,CACLlB,OAAQ,CAAA,EACRgB,SAaH,CAEL"}

package/typebox/dist/typebox.module.js.map

@@ -1 +1 @@
-{"version":3,"file":"typebox.module.js","sources":["../src/typebox.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { Static, StaticDecode, TObject } from '@sinclair/typebox';\nimport { TypeCheck } from '@sinclair/typebox/compiler';\nimport { Value, type ValueError } from '@sinclair/typebox/value';\nimport { FieldError, Resolver, appendErrors } from 'react-hook-form';\n\nfunction parseErrorSchema(\n  _errors: ValueError[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n  for (; _errors.length; ) {\n    const error = _errors[0];\n    const { type, message, path } = error;\n    const _path = path.substring(1).replace(/\\//g, '.');\n\n    if (!errors[_path]) {\n      errors[_path] = { message, type: '' + type };\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types['' + type];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        '' + type,\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    _errors.shift();\n  }\n\n  return errors;\n}\n\n/**\n * Creates a resolver for react-hook-form using Typebox schema validation\n * @param {Schema | TypeCheck<Schema>} schema - The Typebox schema to validate against\n * @param {Object} options - Additional resolver configuration\n * @param {string} [options.mode='async'] - Validation mode\n * @returns {Resolver<Static<Schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Type.Object({\n *   name: Type.String(),\n *   age: Type.Number()\n * });\n *\n * useForm({\n *   resolver: typeboxResolver(schema)\n * });\n */\nexport function typeboxResolver<Schema extends TObject, Context>(\n  schema: Schema | TypeCheck<Schema>,\n): Resolver<Static<Schema>, Context, StaticDecode<Schema>> {\n  return async (values: Static<Schema>, _, options) => {\n    const errors = Array.from(\n      schema instanceof TypeCheck\n        ? schema.Errors(values)\n        : Value.Errors(schema, values),\n    );\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    if (!errors.length) {\n      return {\n        errors: {},\n        values,\n      };\n    }\n\n    return {\n      values: {},\n      errors: toNestErrors(\n        parseErrorSchema(\n          errors,\n          !options.shouldUseNativeValidation && options.criteriaMode === 'all',\n        ),\n        options,\n      ),\n    };\n  };\n}\n"],"names":["parseErrorSchema","_errors","validateAllFieldCriteria","errors","length","error","type","message","_path","path","substring","replace","types","messages","appendErrors","concat","shift","typeboxResolver","schema","values","_","options","Array","from","TypeCheck","Errors","Value","shouldUseNativeValidation","validateFieldsNatively","Promise","resolve","toNestErrors","criteriaMode","e","reject"],"mappings":"qOAMA,SAASA,EACPC,EACAC,GAGA,IADA,IAAMC,EAAqC,CAAA,EACpCF,EAAQG,QAAU,CACvB,IAAMC,EAAQJ,EAAQ,GACdK,EAAwBD,EAAxBC,KAAMC,EAAkBF,EAAlBE,QACRC,EAD0BH,EAATI,KACJC,UAAU,GAAGC,QAAQ,MAAO,KAM/C,GAJKR,EAAOK,KACVL,EAAOK,GAAS,CAAED,QAAAA,EAASD,KAAM,GAAKA,IAGpCJ,EAA0B,CAC5B,IAAMU,EAAQT,EAAOK,GAAOI,MACtBC,EAAWD,GAASA,EAAM,GAAKN,GAErCH,EAAOK,GAASM,EACdN,EACAN,EACAC,EACA,GAAKG,EACLO,EACK,GAAgBE,OAAOF,EAAsBR,EAAME,SACpDF,EAAME,QAEd,CAEAN,EAAQe,OACV,CAEA,OAAOb,CACT,CAkBM,SAAUc,EACdC,GAEA,OAAA,SAAcC,EAAwBC,EAAGC,OACvC,IAAMlB,EAASmB,MAAMC,KACnBL,aAAkBM,EACdN,EAAOO,OAAON,GACdO,EAAMD,OAAOP,EAAQC,IAK3B,OAFAE,EAAQM,2BAA6BC,EAAuB,CAAA,EAAIP,GAShEQ,QAAAC,QAPK3B,EAAOC,OAOL,CACLe,OAAQ,CAAA,EACRhB,OAAQ4B,EACN/B,EACEG,GACCkB,EAAQM,2BAAsD,QAAzBN,EAAQW,cAEhDX,IAbK,CACLlB,OAAQ,CAAA,EACRgB,OAAAA,GAcN,CAAC,MAAAc,GAAAJ,OAAAA,QAAAK,OAAAD,EACH,CAAA,CAAA"}
+{"version":3,"file":"typebox.module.js","sources":["../src/typebox.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { Static, StaticDecode, TObject } from '@sinclair/typebox';\nimport { TypeCheck } from '@sinclair/typebox/compiler';\nimport { Value, type ValueError } from '@sinclair/typebox/value';\nimport { FieldError, Resolver, appendErrors } from 'react-hook-form';\n\nfunction parseErrorSchema(\n  _errors: ValueError[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n  for (; _errors.length; ) {\n    const error = _errors[0];\n    const { type, message, path } = error;\n    const _path = path.substring(1).replace(/\\//g, '.');\n\n    if (!errors[_path]) {\n      errors[_path] = { message, type: '' + type };\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types['' + type];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        '' + type,\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    _errors.shift();\n  }\n\n  return errors;\n}\n\n/**\n * Creates a resolver for react-hook-form using Typebox schema validation\n * @param {Schema | TypeCheck<Schema>} schema - The Typebox schema to validate against\n * @param {Object} options - Additional resolver configuration\n * @param {string} [options.mode='async'] - Validation mode\n * @returns {Resolver<Static<Schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Type.Object({\n *   name: Type.String(),\n *   age: Type.Number()\n * });\n *\n * useForm({\n *   resolver: typeboxResolver(schema)\n * });\n *\n * // Schemas using a custom/third-party `Kind` (e.g. ElysiaJS's `t.Files()`) must have\n * // that kind registered with TypeBox's own `TypeRegistry` before validating, since\n * // this resolver validates via `@sinclair/typebox`'s `Value.Errors`/`Value.Check`:\n * // TypeRegistry.Set('Files', (schema, value) => Array.isArray(value));\n */\nexport function typeboxResolver<Schema extends TObject, Context>(\n  schema: Schema | TypeCheck<Schema>,\n): Resolver<Static<Schema>, Context, StaticDecode<Schema>> {\n  return async (values: Static<Schema>, _, options) => {\n    const errors = Array.from(\n      schema instanceof TypeCheck\n        ? schema.Errors(values)\n        : Value.Errors(schema, values),\n    );\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    if (!errors.length) {\n      return {\n        errors: {},\n        values,\n      };\n    }\n\n    return {\n      values: {},\n      errors: toNestErrors(\n        parseErrorSchema(\n          errors,\n          !options.shouldUseNativeValidation && options.criteriaMode === 'all',\n        ),\n        options,\n      ),\n    };\n  };\n}\n"],"names":["parseErrorSchema","_errors","validateAllFieldCriteria","errors","length","error","type","message","_path","path","substring","replace","types","messages","appendErrors","concat","shift","typeboxResolver","schema","values","_","options","Array","from","TypeCheck","Errors","Value","shouldUseNativeValidation","validateFieldsNatively","Promise","resolve","toNestErrors","criteriaMode","e","reject"],"mappings":"qOAMA,SAASA,EACPC,EACAC,GAGA,IADA,IAAMC,EAAqC,CAAA,EACpCF,EAAQG,QAAU,CACvB,IAAMC,EAAQJ,EAAQ,GACdK,EAAwBD,EAAxBC,KAAMC,EAAkBF,EAAlBE,QACRC,EAD0BH,EAATI,KACJC,UAAU,GAAGC,QAAQ,MAAO,KAM/C,GAJKR,EAAOK,KACVL,EAAOK,GAAS,CAAED,QAAAA,EAASD,KAAM,GAAKA,IAGpCJ,EAA0B,CAC5B,IAAMU,EAAQT,EAAOK,GAAOI,MACtBC,EAAWD,GAASA,EAAM,GAAKN,GAErCH,EAAOK,GAASM,EACdN,EACAN,EACAC,EACA,GAAKG,EACLO,EACK,GAAgBE,OAAOF,EAAsBR,EAAME,SACpDF,EAAME,QAEd,CAEAN,EAAQe,OACV,CAEA,OAAOb,CACT,CAuBM,SAAUc,EACdC,GAEA,OAAA,SAAcC,EAAwBC,EAAGC,OACvC,IAAMlB,EAASmB,MAAMC,KACnBL,aAAkBM,EACdN,EAAOO,OAAON,GACdO,EAAMD,OAAOP,EAAQC,IAK3B,OAFAE,EAAQM,2BAA6BC,EAAuB,CAAA,EAAIP,GAShEQ,QAAAC,QAPK3B,EAAOC,OAOL,CACLe,OAAQ,CAAA,EACRhB,OAAQ4B,EACN/B,EACEG,GACCkB,EAAQM,2BAAsD,QAAzBN,EAAQW,cAEhDX,IAbK,CACLlB,OAAQ,CAAA,EACRgB,OAAAA,GAcN,CAAC,MAAAc,GAAAJ,OAAAA,QAAAK,OAAAD,EACH,CAAA,CAAA"}

package/typebox/dist/typebox.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"typebox.umd.js","sources":["../src/typebox.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { Static, StaticDecode, TObject } from '@sinclair/typebox';\nimport { TypeCheck } from '@sinclair/typebox/compiler';\nimport { Value, type ValueError } from '@sinclair/typebox/value';\nimport { FieldError, Resolver, appendErrors } from 'react-hook-form';\n\nfunction parseErrorSchema(\n  _errors: ValueError[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n  for (; _errors.length; ) {\n    const error = _errors[0];\n    const { type, message, path } = error;\n    const _path = path.substring(1).replace(/\\//g, '.');\n\n    if (!errors[_path]) {\n      errors[_path] = { message, type: '' + type };\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types['' + type];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        '' + type,\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    _errors.shift();\n  }\n\n  return errors;\n}\n\n/**\n * Creates a resolver for react-hook-form using Typebox schema validation\n * @param {Schema | TypeCheck<Schema>} schema - The Typebox schema to validate against\n * @param {Object} options - Additional resolver configuration\n * @param {string} [options.mode='async'] - Validation mode\n * @returns {Resolver<Static<Schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Type.Object({\n *   name: Type.String(),\n *   age: Type.Number()\n * });\n *\n * useForm({\n *   resolver: typeboxResolver(schema)\n * });\n */\nexport function typeboxResolver<Schema extends TObject, Context>(\n  schema: Schema | TypeCheck<Schema>,\n): Resolver<Static<Schema>, Context, StaticDecode<Schema>> {\n  return async (values: Static<Schema>, _, options) => {\n    const errors = Array.from(\n      schema instanceof TypeCheck\n        ? schema.Errors(values)\n        : Value.Errors(schema, values),\n    );\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    if (!errors.length) {\n      return {\n        errors: {},\n        values,\n      };\n    }\n\n    return {\n      values: {},\n      errors: toNestErrors(\n        parseErrorSchema(\n          errors,\n          !options.shouldUseNativeValidation && options.criteriaMode === 'all',\n        ),\n        options,\n      ),\n    };\n  };\n}\n"],"names":["parseErrorSchema","_errors","validateAllFieldCriteria","errors","length","error","type","message","_path","path","substring","replace","types","messages","appendErrors","concat","shift","schema","values","_","options","Array","from","TypeCheck","Errors","Value","shouldUseNativeValidation","validateFieldsNatively","Promise","resolve","toNestErrors","criteriaMode","e","reject"],"mappings":"mhBAMA,SAASA,EACPC,EACAC,GAGA,IADA,IAAMC,EAAqC,CAAA,EACpCF,EAAQG,QAAU,CACvB,IAAMC,EAAQJ,EAAQ,GACdK,EAAwBD,EAAxBC,KAAMC,EAAkBF,EAAlBE,QACRC,EAD0BH,EAATI,KACJC,UAAU,GAAGC,QAAQ,MAAO,KAM/C,GAJKR,EAAOK,KACVL,EAAOK,GAAS,CAAED,QAAAA,EAASD,KAAM,GAAKA,IAGpCJ,EAA0B,CAC5B,IAAMU,EAAQT,EAAOK,GAAOI,MACtBC,EAAWD,GAASA,EAAM,GAAKN,GAErCH,EAAOK,GAASM,EAAAA,aACdN,EACAN,EACAC,EACA,GAAKG,EACLO,EACK,GAAgBE,OAAOF,EAAsBR,EAAME,SACpDF,EAAME,QAEd,CAEAN,EAAQe,OACV,CAEA,OAAOb,CACT,mBAkBM,SACJc,GAEA,OAAA,SAAcC,EAAwBC,EAAGC,OACvC,IAAMjB,EAASkB,MAAMC,KACnBL,aAAkBM,YACdN,EAAOO,OAAON,GACdO,QAAMD,OAAOP,EAAQC,IAK3B,OAFAE,EAAQM,2BAA6BC,yBAAuB,CAAA,EAAIP,GAShEQ,QAAAC,QAPK1B,EAAOC,OAOL,CACLc,OAAQ,CAAA,EACRf,OAAQ2B,EAAYA,aAClB9B,EACEG,GACCiB,EAAQM,2BAAsD,QAAzBN,EAAQW,cAEhDX,IAbK,CACLjB,OAAQ,CAAA,EACRe,OAAAA,GAcN,CAAC,MAAAc,GAAAJ,OAAAA,QAAAK,OAAAD,EACH,CAAA,CAAA"}
+{"version":3,"file":"typebox.umd.js","sources":["../src/typebox.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { Static, StaticDecode, TObject } from '@sinclair/typebox';\nimport { TypeCheck } from '@sinclair/typebox/compiler';\nimport { Value, type ValueError } from '@sinclair/typebox/value';\nimport { FieldError, Resolver, appendErrors } from 'react-hook-form';\n\nfunction parseErrorSchema(\n  _errors: ValueError[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n  for (; _errors.length; ) {\n    const error = _errors[0];\n    const { type, message, path } = error;\n    const _path = path.substring(1).replace(/\\//g, '.');\n\n    if (!errors[_path]) {\n      errors[_path] = { message, type: '' + type };\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types['' + type];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        '' + type,\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    _errors.shift();\n  }\n\n  return errors;\n}\n\n/**\n * Creates a resolver for react-hook-form using Typebox schema validation\n * @param {Schema | TypeCheck<Schema>} schema - The Typebox schema to validate against\n * @param {Object} options - Additional resolver configuration\n * @param {string} [options.mode='async'] - Validation mode\n * @returns {Resolver<Static<Schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Type.Object({\n *   name: Type.String(),\n *   age: Type.Number()\n * });\n *\n * useForm({\n *   resolver: typeboxResolver(schema)\n * });\n *\n * // Schemas using a custom/third-party `Kind` (e.g. ElysiaJS's `t.Files()`) must have\n * // that kind registered with TypeBox's own `TypeRegistry` before validating, since\n * // this resolver validates via `@sinclair/typebox`'s `Value.Errors`/`Value.Check`:\n * // TypeRegistry.Set('Files', (schema, value) => Array.isArray(value));\n */\nexport function typeboxResolver<Schema extends TObject, Context>(\n  schema: Schema | TypeCheck<Schema>,\n): Resolver<Static<Schema>, Context, StaticDecode<Schema>> {\n  return async (values: Static<Schema>, _, options) => {\n    const errors = Array.from(\n      schema instanceof TypeCheck\n        ? schema.Errors(values)\n        : Value.Errors(schema, values),\n    );\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    if (!errors.length) {\n      return {\n        errors: {},\n        values,\n      };\n    }\n\n    return {\n      values: {},\n      errors: toNestErrors(\n        parseErrorSchema(\n          errors,\n          !options.shouldUseNativeValidation && options.criteriaMode === 'all',\n        ),\n        options,\n      ),\n    };\n  };\n}\n"],"names":["parseErrorSchema","_errors","validateAllFieldCriteria","errors","length","error","type","message","_path","path","substring","replace","types","messages","appendErrors","concat","shift","schema","values","_","options","Array","from","TypeCheck","Errors","Value","shouldUseNativeValidation","validateFieldsNatively","Promise","resolve","toNestErrors","criteriaMode","e","reject"],"mappings":"mhBAMA,SAASA,EACPC,EACAC,GAGA,IADA,IAAMC,EAAqC,CAAA,EACpCF,EAAQG,QAAU,CACvB,IAAMC,EAAQJ,EAAQ,GACdK,EAAwBD,EAAxBC,KAAMC,EAAkBF,EAAlBE,QACRC,EAD0BH,EAATI,KACJC,UAAU,GAAGC,QAAQ,MAAO,KAM/C,GAJKR,EAAOK,KACVL,EAAOK,GAAS,CAAED,QAAAA,EAASD,KAAM,GAAKA,IAGpCJ,EAA0B,CAC5B,IAAMU,EAAQT,EAAOK,GAAOI,MACtBC,EAAWD,GAASA,EAAM,GAAKN,GAErCH,EAAOK,GAASM,EAAAA,aACdN,EACAN,EACAC,EACA,GAAKG,EACLO,EACK,GAAgBE,OAAOF,EAAsBR,EAAME,SACpDF,EAAME,QAEd,CAEAN,EAAQe,OACV,CAEA,OAAOb,CACT,mBAuBM,SACJc,GAEA,OAAA,SAAcC,EAAwBC,EAAGC,OACvC,IAAMjB,EAASkB,MAAMC,KACnBL,aAAkBM,YACdN,EAAOO,OAAON,GACdO,QAAMD,OAAOP,EAAQC,IAK3B,OAFAE,EAAQM,2BAA6BC,yBAAuB,CAAA,EAAIP,GAShEQ,QAAAC,QAPK1B,EAAOC,OAOL,CACLc,OAAQ,CAAA,EACRf,OAAQ2B,EAAYA,aAClB9B,EACEG,GACCiB,EAAQM,2BAAsD,QAAzBN,EAAQW,cAEhDX,IAbK,CACLjB,OAAQ,CAAA,EACRe,OAAAA,GAcN,CAAC,MAAAc,GAAAJ,OAAAA,QAAAK,OAAAD,EACH,CAAA,CAAA"}

package/typebox/src/typebox.ts

@@ -54,6 +54,11 @@ function parseErrorSchema(
  * useForm({
  *   resolver: typeboxResolver(schema)
  * });
+ *
+ * // Schemas using a custom/third-party `Kind` (e.g. ElysiaJS's `t.Files()`) must have
+ * // that kind registered with TypeBox's own `TypeRegistry` before validating, since
+ * // this resolver validates via `@sinclair/typebox`'s `Value.Errors`/`Value.Check`:
+ * // TypeRegistry.Set('Files', (schema, value) => Array.isArray(value));
  */
 export function typeboxResolver<Schema extends TObject, Context>(
   schema: Schema | TypeCheck<Schema>,

package/valibot/src/__tests__/valibot.ts

@@ -213,4 +213,32 @@ describe('valibotResolver', () => {
       }>
     >();
   });
+
+  it('keeps handleSubmit typed to the transformed output when useForm is given all three generics (#773)', () => {
+    const schema = v.object({
+      name: v.string(),
+      number: v.pipe(v.string(), v.transform(Number)),
+    });
+
+    const {
+      result: { current: form },
+    } = renderHook(() =>
+      useForm<
+        v.InferInput<typeof schema>,
+        unknown,
+        v.InferOutput<typeof schema>
+      >({
+        resolver: valibotResolver(schema),
+      }),
+    );
+
+    expectTypeOf(form.watch('number')).toEqualTypeOf<string>();
+
+    expectTypeOf(form.handleSubmit).parameter(0).toEqualTypeOf<
+      SubmitHandler<{
+        name: string;
+        number: number;
+      }>
+    >();
+  });
 });

package/yup/src/__tests__/Form.tsx

@@ -50,3 +50,29 @@ test("form's validation with Yup and TypeScript's integration", async () => {
   expect(screen.getByText(/password is a required field/i)).toBeInTheDocument();
   expect(handleSubmit).not.toHaveBeenCalled();
 });
+
+const checkboxSchema = Yup.object({
+  isTosAccepted: Yup.boolean().oneOf([true], 'must accept tos').required(),
+});
+
+test('errors.<field>.ref is the checkbox input element, not validation metadata (#630)', async () => {
+  let latestErrors: ReturnType<typeof useForm>['formState']['errors'] = {};
+  function Wrapper() {
+    const methods = useForm({ resolver: yupResolver(checkboxSchema) });
+    latestErrors = methods.formState.errors;
+
+    return (
+      <form onSubmit={methods.handleSubmit(() => {})}>
+        <input type="checkbox" {...methods.register('isTosAccepted')} />
+        <button type="submit">submit</button>
+      </form>
+    );
+  }
+
+  render(<Wrapper />);
+
+  const checkbox = screen.getByRole('checkbox');
+  await user.click(screen.getByText(/submit/i));
+
+  expect(latestErrors.isTosAccepted?.ref).toBe(checkbox);
+});

package/zod/dist/zod.d.ts

@@ -1,6 +1,6 @@
 import { FieldValues, Resolver } from 'react-hook-form';
-import * as z3 from 'zod/v3';
-import * as z4 from 'zod/v4/core';
+import type * as z3 from 'zod/v3';
+import type * as z4 from 'zod/v4/core';
 type RawResolverOptions = {
     mode?: 'async' | 'sync';
     raw: true;

package/zod/dist/zod.js

@@ -1,2 +1,2 @@
-var r=require("@hookform/resolvers"),e=require("react-hook-form");function n(r){if(r&&r.__esModule)return r;var e=Object.create(null);return r&&Object.keys(r).forEach(function(n){if("default"!==n){var t=Object.getOwnPropertyDescriptor(r,n);Object.defineProperty(e,n,t.get?t:{enumerable:!0,get:function(){return r[n]}})}}),e.default=r,e}var t=/*#__PURE__*/n(require("zod/v4/core"));function o(){return o=Object.assign?Object.assign.bind():function(r){for(var e=1;e<arguments.length;e++){var n=arguments[e];for(var t in n)({}).hasOwnProperty.call(n,t)&&(r[t]=n[t])}return r},o.apply(null,arguments)}function s(r,e){try{var n=r()}catch(r){return e(r)}return n&&n.then?n.then(void 0,e):n}function i(r,n){for(var t={};r.length;){var o=r[0],s=o.code,i=o.message,a=o.path.join(".");if(!t[a])if("unionErrors"in o){var u,c,l=o.unionErrors.reduce(function(r,e){return e.errors.length<r.errors.length?e:r}).errors[0];t[a]={message:null!=(u=null==l?void 0:l.message)?u:i,type:null!=(c=null==l?void 0:l.code)?c:s}}else t[a]={message:i,type:s};if("unionErrors"in o&&o.unionErrors.forEach(function(e){return e.errors.forEach(function(e){return r.push(e)})}),n){var f=t[a].types,d=f&&f[o.code];t[a]=e.appendErrors(a,n,t,s,d?[].concat(d,o.message):o.message)}r.shift()}return t}function a(r,n){for(var t={},s=function(){var s=r[0],i=s.code,a=s.message,u=s.path.join(".");if(!t[u])if("invalid_union"===s.code&&s.errors.length>0){var c,l,f=s.errors.reduce(function(r,e){return e.length<r.length?e:r})[0];t[u]={message:null!=(c=null==f?void 0:f.message)?c:a,type:null!=(l=null==f?void 0:f.code)?l:i}}else t[u]={message:a,type:i};if("invalid_union"===s.code&&s.errors.forEach(function(e){return e.forEach(function(e){return r.push(o({},e,{path:[].concat(s.path,e.path)}))})}),n){var d=t[u].types,v=d&&d[s.code];t[u]=e.appendErrors(u,n,t,i,v?[].concat(v,s.message):s.message)}r.shift()};r.length;)s();return t}exports.zodResolver=function(e,n,o){if(void 0===o&&(o={}),function(r){return"_zod"in r&&"object"==typeof r._zod}(e))return function(i,u,c){try{return Promise.resolve(s(function(){function t(e){return c.shouldUseNativeValidation&&r.validateFieldsNatively({},c),{errors:{},values:o.raw?Object.assign({},i):e}}var s=e;return"sync"===o.mode?t(s.parse(i,n)):Promise.resolve(s.parseAsync(i,n)).then(t)},function(e){if(function(r){return r instanceof t.$ZodError}(e))return{values:{},errors:r.toNestErrors(a(e.issues,!c.shouldUseNativeValidation&&"all"===c.criteriaMode),c)};throw e}))}catch(r){return Promise.reject(r)}};if(function(r){return"_def"in r&&"object"==typeof r._def}(e))return function(t,a,u){try{return Promise.resolve(s(function(){return Promise.resolve(e["sync"===o.mode?"parse":"parseAsync"](t,n)).then(function(e){return u.shouldUseNativeValidation&&r.validateFieldsNatively({},u),{errors:{},values:o.raw?Object.assign({},t):e}})},function(e){if(function(r){return Array.isArray(null==r?void 0:r.issues)}(e))return{values:{},errors:r.toNestErrors(i(e.errors,!u.shouldUseNativeValidation&&"all"===u.criteriaMode),u)};throw e}))}catch(r){return Promise.reject(r)}};throw new Error("Invalid input: not a Zod schema")};
+var r=require("@hookform/resolvers"),e=require("react-hook-form");function n(){return n=Object.assign?Object.assign.bind():function(r){for(var e=1;e<arguments.length;e++){var n=arguments[e];for(var o in n)({}).hasOwnProperty.call(n,o)&&(r[o]=n[o])}return r},n.apply(null,arguments)}function o(r,e){try{var n=r()}catch(r){return e(r)}return n&&n.then?n.then(void 0,e):n}function t(r,n){for(var o={};r.length;){var t=r[0],s=t.code,i=t.message,a=t.path.join(".");if(!o[a])if("unionErrors"in t){var u,l,c=t.unionErrors.reduce(function(r,e){return e.errors.length<r.errors.length?e:r}).errors[0];o[a]={message:null!=(u=null==c?void 0:c.message)?u:i,type:null!=(l=null==c?void 0:c.code)?l:s}}else o[a]={message:i,type:s};if("unionErrors"in t&&t.unionErrors.forEach(function(e){return e.errors.forEach(function(e){return r.push(e)})}),n){var f=o[a].types,d=f&&f[t.code];o[a]=e.appendErrors(a,n,o,s,d?[].concat(d,t.message):t.message)}r.shift()}return o}function s(r,o){for(var t={},s=function(){var s=r[0],i=s.code,a=s.message,u=s.path.join(".");if(!t[u])if("invalid_union"===s.code&&s.errors.length>0){var l,c,f=s.errors.reduce(function(r,e){return e.length<r.length?e:r})[0];t[u]={message:null!=(l=null==f?void 0:f.message)?l:a,type:null!=(c=null==f?void 0:f.code)?c:i}}else t[u]={message:a,type:i};if("invalid_union"===s.code&&s.errors.forEach(function(e){return e.forEach(function(e){return r.push(n({},e,{path:[].concat(s.path,e.path)}))})}),o){var d=t[u].types,v=d&&d[s.code];t[u]=e.appendErrors(u,o,t,i,v?[].concat(v,s.message):s.message)}r.shift()};r.length;)s();return t}exports.zodResolver=function(e,n,i){if(void 0===i&&(i={}),function(r){return"_zod"in r&&"object"==typeof r._zod}(e))return function(t,a,u){try{return Promise.resolve(o(function(){function o(e){return u.shouldUseNativeValidation&&r.validateFieldsNatively({},u),{errors:{},values:i.raw?Object.assign({},t):e}}var s=e;return"sync"===i.mode?o(s.parse(t,n)):Promise.resolve(s.parseAsync(t,n)).then(o)},function(e){if(function(r){var e;return!(null==r||null==(e=r._zod)||null==(e=e.traits)||!e.has("$ZodError"))}(e))return{values:{},errors:r.toNestErrors(s(e.issues,!u.shouldUseNativeValidation&&"all"===u.criteriaMode),u)};throw e}))}catch(r){return Promise.reject(r)}};if(function(r){return"_def"in r&&"object"==typeof r._def}(e))return function(s,a,u){try{return Promise.resolve(o(function(){return Promise.resolve(e["sync"===i.mode?"parse":"parseAsync"](s,n)).then(function(e){return u.shouldUseNativeValidation&&r.validateFieldsNatively({},u),{errors:{},values:i.raw?Object.assign({},s):e}})},function(e){if(function(r){return Array.isArray(null==r?void 0:r.issues)}(e))return{values:{},errors:r.toNestErrors(t(e.errors,!u.shouldUseNativeValidation&&"all"===u.criteriaMode),u)};throw e}))}catch(r){return Promise.reject(r)}};throw new Error("Invalid input: not a Zod schema")};
 //# sourceMappingURL=zod.js.map

package/zod/dist/zod.js.map

@@ -1 +1 @@
-{"version":3,"file":"zod.js","sources":["../src/zod.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport {\n  FieldError,\n  FieldValues,\n  Resolver,\n  ResolverError,\n  ResolverSuccess,\n  appendErrors,\n} from 'react-hook-form';\nimport * as z3 from 'zod/v3';\nimport * as z4 from 'zod/v4/core';\n\nconst isZod3Error = (error: any): error is z3.ZodError => {\n  return Array.isArray(error?.issues);\n};\nconst isZod3Schema = (schema: any): schema is z3.ZodSchema => {\n  // Deliberately doesn't require `typeName` in `_def` — dynamically selected\n  // schemas typed via the generic `z.ZodType<Output>` annotation (rather than\n  // a concrete subclass like `ZodObject`) don't statically expose `typeName`,\n  // even though they're genuine Zod 3 schema instances at runtime.\n  return '_def' in schema && typeof schema._def === 'object';\n};\nconst isZod4Error = (error: any): error is z4.$ZodError => {\n  // instanceof is safe in Zod 4 (uses Symbol.hasInstance)\n  return error instanceof z4.$ZodError;\n};\nconst isZod4Schema = (schema: any): schema is z4.$ZodType => {\n  return '_zod' in schema && typeof schema._zod === 'object';\n};\n\nfunction parseZod3Issues(\n  zodErrors: z3.ZodIssue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n  for (; zodErrors.length; ) {\n    const error = zodErrors[0];\n    const { code, message, path } = error;\n    const _path = path.join('.');\n\n    if (!errors[_path]) {\n      if ('unionErrors' in error) {\n        // Surface the error from whichever union member came closest to\n        // matching (fewest issues), rather than always the first member —\n        // the first member isn't necessarily the one the input was meant for.\n        const closestUnionError = error.unionErrors.reduce(\n          (closest, current) =>\n            current.errors.length < closest.errors.length ? current : closest,\n        );\n        // Fall back to the union issue's own message/code if the closest\n        // member somehow has no issues of its own (shouldn't happen, but\n        // avoids ever throwing on an unexpected/malformed union shape).\n        const unionError = closestUnionError.errors[0];\n\n        errors[_path] = {\n          message: unionError?.message ?? message,\n          type: unionError?.code ?? code,\n        };\n      } else {\n        errors[_path] = { message, type: code };\n      }\n    }\n\n    if ('unionErrors' in error) {\n      error.unionErrors.forEach((unionError) =>\n        unionError.errors.forEach((e) => zodErrors.push(e)),\n      );\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types[error.code];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        code,\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    zodErrors.shift();\n  }\n\n  return errors;\n}\n\nfunction parseZod4Issues(\n  zodErrors: z4.$ZodIssue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n  // const _zodErrors = zodErrors as z4.$ZodISsue; //\n  for (; zodErrors.length; ) {\n    const error = zodErrors[0];\n    const { code, message, path } = error;\n    const _path = path.join('.');\n\n    if (!errors[_path]) {\n      if (error.code === 'invalid_union' && error.errors.length > 0) {\n        // Surface the error from whichever union member came closest to\n        // matching (fewest issues), rather than always the first member —\n        // the first member isn't necessarily the one the input was meant for.\n        const closestBranch = error.errors.reduce((closest, branch) =>\n          branch.length < closest.length ? branch : closest,\n        );\n        // Fall back to the union issue's own message/code if the closest\n        // branch somehow has no issues of its own (shouldn't happen — a\n        // 0-issue branch means that branch matched — but this guarantees we\n        // never throw on an unexpected/malformed union shape, e.g. a \"no\n        // matching discriminator\" issue nested in a way we haven't seen).\n        const unionError = closestBranch[0];\n\n        errors[_path] = {\n          message: unionError?.message ?? message,\n          type: unionError?.code ?? code,\n        };\n      } else {\n        errors[_path] = { message, type: code };\n      }\n    }\n\n    if (error.code === 'invalid_union') {\n      error.errors.forEach((unionError) =>\n        unionError.forEach((e) =>\n          zodErrors.push({ ...e, path: [...error.path, ...e.path] }),\n        ),\n      );\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types[error.code];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        code,\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    zodErrors.shift();\n  }\n\n  return errors;\n}\n\ntype RawResolverOptions = {\n  mode?: 'async' | 'sync';\n  raw: true;\n};\ntype NonRawResolverOptions = {\n  mode?: 'async' | 'sync';\n  raw?: false;\n};\n\n// minimal interfaces to avoid asssignability issues between versions\ninterface Zod3Type<O = unknown, I = unknown> {\n  _output: O;\n  _input: I;\n  _def: object;\n}\n\n// minimal interface to avoid assignability issues between zod v4 patch/minor\n// releases, which brand the full `$ZodType` shape with an exact version literal\n// (e.g. `_zod.version.minor`)\ninterface Zod4Type<Output = unknown, Input = unknown> {\n  _zod: {\n    output: Output;\n    input: Input;\n  };\n}\n\n// some type magic to make versions pre-3.25.0 still work\ntype IsUnresolved<T> = PropertyKey extends keyof T ? true : false;\ntype UnresolvedFallback<T, Fallback> = IsUnresolved<typeof z3> extends true\n  ? Fallback\n  : T;\ntype FallbackIssue = {\n  code: string;\n  message: string;\n  path: (string | number)[];\n};\ntype Zod3ParseParams = UnresolvedFallback<\n  z3.ParseParams,\n  // fallback if user is on <3.25.0\n  {\n    path?: (string | number)[];\n    errorMap?: (\n      iss: FallbackIssue,\n      ctx: {\n        defaultError: string;\n        data: any;\n      },\n    ) => { message: string };\n    async?: boolean;\n  }\n>;\ntype Zod4ParseParams = UnresolvedFallback<\n  z4.ParseContext<z4.$ZodIssue>,\n  // fallback if user is on <3.25.0\n  {\n    readonly error?: (\n      iss: FallbackIssue,\n    ) => null | undefined | string | { message: string };\n    readonly reportInput?: boolean;\n    readonly jitless?: boolean;\n  }\n>;\n\nexport function zodResolver<Input extends FieldValues, Context, Output>(\n  schema: Zod3Type<Output, Input>,\n  schemaOptions?: Zod3ParseParams,\n  resolverOptions?: NonRawResolverOptions,\n): Resolver<Input, Context, Output>;\nexport function zodResolver<Input extends FieldValues, Context, Output>(\n  schema: Zod3Type<Output, Input>,\n  schemaOptions: Zod3ParseParams | undefined,\n  resolverOptions: RawResolverOptions,\n): Resolver<Input, Context, Input>;\n// the Zod 4 overloads need to be generic for complicated reasons\nexport function zodResolver<\n  Input extends FieldValues,\n  Context,\n  Output,\n  T extends Zod4Type<Output, Input> = Zod4Type<Output, Input>,\n>(\n  schema: T,\n  schemaOptions?: Zod4ParseParams, // already partial\n  resolverOptions?: NonRawResolverOptions,\n): Resolver<z4.input<T>, Context, z4.output<T>>;\nexport function zodResolver<\n  Input extends FieldValues,\n  Context,\n  Output,\n  T extends Zod4Type<Output, Input> = Zod4Type<Output, Input>,\n>(\n  schema: Zod4Type<Output, Input>,\n  schemaOptions: Zod4ParseParams | undefined, // already partial\n  resolverOptions: RawResolverOptions,\n): Resolver<z4.input<T>, Context, z4.input<T>>;\n/**\n * Creates a resolver function for react-hook-form that validates form data using a Zod schema\n * @param {z3.ZodSchema<Input>} schema - The Zod schema used to validate the form data\n * @param {Partial<z3.ParseParams>} [schemaOptions] - Optional configuration options for Zod parsing\n * @param {Object} [resolverOptions] - Optional resolver-specific configuration\n * @param {('async'|'sync')} [resolverOptions.mode='async'] - Validation mode. Use 'sync' for synchronous validation\n * @param {boolean} [resolverOptions.raw=false] - If true, returns the raw form values instead of the parsed data\n * @returns {Resolver<z3.output<typeof schema>>} A resolver function compatible with react-hook-form\n * @throws {Error} Throws if validation fails with a non-Zod error\n * @example\n * const schema = z3.object({\n *   name: z3.string().min(2),\n *   age: z3.number().min(18)\n * });\n *\n * useForm({\n *   resolver: zodResolver(schema)\n * });\n */\nexport function zodResolver<Input extends FieldValues, Context, Output>(\n  schema: object,\n  schemaOptions?: object,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Output | Input> {\n  // Zod 4 is checked first: its `_zod` marker is unambiguous, whereas the\n  // Zod 3 check below only requires an object-shaped `_def` (to support\n  // dynamically-selected schemas typed via the generic `z.ZodType<Output>`\n  // annotation, see `isZod3Schema`) — and Zod 4 schemas also have an\n  // object-shaped `_def`, so they'd otherwise be misdetected as Zod 3.\n  if (isZod4Schema(schema)) {\n    return async (values: Input, _, options) => {\n      try {\n        // Call the schema's own bound `parse`/`parseAsync` method rather\n        // than the standalone `z4.parse`/`z4.parseAsync` functions. Those\n        // standalone functions read from this module's own imported\n        // `zod/v4/core`, which — under bundlers that can resolve `zod` and\n        // `zod/v4/core` to two distinct module instances (e.g. Metro with\n        // package-exports resolution enabled) — may not be the same zod\n        // instance the schema was created with, silently dropping any\n        // global config (`z.config()`) or locale the app configured on its\n        // own zod instance. The schema's own method is always bound to\n        // whichever zod instance actually created it.\n        const classicSchema = schema as unknown as {\n          parse: (values: unknown, schemaOptions: unknown) => unknown;\n          parseAsync: (\n            values: unknown,\n            schemaOptions: unknown,\n          ) => Promise<unknown>;\n        };\n        const data: any =\n          resolverOptions.mode === 'sync'\n            ? classicSchema.parse(values, schemaOptions)\n            : await classicSchema.parseAsync(values, schemaOptions);\n\n        options.shouldUseNativeValidation &&\n          validateFieldsNatively({}, options);\n\n        return {\n          errors: {},\n          values: resolverOptions.raw ? Object.assign({}, values) : data,\n        } satisfies ResolverSuccess<Output | Input>;\n      } catch (error) {\n        if (isZod4Error(error)) {\n          return {\n            values: {},\n            errors: toNestErrors(\n              parseZod4Issues(\n                error.issues,\n                !options.shouldUseNativeValidation &&\n                  options.criteriaMode === 'all',\n              ),\n              options,\n            ),\n          } satisfies ResolverError<Input>;\n        }\n\n        throw error;\n      }\n    };\n  }\n\n  if (isZod3Schema(schema)) {\n    return async (values: Input, _, options) => {\n      try {\n        const data = await schema[\n          resolverOptions.mode === 'sync' ? 'parse' : 'parseAsync'\n        ](values, schemaOptions);\n\n        options.shouldUseNativeValidation &&\n          validateFieldsNatively({}, options);\n\n        return {\n          errors: {},\n          values: resolverOptions.raw ? Object.assign({}, values) : data,\n        } satisfies ResolverSuccess<Output | Input>;\n      } catch (error) {\n        if (isZod3Error(error)) {\n          return {\n            values: {},\n            errors: toNestErrors(\n              parseZod3Issues(\n                error.errors,\n                !options.shouldUseNativeValidation &&\n                  options.criteriaMode === 'all',\n              ),\n              options,\n            ),\n          } satisfies ResolverError<Input>;\n        }\n\n        throw error;\n      }\n    };\n  }\n\n  throw new Error('Invalid input: not a Zod schema');\n}\n"],"names":["parseZod3Issues","zodErrors","validateAllFieldCriteria","errors","length","error","code","message","_path","path","join","_unionError$message","_unionError$code","unionError","unionErrors","reduce","closest","current","type","forEach","e","push","types","messages","appendErrors","concat","shift","parseZod4Issues","_loop","_unionError$message2","_unionError$code2","branch","_extends","schema","schemaOptions","resolverOptions","_zod","isZod4Schema","values","_","options","Promise","resolve","_catch","_temp2","data","shouldUseNativeValidation","validateFieldsNatively","raw","Object","assign","classicSchema","mode","parse","parseAsync","then","z4","$ZodError","isZod4Error","toNestErrors","issues","criteriaMode","reject","_def","isZod3Schema","Array","isArray","isZod3Error","Error"],"mappings":"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"}
+{"version":3,"file":"zod.js","sources":["../src/zod.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport {\n  FieldError,\n  FieldValues,\n  Resolver,\n  ResolverError,\n  ResolverSuccess,\n  appendErrors,\n} from 'react-hook-form';\n// Type-only: these subpaths don't exist before zod@3.25.0, so importing them\n// as values would break resolution for anyone on an older zod 3.x. `import\n// type` is fully erased at build time, so the compiled output never\n// references these subpaths at runtime — see `isZod4Error` below for how the\n// one runtime check that used to need `z4.$ZodError` avoids that now.\nimport type * as z3 from 'zod/v3';\nimport type * as z4 from 'zod/v4/core';\n\nconst isZod3Error = (error: any): error is z3.ZodError => {\n  return Array.isArray(error?.issues);\n};\nconst isZod3Schema = (schema: any): schema is z3.ZodSchema => {\n  // Deliberately doesn't require `typeName` in `_def` — dynamically selected\n  // schemas typed via the generic `z.ZodType<Output>` annotation (rather than\n  // a concrete subclass like `ZodObject`) don't statically expose `typeName`,\n  // even though they're genuine Zod 3 schema instances at runtime.\n  return '_def' in schema && typeof schema._def === 'object';\n};\nconst isZod4Error = (error: any): error is z4.$ZodError => {\n  // Replicates zod4's own `$ZodError`/`Symbol.hasInstance` check\n  // (`inst?._zod?.traits?.has(name)`, see zod's `$constructor` in\n  // `v4/core/core.ts`) by hand rather than importing `$ZodError` as a value,\n  // since that import only exists in zod@3.25.0+ (see the `import type` note\n  // above).\n  return !!error?._zod?.traits?.has('$ZodError');\n};\nconst isZod4Schema = (schema: any): schema is z4.$ZodType => {\n  return '_zod' in schema && typeof schema._zod === 'object';\n};\n\nfunction parseZod3Issues(\n  zodErrors: z3.ZodIssue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n  for (; zodErrors.length; ) {\n    const error = zodErrors[0];\n    const { code, message, path } = error;\n    const _path = path.join('.');\n\n    if (!errors[_path]) {\n      if ('unionErrors' in error) {\n        // Surface the error from whichever union member came closest to\n        // matching (fewest issues), rather than always the first member —\n        // the first member isn't necessarily the one the input was meant for.\n        const closestUnionError = error.unionErrors.reduce(\n          (closest, current) =>\n            current.errors.length < closest.errors.length ? current : closest,\n        );\n        // Fall back to the union issue's own message/code if the closest\n        // member somehow has no issues of its own (shouldn't happen, but\n        // avoids ever throwing on an unexpected/malformed union shape).\n        const unionError = closestUnionError.errors[0];\n\n        errors[_path] = {\n          message: unionError?.message ?? message,\n          type: unionError?.code ?? code,\n        };\n      } else {\n        errors[_path] = { message, type: code };\n      }\n    }\n\n    if ('unionErrors' in error) {\n      error.unionErrors.forEach((unionError) =>\n        unionError.errors.forEach((e) => zodErrors.push(e)),\n      );\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types[error.code];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        code,\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    zodErrors.shift();\n  }\n\n  return errors;\n}\n\nfunction parseZod4Issues(\n  zodErrors: z4.$ZodIssue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n  // const _zodErrors = zodErrors as z4.$ZodISsue; //\n  for (; zodErrors.length; ) {\n    const error = zodErrors[0];\n    const { code, message, path } = error;\n    const _path = path.join('.');\n\n    if (!errors[_path]) {\n      if (error.code === 'invalid_union' && error.errors.length > 0) {\n        // Surface the error from whichever union member came closest to\n        // matching (fewest issues), rather than always the first member —\n        // the first member isn't necessarily the one the input was meant for.\n        const closestBranch = error.errors.reduce((closest, branch) =>\n          branch.length < closest.length ? branch : closest,\n        );\n        // Fall back to the union issue's own message/code if the closest\n        // branch somehow has no issues of its own (shouldn't happen — a\n        // 0-issue branch means that branch matched — but this guarantees we\n        // never throw on an unexpected/malformed union shape, e.g. a \"no\n        // matching discriminator\" issue nested in a way we haven't seen).\n        const unionError = closestBranch[0];\n\n        errors[_path] = {\n          message: unionError?.message ?? message,\n          type: unionError?.code ?? code,\n        };\n      } else {\n        errors[_path] = { message, type: code };\n      }\n    }\n\n    if (error.code === 'invalid_union') {\n      error.errors.forEach((unionError) =>\n        unionError.forEach((e) =>\n          zodErrors.push({ ...e, path: [...error.path, ...e.path] }),\n        ),\n      );\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types[error.code];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        code,\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    zodErrors.shift();\n  }\n\n  return errors;\n}\n\ntype RawResolverOptions = {\n  mode?: 'async' | 'sync';\n  raw: true;\n};\ntype NonRawResolverOptions = {\n  mode?: 'async' | 'sync';\n  raw?: false;\n};\n\n// minimal interfaces to avoid asssignability issues between versions\ninterface Zod3Type<O = unknown, I = unknown> {\n  _output: O;\n  _input: I;\n  _def: object;\n}\n\n// minimal interface to avoid assignability issues between zod v4 patch/minor\n// releases, which brand the full `$ZodType` shape with an exact version literal\n// (e.g. `_zod.version.minor`)\ninterface Zod4Type<Output = unknown, Input = unknown> {\n  _zod: {\n    output: Output;\n    input: Input;\n  };\n}\n\n// some type magic to make versions pre-3.25.0 still work\ntype IsUnresolved<T> = PropertyKey extends keyof T ? true : false;\ntype UnresolvedFallback<T, Fallback> = IsUnresolved<typeof z3> extends true\n  ? Fallback\n  : T;\ntype FallbackIssue = {\n  code: string;\n  message: string;\n  path: (string | number)[];\n};\ntype Zod3ParseParams = UnresolvedFallback<\n  z3.ParseParams,\n  // fallback if user is on <3.25.0\n  {\n    path?: (string | number)[];\n    errorMap?: (\n      iss: FallbackIssue,\n      ctx: {\n        defaultError: string;\n        data: any;\n      },\n    ) => { message: string };\n    async?: boolean;\n  }\n>;\ntype Zod4ParseParams = UnresolvedFallback<\n  z4.ParseContext<z4.$ZodIssue>,\n  // fallback if user is on <3.25.0\n  {\n    readonly error?: (\n      iss: FallbackIssue,\n    ) => null | undefined | string | { message: string };\n    readonly reportInput?: boolean;\n    readonly jitless?: boolean;\n  }\n>;\n\nexport function zodResolver<Input extends FieldValues, Context, Output>(\n  schema: Zod3Type<Output, Input>,\n  schemaOptions?: Zod3ParseParams,\n  resolverOptions?: NonRawResolverOptions,\n): Resolver<Input, Context, Output>;\nexport function zodResolver<Input extends FieldValues, Context, Output>(\n  schema: Zod3Type<Output, Input>,\n  schemaOptions: Zod3ParseParams | undefined,\n  resolverOptions: RawResolverOptions,\n): Resolver<Input, Context, Input>;\n// the Zod 4 overloads need to be generic for complicated reasons\nexport function zodResolver<\n  Input extends FieldValues,\n  Context,\n  Output,\n  T extends Zod4Type<Output, Input> = Zod4Type<Output, Input>,\n>(\n  schema: T,\n  schemaOptions?: Zod4ParseParams, // already partial\n  resolverOptions?: NonRawResolverOptions,\n): Resolver<z4.input<T>, Context, z4.output<T>>;\nexport function zodResolver<\n  Input extends FieldValues,\n  Context,\n  Output,\n  T extends Zod4Type<Output, Input> = Zod4Type<Output, Input>,\n>(\n  schema: Zod4Type<Output, Input>,\n  schemaOptions: Zod4ParseParams | undefined, // already partial\n  resolverOptions: RawResolverOptions,\n): Resolver<z4.input<T>, Context, z4.input<T>>;\n/**\n * Creates a resolver function for react-hook-form that validates form data using a Zod schema\n * @param {z3.ZodSchema<Input>} schema - The Zod schema used to validate the form data\n * @param {Partial<z3.ParseParams>} [schemaOptions] - Optional configuration options for Zod parsing\n * @param {Object} [resolverOptions] - Optional resolver-specific configuration\n * @param {('async'|'sync')} [resolverOptions.mode='async'] - Validation mode. Use 'sync' for synchronous validation\n * @param {boolean} [resolverOptions.raw=false] - If true, returns the raw form values instead of the parsed data\n * @returns {Resolver<z3.output<typeof schema>>} A resolver function compatible with react-hook-form\n * @throws {Error} Throws if validation fails with a non-Zod error\n * @example\n * const schema = z3.object({\n *   name: z3.string().min(2),\n *   age: z3.number().min(18)\n * });\n *\n * useForm({\n *   resolver: zodResolver(schema)\n * });\n */\nexport function zodResolver<Input extends FieldValues, Context, Output>(\n  schema: object,\n  schemaOptions?: object,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Output | Input> {\n  // Zod 4 is checked first: its `_zod` marker is unambiguous, whereas the\n  // Zod 3 check below only requires an object-shaped `_def` (to support\n  // dynamically-selected schemas typed via the generic `z.ZodType<Output>`\n  // annotation, see `isZod3Schema`) — and Zod 4 schemas also have an\n  // object-shaped `_def`, so they'd otherwise be misdetected as Zod 3.\n  if (isZod4Schema(schema)) {\n    return async (values: Input, _, options) => {\n      try {\n        // Call the schema's own bound `parse`/`parseAsync` method rather\n        // than the standalone `z4.parse`/`z4.parseAsync` functions. Those\n        // standalone functions read from this module's own imported\n        // `zod/v4/core`, which — under bundlers that can resolve `zod` and\n        // `zod/v4/core` to two distinct module instances (e.g. Metro with\n        // package-exports resolution enabled) — may not be the same zod\n        // instance the schema was created with, silently dropping any\n        // global config (`z.config()`) or locale the app configured on its\n        // own zod instance. The schema's own method is always bound to\n        // whichever zod instance actually created it.\n        const classicSchema = schema as unknown as {\n          parse: (values: unknown, schemaOptions: unknown) => unknown;\n          parseAsync: (\n            values: unknown,\n            schemaOptions: unknown,\n          ) => Promise<unknown>;\n        };\n        const data: any =\n          resolverOptions.mode === 'sync'\n            ? classicSchema.parse(values, schemaOptions)\n            : await classicSchema.parseAsync(values, schemaOptions);\n\n        options.shouldUseNativeValidation &&\n          validateFieldsNatively({}, options);\n\n        return {\n          errors: {},\n          values: resolverOptions.raw ? Object.assign({}, values) : data,\n        } satisfies ResolverSuccess<Output | Input>;\n      } catch (error) {\n        if (isZod4Error(error)) {\n          return {\n            values: {},\n            errors: toNestErrors(\n              parseZod4Issues(\n                error.issues,\n                !options.shouldUseNativeValidation &&\n                  options.criteriaMode === 'all',\n              ),\n              options,\n            ),\n          } satisfies ResolverError<Input>;\n        }\n\n        throw error;\n      }\n    };\n  }\n\n  if (isZod3Schema(schema)) {\n    return async (values: Input, _, options) => {\n      try {\n        const data = await schema[\n          resolverOptions.mode === 'sync' ? 'parse' : 'parseAsync'\n        ](values, schemaOptions);\n\n        options.shouldUseNativeValidation &&\n          validateFieldsNatively({}, options);\n\n        return {\n          errors: {},\n          values: resolverOptions.raw ? Object.assign({}, values) : data,\n        } satisfies ResolverSuccess<Output | Input>;\n      } catch (error) {\n        if (isZod3Error(error)) {\n          return {\n            values: {},\n            errors: toNestErrors(\n              parseZod3Issues(\n                error.errors,\n                !options.shouldUseNativeValidation &&\n                  options.criteriaMode === 'all',\n              ),\n              options,\n            ),\n          } satisfies ResolverError<Input>;\n        }\n\n        throw error;\n      }\n    };\n  }\n\n  throw new Error('Invalid input: not a Zod schema');\n}\n"],"names":["parseZod3Issues","zodErrors","validateAllFieldCriteria","errors","length","error","code","message","_path","path","join","_unionError$message","_unionError$code","unionError","unionErrors","reduce","closest","current","type","forEach","e","push","types","messages","appendErrors","concat","shift","parseZod4Issues","_loop","_unionError$message2","_unionError$code2","branch","_extends","schema","schemaOptions","resolverOptions","_zod","isZod4Schema","values","_","options","Promise","resolve","_catch","_temp2","data","shouldUseNativeValidation","validateFieldsNatively","raw","Object","assign","classicSchema","mode","parse","parseAsync","then","_error$_zod","traits","has","isZod4Error","toNestErrors","issues","criteriaMode","reject","_def","isZod3Schema","Array","isArray","isZod3Error","Error"],"mappings":"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"}

package/zod/dist/zod.mjs

@@ -1,2 +1,2 @@
-import{validateFieldsNatively as r,toNestErrors as e}from"@hookform/resolvers";import{appendErrors as n}from"react-hook-form";import*as o from"zod/v4/core";function t(){return t=Object.assign?Object.assign.bind():function(r){for(var e=1;e<arguments.length;e++){var n=arguments[e];for(var o in n)({}).hasOwnProperty.call(n,o)&&(r[o]=n[o])}return r},t.apply(null,arguments)}function s(r,e){try{var n=r()}catch(r){return e(r)}return n&&n.then?n.then(void 0,e):n}function i(r,e){for(var o={};r.length;){var t=r[0],s=t.code,i=t.message,u=t.path.join(".");if(!o[u])if("unionErrors"in t){var a,c,l=t.unionErrors.reduce(function(r,e){return e.errors.length<r.errors.length?e:r}).errors[0];o[u]={message:null!=(a=null==l?void 0:l.message)?a:i,type:null!=(c=null==l?void 0:l.code)?c:s}}else o[u]={message:i,type:s};if("unionErrors"in t&&t.unionErrors.forEach(function(e){return e.errors.forEach(function(e){return r.push(e)})}),e){var f=o[u].types,d=f&&f[t.code];o[u]=n(u,e,o,s,d?[].concat(d,t.message):t.message)}r.shift()}return o}function u(r,e){for(var o={},s=function(){var s=r[0],i=s.code,u=s.message,a=s.path.join(".");if(!o[a])if("invalid_union"===s.code&&s.errors.length>0){var c,l,f=s.errors.reduce(function(r,e){return e.length<r.length?e:r})[0];o[a]={message:null!=(c=null==f?void 0:f.message)?c:u,type:null!=(l=null==f?void 0:f.code)?l:i}}else o[a]={message:u,type:i};if("invalid_union"===s.code&&s.errors.forEach(function(e){return e.forEach(function(e){return r.push(t({},e,{path:[].concat(s.path,e.path)}))})}),e){var d=o[a].types,h=d&&d[s.code];o[a]=n(a,e,o,i,h?[].concat(h,s.message):s.message)}r.shift()};r.length;)s();return o}function a(n,t,a){if(void 0===a&&(a={}),function(r){return"_zod"in r&&"object"==typeof r._zod}(n))return function(i,c,l){try{return Promise.resolve(s(function(){function e(e){return l.shouldUseNativeValidation&&r({},l),{errors:{},values:a.raw?Object.assign({},i):e}}var o=n;return"sync"===a.mode?e(o.parse(i,t)):Promise.resolve(o.parseAsync(i,t)).then(e)},function(r){if(function(r){return r instanceof o.$ZodError}(r))return{values:{},errors:e(u(r.issues,!l.shouldUseNativeValidation&&"all"===l.criteriaMode),l)};throw r}))}catch(r){return Promise.reject(r)}};if(function(r){return"_def"in r&&"object"==typeof r._def}(n))return function(o,u,c){try{return Promise.resolve(s(function(){return Promise.resolve(n["sync"===a.mode?"parse":"parseAsync"](o,t)).then(function(e){return c.shouldUseNativeValidation&&r({},c),{errors:{},values:a.raw?Object.assign({},o):e}})},function(r){if(function(r){return Array.isArray(null==r?void 0:r.issues)}(r))return{values:{},errors:e(i(r.errors,!c.shouldUseNativeValidation&&"all"===c.criteriaMode),c)};throw r}))}catch(r){return Promise.reject(r)}};throw new Error("Invalid input: not a Zod schema")}export{a as zodResolver};
+import{validateFieldsNatively as r,toNestErrors as e}from"@hookform/resolvers";import{appendErrors as n}from"react-hook-form";function o(){return o=Object.assign?Object.assign.bind():function(r){for(var e=1;e<arguments.length;e++){var n=arguments[e];for(var o in n)({}).hasOwnProperty.call(n,o)&&(r[o]=n[o])}return r},o.apply(null,arguments)}function t(r,e){try{var n=r()}catch(r){return e(r)}return n&&n.then?n.then(void 0,e):n}function s(r,e){for(var o={};r.length;){var t=r[0],s=t.code,i=t.message,u=t.path.join(".");if(!o[u])if("unionErrors"in t){var a,c,l=t.unionErrors.reduce(function(r,e){return e.errors.length<r.errors.length?e:r}).errors[0];o[u]={message:null!=(a=null==l?void 0:l.message)?a:i,type:null!=(c=null==l?void 0:l.code)?c:s}}else o[u]={message:i,type:s};if("unionErrors"in t&&t.unionErrors.forEach(function(e){return e.errors.forEach(function(e){return r.push(e)})}),e){var f=o[u].types,d=f&&f[t.code];o[u]=n(u,e,o,s,d?[].concat(d,t.message):t.message)}r.shift()}return o}function i(r,e){for(var t={},s=function(){var s=r[0],i=s.code,u=s.message,a=s.path.join(".");if(!t[a])if("invalid_union"===s.code&&s.errors.length>0){var c,l,f=s.errors.reduce(function(r,e){return e.length<r.length?e:r})[0];t[a]={message:null!=(c=null==f?void 0:f.message)?c:u,type:null!=(l=null==f?void 0:f.code)?l:i}}else t[a]={message:u,type:i};if("invalid_union"===s.code&&s.errors.forEach(function(e){return e.forEach(function(e){return r.push(o({},e,{path:[].concat(s.path,e.path)}))})}),e){var d=t[a].types,h=d&&d[s.code];t[a]=n(a,e,t,i,h?[].concat(h,s.message):s.message)}r.shift()};r.length;)s();return t}function u(n,o,u){if(void 0===u&&(u={}),function(r){return"_zod"in r&&"object"==typeof r._zod}(n))return function(s,a,c){try{return Promise.resolve(t(function(){function e(e){return c.shouldUseNativeValidation&&r({},c),{errors:{},values:u.raw?Object.assign({},s):e}}var t=n;return"sync"===u.mode?e(t.parse(s,o)):Promise.resolve(t.parseAsync(s,o)).then(e)},function(r){if(function(r){var e;return!(null==r||null==(e=r._zod)||null==(e=e.traits)||!e.has("$ZodError"))}(r))return{values:{},errors:e(i(r.issues,!c.shouldUseNativeValidation&&"all"===c.criteriaMode),c)};throw r}))}catch(r){return Promise.reject(r)}};if(function(r){return"_def"in r&&"object"==typeof r._def}(n))return function(i,a,c){try{return Promise.resolve(t(function(){return Promise.resolve(n["sync"===u.mode?"parse":"parseAsync"](i,o)).then(function(e){return c.shouldUseNativeValidation&&r({},c),{errors:{},values:u.raw?Object.assign({},i):e}})},function(r){if(function(r){return Array.isArray(null==r?void 0:r.issues)}(r))return{values:{},errors:e(s(r.errors,!c.shouldUseNativeValidation&&"all"===c.criteriaMode),c)};throw r}))}catch(r){return Promise.reject(r)}};throw new Error("Invalid input: not a Zod schema")}export{u as zodResolver};
 //# sourceMappingURL=zod.module.js.map

package/zod/dist/zod.modern.mjs

@@ -1,2 +1,2 @@
-import{validateFieldsNatively as r,toNestErrors as e}from"@hookform/resolvers";import{appendErrors as o}from"react-hook-form";import*as s from"zod/v4/core";function n(){return n=Object.assign?Object.assign.bind():function(r){for(var e=1;e<arguments.length;e++){var o=arguments[e];for(var s in o)({}).hasOwnProperty.call(o,s)&&(r[s]=o[s])}return r},n.apply(null,arguments)}function t(r,e){const s={};for(;r.length;){const a=r[0],{code:i,message:c,path:l}=a,u=l.join(".");if(!s[u])if("unionErrors"in a){var n,t;const r=a.unionErrors.reduce((r,e)=>e.errors.length<r.errors.length?e:r).errors[0];s[u]={message:null!=(n=null==r?void 0:r.message)?n:c,type:null!=(t=null==r?void 0:r.code)?t:i}}else s[u]={message:c,type:i};if("unionErrors"in a&&a.unionErrors.forEach(e=>e.errors.forEach(e=>r.push(e))),e){const r=s[u].types,n=r&&r[a.code];s[u]=o(u,e,s,i,n?[].concat(n,a.message):a.message)}r.shift()}return s}function a(r,e){const s={};for(;r.length;){const i=r[0],{code:c,message:l,path:u}=i,d=u.join(".");if(!s[d])if("invalid_union"===i.code&&i.errors.length>0){var t,a;const r=i.errors.reduce((r,e)=>e.length<r.length?e:r)[0];s[d]={message:null!=(t=null==r?void 0:r.message)?t:l,type:null!=(a=null==r?void 0:r.code)?a:c}}else s[d]={message:l,type:c};if("invalid_union"===i.code&&i.errors.forEach(e=>e.forEach(e=>r.push(n({},e,{path:[...i.path,...e.path]})))),e){const r=s[d].types,n=r&&r[i.code];s[d]=o(d,e,s,c,n?[].concat(n,i.message):i.message)}r.shift()}return s}function i(o,n,i={}){if((r=>"_zod"in r&&"object"==typeof r._zod)(o))return async(t,c,l)=>{try{const e=o,s="sync"===i.mode?e.parse(t,n):await e.parseAsync(t,n);return l.shouldUseNativeValidation&&r({},l),{errors:{},values:i.raw?Object.assign({},t):s}}catch(r){if((r=>r instanceof s.$ZodError)(r))return{values:{},errors:e(a(r.issues,!l.shouldUseNativeValidation&&"all"===l.criteriaMode),l)};throw r}};if((r=>"_def"in r&&"object"==typeof r._def)(o))return async(s,a,c)=>{try{const e=await o["sync"===i.mode?"parse":"parseAsync"](s,n);return c.shouldUseNativeValidation&&r({},c),{errors:{},values:i.raw?Object.assign({},s):e}}catch(r){if((r=>Array.isArray(null==r?void 0:r.issues))(r))return{values:{},errors:e(t(r.errors,!c.shouldUseNativeValidation&&"all"===c.criteriaMode),c)};throw r}};throw new Error("Invalid input: not a Zod schema")}export{i as zodResolver};
+import{validateFieldsNatively as r,toNestErrors as e}from"@hookform/resolvers";import{appendErrors as o}from"react-hook-form";function s(){return s=Object.assign?Object.assign.bind():function(r){for(var e=1;e<arguments.length;e++){var o=arguments[e];for(var s in o)({}).hasOwnProperty.call(o,s)&&(r[s]=o[s])}return r},s.apply(null,arguments)}function n(r,e){const s={};for(;r.length;){const a=r[0],{code:i,message:l,path:c}=a,u=c.join(".");if(!s[u])if("unionErrors"in a){var n,t;const r=a.unionErrors.reduce((r,e)=>e.errors.length<r.errors.length?e:r).errors[0];s[u]={message:null!=(n=null==r?void 0:r.message)?n:l,type:null!=(t=null==r?void 0:r.code)?t:i}}else s[u]={message:l,type:i};if("unionErrors"in a&&a.unionErrors.forEach(e=>e.errors.forEach(e=>r.push(e))),e){const r=s[u].types,n=r&&r[a.code];s[u]=o(u,e,s,i,n?[].concat(n,a.message):a.message)}r.shift()}return s}function t(r,e){const n={};for(;r.length;){const i=r[0],{code:l,message:c,path:u}=i,d=u.join(".");if(!n[d])if("invalid_union"===i.code&&i.errors.length>0){var t,a;const r=i.errors.reduce((r,e)=>e.length<r.length?e:r)[0];n[d]={message:null!=(t=null==r?void 0:r.message)?t:c,type:null!=(a=null==r?void 0:r.code)?a:l}}else n[d]={message:c,type:l};if("invalid_union"===i.code&&i.errors.forEach(e=>e.forEach(e=>r.push(s({},e,{path:[...i.path,...e.path]})))),e){const r=n[d].types,s=r&&r[i.code];n[d]=o(d,e,n,l,s?[].concat(s,i.message):i.message)}r.shift()}return n}function a(o,s,a={}){if((r=>"_zod"in r&&"object"==typeof r._zod)(o))return async(n,i,l)=>{try{const e=o,t="sync"===a.mode?e.parse(n,s):await e.parseAsync(n,s);return l.shouldUseNativeValidation&&r({},l),{errors:{},values:a.raw?Object.assign({},n):t}}catch(r){if((r=>{var e;return!(null==r||null==(e=r._zod)||null==(e=e.traits)||!e.has("$ZodError"))})(r))return{values:{},errors:e(t(r.issues,!l.shouldUseNativeValidation&&"all"===l.criteriaMode),l)};throw r}};if((r=>"_def"in r&&"object"==typeof r._def)(o))return async(t,i,l)=>{try{const e=await o["sync"===a.mode?"parse":"parseAsync"](t,s);return l.shouldUseNativeValidation&&r({},l),{errors:{},values:a.raw?Object.assign({},t):e}}catch(r){if((r=>Array.isArray(null==r?void 0:r.issues))(r))return{values:{},errors:e(n(r.errors,!l.shouldUseNativeValidation&&"all"===l.criteriaMode),l)};throw r}};throw new Error("Invalid input: not a Zod schema")}export{a as zodResolver};
 //# sourceMappingURL=zod.modern.mjs.map

package/zod/dist/zod.modern.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"zod.modern.mjs","sources":["../src/zod.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport {\n  FieldError,\n  FieldValues,\n  Resolver,\n  ResolverError,\n  ResolverSuccess,\n  appendErrors,\n} from 'react-hook-form';\nimport * as z3 from 'zod/v3';\nimport * as z4 from 'zod/v4/core';\n\nconst isZod3Error = (error: any): error is z3.ZodError => {\n  return Array.isArray(error?.issues);\n};\nconst isZod3Schema = (schema: any): schema is z3.ZodSchema => {\n  // Deliberately doesn't require `typeName` in `_def` — dynamically selected\n  // schemas typed via the generic `z.ZodType<Output>` annotation (rather than\n  // a concrete subclass like `ZodObject`) don't statically expose `typeName`,\n  // even though they're genuine Zod 3 schema instances at runtime.\n  return '_def' in schema && typeof schema._def === 'object';\n};\nconst isZod4Error = (error: any): error is z4.$ZodError => {\n  // instanceof is safe in Zod 4 (uses Symbol.hasInstance)\n  return error instanceof z4.$ZodError;\n};\nconst isZod4Schema = (schema: any): schema is z4.$ZodType => {\n  return '_zod' in schema && typeof schema._zod === 'object';\n};\n\nfunction parseZod3Issues(\n  zodErrors: z3.ZodIssue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n  for (; zodErrors.length; ) {\n    const error = zodErrors[0];\n    const { code, message, path } = error;\n    const _path = path.join('.');\n\n    if (!errors[_path]) {\n      if ('unionErrors' in error) {\n        // Surface the error from whichever union member came closest to\n        // matching (fewest issues), rather than always the first member —\n        // the first member isn't necessarily the one the input was meant for.\n        const closestUnionError = error.unionErrors.reduce(\n          (closest, current) =>\n            current.errors.length < closest.errors.length ? current : closest,\n        );\n        // Fall back to the union issue's own message/code if the closest\n        // member somehow has no issues of its own (shouldn't happen, but\n        // avoids ever throwing on an unexpected/malformed union shape).\n        const unionError = closestUnionError.errors[0];\n\n        errors[_path] = {\n          message: unionError?.message ?? message,\n          type: unionError?.code ?? code,\n        };\n      } else {\n        errors[_path] = { message, type: code };\n      }\n    }\n\n    if ('unionErrors' in error) {\n      error.unionErrors.forEach((unionError) =>\n        unionError.errors.forEach((e) => zodErrors.push(e)),\n      );\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types[error.code];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        code,\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    zodErrors.shift();\n  }\n\n  return errors;\n}\n\nfunction parseZod4Issues(\n  zodErrors: z4.$ZodIssue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n  // const _zodErrors = zodErrors as z4.$ZodISsue; //\n  for (; zodErrors.length; ) {\n    const error = zodErrors[0];\n    const { code, message, path } = error;\n    const _path = path.join('.');\n\n    if (!errors[_path]) {\n      if (error.code === 'invalid_union' && error.errors.length > 0) {\n        // Surface the error from whichever union member came closest to\n        // matching (fewest issues), rather than always the first member —\n        // the first member isn't necessarily the one the input was meant for.\n        const closestBranch = error.errors.reduce((closest, branch) =>\n          branch.length < closest.length ? branch : closest,\n        );\n        // Fall back to the union issue's own message/code if the closest\n        // branch somehow has no issues of its own (shouldn't happen — a\n        // 0-issue branch means that branch matched — but this guarantees we\n        // never throw on an unexpected/malformed union shape, e.g. a \"no\n        // matching discriminator\" issue nested in a way we haven't seen).\n        const unionError = closestBranch[0];\n\n        errors[_path] = {\n          message: unionError?.message ?? message,\n          type: unionError?.code ?? code,\n        };\n      } else {\n        errors[_path] = { message, type: code };\n      }\n    }\n\n    if (error.code === 'invalid_union') {\n      error.errors.forEach((unionError) =>\n        unionError.forEach((e) =>\n          zodErrors.push({ ...e, path: [...error.path, ...e.path] }),\n        ),\n      );\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types[error.code];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        code,\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    zodErrors.shift();\n  }\n\n  return errors;\n}\n\ntype RawResolverOptions = {\n  mode?: 'async' | 'sync';\n  raw: true;\n};\ntype NonRawResolverOptions = {\n  mode?: 'async' | 'sync';\n  raw?: false;\n};\n\n// minimal interfaces to avoid asssignability issues between versions\ninterface Zod3Type<O = unknown, I = unknown> {\n  _output: O;\n  _input: I;\n  _def: object;\n}\n\n// minimal interface to avoid assignability issues between zod v4 patch/minor\n// releases, which brand the full `$ZodType` shape with an exact version literal\n// (e.g. `_zod.version.minor`)\ninterface Zod4Type<Output = unknown, Input = unknown> {\n  _zod: {\n    output: Output;\n    input: Input;\n  };\n}\n\n// some type magic to make versions pre-3.25.0 still work\ntype IsUnresolved<T> = PropertyKey extends keyof T ? true : false;\ntype UnresolvedFallback<T, Fallback> = IsUnresolved<typeof z3> extends true\n  ? Fallback\n  : T;\ntype FallbackIssue = {\n  code: string;\n  message: string;\n  path: (string | number)[];\n};\ntype Zod3ParseParams = UnresolvedFallback<\n  z3.ParseParams,\n  // fallback if user is on <3.25.0\n  {\n    path?: (string | number)[];\n    errorMap?: (\n      iss: FallbackIssue,\n      ctx: {\n        defaultError: string;\n        data: any;\n      },\n    ) => { message: string };\n    async?: boolean;\n  }\n>;\ntype Zod4ParseParams = UnresolvedFallback<\n  z4.ParseContext<z4.$ZodIssue>,\n  // fallback if user is on <3.25.0\n  {\n    readonly error?: (\n      iss: FallbackIssue,\n    ) => null | undefined | string | { message: string };\n    readonly reportInput?: boolean;\n    readonly jitless?: boolean;\n  }\n>;\n\nexport function zodResolver<Input extends FieldValues, Context, Output>(\n  schema: Zod3Type<Output, Input>,\n  schemaOptions?: Zod3ParseParams,\n  resolverOptions?: NonRawResolverOptions,\n): Resolver<Input, Context, Output>;\nexport function zodResolver<Input extends FieldValues, Context, Output>(\n  schema: Zod3Type<Output, Input>,\n  schemaOptions: Zod3ParseParams | undefined,\n  resolverOptions: RawResolverOptions,\n): Resolver<Input, Context, Input>;\n// the Zod 4 overloads need to be generic for complicated reasons\nexport function zodResolver<\n  Input extends FieldValues,\n  Context,\n  Output,\n  T extends Zod4Type<Output, Input> = Zod4Type<Output, Input>,\n>(\n  schema: T,\n  schemaOptions?: Zod4ParseParams, // already partial\n  resolverOptions?: NonRawResolverOptions,\n): Resolver<z4.input<T>, Context, z4.output<T>>;\nexport function zodResolver<\n  Input extends FieldValues,\n  Context,\n  Output,\n  T extends Zod4Type<Output, Input> = Zod4Type<Output, Input>,\n>(\n  schema: Zod4Type<Output, Input>,\n  schemaOptions: Zod4ParseParams | undefined, // already partial\n  resolverOptions: RawResolverOptions,\n): Resolver<z4.input<T>, Context, z4.input<T>>;\n/**\n * Creates a resolver function for react-hook-form that validates form data using a Zod schema\n * @param {z3.ZodSchema<Input>} schema - The Zod schema used to validate the form data\n * @param {Partial<z3.ParseParams>} [schemaOptions] - Optional configuration options for Zod parsing\n * @param {Object} [resolverOptions] - Optional resolver-specific configuration\n * @param {('async'|'sync')} [resolverOptions.mode='async'] - Validation mode. Use 'sync' for synchronous validation\n * @param {boolean} [resolverOptions.raw=false] - If true, returns the raw form values instead of the parsed data\n * @returns {Resolver<z3.output<typeof schema>>} A resolver function compatible with react-hook-form\n * @throws {Error} Throws if validation fails with a non-Zod error\n * @example\n * const schema = z3.object({\n *   name: z3.string().min(2),\n *   age: z3.number().min(18)\n * });\n *\n * useForm({\n *   resolver: zodResolver(schema)\n * });\n */\nexport function zodResolver<Input extends FieldValues, Context, Output>(\n  schema: object,\n  schemaOptions?: object,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Output | Input> {\n  // Zod 4 is checked first: its `_zod` marker is unambiguous, whereas the\n  // Zod 3 check below only requires an object-shaped `_def` (to support\n  // dynamically-selected schemas typed via the generic `z.ZodType<Output>`\n  // annotation, see `isZod3Schema`) — and Zod 4 schemas also have an\n  // object-shaped `_def`, so they'd otherwise be misdetected as Zod 3.\n  if (isZod4Schema(schema)) {\n    return async (values: Input, _, options) => {\n      try {\n        // Call the schema's own bound `parse`/`parseAsync` method rather\n        // than the standalone `z4.parse`/`z4.parseAsync` functions. Those\n        // standalone functions read from this module's own imported\n        // `zod/v4/core`, which — under bundlers that can resolve `zod` and\n        // `zod/v4/core` to two distinct module instances (e.g. Metro with\n        // package-exports resolution enabled) — may not be the same zod\n        // instance the schema was created with, silently dropping any\n        // global config (`z.config()`) or locale the app configured on its\n        // own zod instance. The schema's own method is always bound to\n        // whichever zod instance actually created it.\n        const classicSchema = schema as unknown as {\n          parse: (values: unknown, schemaOptions: unknown) => unknown;\n          parseAsync: (\n            values: unknown,\n            schemaOptions: unknown,\n          ) => Promise<unknown>;\n        };\n        const data: any =\n          resolverOptions.mode === 'sync'\n            ? classicSchema.parse(values, schemaOptions)\n            : await classicSchema.parseAsync(values, schemaOptions);\n\n        options.shouldUseNativeValidation &&\n          validateFieldsNatively({}, options);\n\n        return {\n          errors: {},\n          values: resolverOptions.raw ? Object.assign({}, values) : data,\n        } satisfies ResolverSuccess<Output | Input>;\n      } catch (error) {\n        if (isZod4Error(error)) {\n          return {\n            values: {},\n            errors: toNestErrors(\n              parseZod4Issues(\n                error.issues,\n                !options.shouldUseNativeValidation &&\n                  options.criteriaMode === 'all',\n              ),\n              options,\n            ),\n          } satisfies ResolverError<Input>;\n        }\n\n        throw error;\n      }\n    };\n  }\n\n  if (isZod3Schema(schema)) {\n    return async (values: Input, _, options) => {\n      try {\n        const data = await schema[\n          resolverOptions.mode === 'sync' ? 'parse' : 'parseAsync'\n        ](values, schemaOptions);\n\n        options.shouldUseNativeValidation &&\n          validateFieldsNatively({}, options);\n\n        return {\n          errors: {},\n          values: resolverOptions.raw ? Object.assign({}, values) : data,\n        } satisfies ResolverSuccess<Output | Input>;\n      } catch (error) {\n        if (isZod3Error(error)) {\n          return {\n            values: {},\n            errors: toNestErrors(\n              parseZod3Issues(\n                error.errors,\n                !options.shouldUseNativeValidation &&\n                  options.criteriaMode === 'all',\n              ),\n              options,\n            ),\n          } satisfies ResolverError<Input>;\n        }\n\n        throw error;\n      }\n    };\n  }\n\n  throw new Error('Invalid input: not a Zod schema');\n}\n"],"names":["parseZod3Issues","zodErrors","validateAllFieldCriteria","errors","length","error","code","message","path","_path","join","_unionError$message","_unionError$code","unionError","unionErrors","reduce","closest","current","type","forEach","e","push","types","messages","appendErrors","concat","shift","parseZod4Issues","_unionError$message2","_unionError$code2","branch","_extends","zodResolver","schema","schemaOptions","resolverOptions","_zod","isZod4Schema","async","values","_","options","classicSchema","data","mode","parse","parseAsync","shouldUseNativeValidation","validateFieldsNatively","raw","Object","assign","z4","$ZodError","isZod4Error","toNestErrors","issues","criteriaMode","_def","isZod3Schema","Array","isArray","isZod3Error","Error"],"mappings":"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"}
+{"version":3,"file":"zod.modern.mjs","sources":["../src/zod.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport {\n  FieldError,\n  FieldValues,\n  Resolver,\n  ResolverError,\n  ResolverSuccess,\n  appendErrors,\n} from 'react-hook-form';\n// Type-only: these subpaths don't exist before zod@3.25.0, so importing them\n// as values would break resolution for anyone on an older zod 3.x. `import\n// type` is fully erased at build time, so the compiled output never\n// references these subpaths at runtime — see `isZod4Error` below for how the\n// one runtime check that used to need `z4.$ZodError` avoids that now.\nimport type * as z3 from 'zod/v3';\nimport type * as z4 from 'zod/v4/core';\n\nconst isZod3Error = (error: any): error is z3.ZodError => {\n  return Array.isArray(error?.issues);\n};\nconst isZod3Schema = (schema: any): schema is z3.ZodSchema => {\n  // Deliberately doesn't require `typeName` in `_def` — dynamically selected\n  // schemas typed via the generic `z.ZodType<Output>` annotation (rather than\n  // a concrete subclass like `ZodObject`) don't statically expose `typeName`,\n  // even though they're genuine Zod 3 schema instances at runtime.\n  return '_def' in schema && typeof schema._def === 'object';\n};\nconst isZod4Error = (error: any): error is z4.$ZodError => {\n  // Replicates zod4's own `$ZodError`/`Symbol.hasInstance` check\n  // (`inst?._zod?.traits?.has(name)`, see zod's `$constructor` in\n  // `v4/core/core.ts`) by hand rather than importing `$ZodError` as a value,\n  // since that import only exists in zod@3.25.0+ (see the `import type` note\n  // above).\n  return !!error?._zod?.traits?.has('$ZodError');\n};\nconst isZod4Schema = (schema: any): schema is z4.$ZodType => {\n  return '_zod' in schema && typeof schema._zod === 'object';\n};\n\nfunction parseZod3Issues(\n  zodErrors: z3.ZodIssue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n  for (; zodErrors.length; ) {\n    const error = zodErrors[0];\n    const { code, message, path } = error;\n    const _path = path.join('.');\n\n    if (!errors[_path]) {\n      if ('unionErrors' in error) {\n        // Surface the error from whichever union member came closest to\n        // matching (fewest issues), rather than always the first member —\n        // the first member isn't necessarily the one the input was meant for.\n        const closestUnionError = error.unionErrors.reduce(\n          (closest, current) =>\n            current.errors.length < closest.errors.length ? current : closest,\n        );\n        // Fall back to the union issue's own message/code if the closest\n        // member somehow has no issues of its own (shouldn't happen, but\n        // avoids ever throwing on an unexpected/malformed union shape).\n        const unionError = closestUnionError.errors[0];\n\n        errors[_path] = {\n          message: unionError?.message ?? message,\n          type: unionError?.code ?? code,\n        };\n      } else {\n        errors[_path] = { message, type: code };\n      }\n    }\n\n    if ('unionErrors' in error) {\n      error.unionErrors.forEach((unionError) =>\n        unionError.errors.forEach((e) => zodErrors.push(e)),\n      );\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types[error.code];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        code,\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    zodErrors.shift();\n  }\n\n  return errors;\n}\n\nfunction parseZod4Issues(\n  zodErrors: z4.$ZodIssue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n  // const _zodErrors = zodErrors as z4.$ZodISsue; //\n  for (; zodErrors.length; ) {\n    const error = zodErrors[0];\n    const { code, message, path } = error;\n    const _path = path.join('.');\n\n    if (!errors[_path]) {\n      if (error.code === 'invalid_union' && error.errors.length > 0) {\n        // Surface the error from whichever union member came closest to\n        // matching (fewest issues), rather than always the first member —\n        // the first member isn't necessarily the one the input was meant for.\n        const closestBranch = error.errors.reduce((closest, branch) =>\n          branch.length < closest.length ? branch : closest,\n        );\n        // Fall back to the union issue's own message/code if the closest\n        // branch somehow has no issues of its own (shouldn't happen — a\n        // 0-issue branch means that branch matched — but this guarantees we\n        // never throw on an unexpected/malformed union shape, e.g. a \"no\n        // matching discriminator\" issue nested in a way we haven't seen).\n        const unionError = closestBranch[0];\n\n        errors[_path] = {\n          message: unionError?.message ?? message,\n          type: unionError?.code ?? code,\n        };\n      } else {\n        errors[_path] = { message, type: code };\n      }\n    }\n\n    if (error.code === 'invalid_union') {\n      error.errors.forEach((unionError) =>\n        unionError.forEach((e) =>\n          zodErrors.push({ ...e, path: [...error.path, ...e.path] }),\n        ),\n      );\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types[error.code];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        code,\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    zodErrors.shift();\n  }\n\n  return errors;\n}\n\ntype RawResolverOptions = {\n  mode?: 'async' | 'sync';\n  raw: true;\n};\ntype NonRawResolverOptions = {\n  mode?: 'async' | 'sync';\n  raw?: false;\n};\n\n// minimal interfaces to avoid asssignability issues between versions\ninterface Zod3Type<O = unknown, I = unknown> {\n  _output: O;\n  _input: I;\n  _def: object;\n}\n\n// minimal interface to avoid assignability issues between zod v4 patch/minor\n// releases, which brand the full `$ZodType` shape with an exact version literal\n// (e.g. `_zod.version.minor`)\ninterface Zod4Type<Output = unknown, Input = unknown> {\n  _zod: {\n    output: Output;\n    input: Input;\n  };\n}\n\n// some type magic to make versions pre-3.25.0 still work\ntype IsUnresolved<T> = PropertyKey extends keyof T ? true : false;\ntype UnresolvedFallback<T, Fallback> = IsUnresolved<typeof z3> extends true\n  ? Fallback\n  : T;\ntype FallbackIssue = {\n  code: string;\n  message: string;\n  path: (string | number)[];\n};\ntype Zod3ParseParams = UnresolvedFallback<\n  z3.ParseParams,\n  // fallback if user is on <3.25.0\n  {\n    path?: (string | number)[];\n    errorMap?: (\n      iss: FallbackIssue,\n      ctx: {\n        defaultError: string;\n        data: any;\n      },\n    ) => { message: string };\n    async?: boolean;\n  }\n>;\ntype Zod4ParseParams = UnresolvedFallback<\n  z4.ParseContext<z4.$ZodIssue>,\n  // fallback if user is on <3.25.0\n  {\n    readonly error?: (\n      iss: FallbackIssue,\n    ) => null | undefined | string | { message: string };\n    readonly reportInput?: boolean;\n    readonly jitless?: boolean;\n  }\n>;\n\nexport function zodResolver<Input extends FieldValues, Context, Output>(\n  schema: Zod3Type<Output, Input>,\n  schemaOptions?: Zod3ParseParams,\n  resolverOptions?: NonRawResolverOptions,\n): Resolver<Input, Context, Output>;\nexport function zodResolver<Input extends FieldValues, Context, Output>(\n  schema: Zod3Type<Output, Input>,\n  schemaOptions: Zod3ParseParams | undefined,\n  resolverOptions: RawResolverOptions,\n): Resolver<Input, Context, Input>;\n// the Zod 4 overloads need to be generic for complicated reasons\nexport function zodResolver<\n  Input extends FieldValues,\n  Context,\n  Output,\n  T extends Zod4Type<Output, Input> = Zod4Type<Output, Input>,\n>(\n  schema: T,\n  schemaOptions?: Zod4ParseParams, // already partial\n  resolverOptions?: NonRawResolverOptions,\n): Resolver<z4.input<T>, Context, z4.output<T>>;\nexport function zodResolver<\n  Input extends FieldValues,\n  Context,\n  Output,\n  T extends Zod4Type<Output, Input> = Zod4Type<Output, Input>,\n>(\n  schema: Zod4Type<Output, Input>,\n  schemaOptions: Zod4ParseParams | undefined, // already partial\n  resolverOptions: RawResolverOptions,\n): Resolver<z4.input<T>, Context, z4.input<T>>;\n/**\n * Creates a resolver function for react-hook-form that validates form data using a Zod schema\n * @param {z3.ZodSchema<Input>} schema - The Zod schema used to validate the form data\n * @param {Partial<z3.ParseParams>} [schemaOptions] - Optional configuration options for Zod parsing\n * @param {Object} [resolverOptions] - Optional resolver-specific configuration\n * @param {('async'|'sync')} [resolverOptions.mode='async'] - Validation mode. Use 'sync' for synchronous validation\n * @param {boolean} [resolverOptions.raw=false] - If true, returns the raw form values instead of the parsed data\n * @returns {Resolver<z3.output<typeof schema>>} A resolver function compatible with react-hook-form\n * @throws {Error} Throws if validation fails with a non-Zod error\n * @example\n * const schema = z3.object({\n *   name: z3.string().min(2),\n *   age: z3.number().min(18)\n * });\n *\n * useForm({\n *   resolver: zodResolver(schema)\n * });\n */\nexport function zodResolver<Input extends FieldValues, Context, Output>(\n  schema: object,\n  schemaOptions?: object,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Output | Input> {\n  // Zod 4 is checked first: its `_zod` marker is unambiguous, whereas the\n  // Zod 3 check below only requires an object-shaped `_def` (to support\n  // dynamically-selected schemas typed via the generic `z.ZodType<Output>`\n  // annotation, see `isZod3Schema`) — and Zod 4 schemas also have an\n  // object-shaped `_def`, so they'd otherwise be misdetected as Zod 3.\n  if (isZod4Schema(schema)) {\n    return async (values: Input, _, options) => {\n      try {\n        // Call the schema's own bound `parse`/`parseAsync` method rather\n        // than the standalone `z4.parse`/`z4.parseAsync` functions. Those\n        // standalone functions read from this module's own imported\n        // `zod/v4/core`, which — under bundlers that can resolve `zod` and\n        // `zod/v4/core` to two distinct module instances (e.g. Metro with\n        // package-exports resolution enabled) — may not be the same zod\n        // instance the schema was created with, silently dropping any\n        // global config (`z.config()`) or locale the app configured on its\n        // own zod instance. The schema's own method is always bound to\n        // whichever zod instance actually created it.\n        const classicSchema = schema as unknown as {\n          parse: (values: unknown, schemaOptions: unknown) => unknown;\n          parseAsync: (\n            values: unknown,\n            schemaOptions: unknown,\n          ) => Promise<unknown>;\n        };\n        const data: any =\n          resolverOptions.mode === 'sync'\n            ? classicSchema.parse(values, schemaOptions)\n            : await classicSchema.parseAsync(values, schemaOptions);\n\n        options.shouldUseNativeValidation &&\n          validateFieldsNatively({}, options);\n\n        return {\n          errors: {},\n          values: resolverOptions.raw ? Object.assign({}, values) : data,\n        } satisfies ResolverSuccess<Output | Input>;\n      } catch (error) {\n        if (isZod4Error(error)) {\n          return {\n            values: {},\n            errors: toNestErrors(\n              parseZod4Issues(\n                error.issues,\n                !options.shouldUseNativeValidation &&\n                  options.criteriaMode === 'all',\n              ),\n              options,\n            ),\n          } satisfies ResolverError<Input>;\n        }\n\n        throw error;\n      }\n    };\n  }\n\n  if (isZod3Schema(schema)) {\n    return async (values: Input, _, options) => {\n      try {\n        const data = await schema[\n          resolverOptions.mode === 'sync' ? 'parse' : 'parseAsync'\n        ](values, schemaOptions);\n\n        options.shouldUseNativeValidation &&\n          validateFieldsNatively({}, options);\n\n        return {\n          errors: {},\n          values: resolverOptions.raw ? Object.assign({}, values) : data,\n        } satisfies ResolverSuccess<Output | Input>;\n      } catch (error) {\n        if (isZod3Error(error)) {\n          return {\n            values: {},\n            errors: toNestErrors(\n              parseZod3Issues(\n                error.errors,\n                !options.shouldUseNativeValidation &&\n                  options.criteriaMode === 'all',\n              ),\n              options,\n            ),\n          } satisfies ResolverError<Input>;\n        }\n\n        throw error;\n      }\n    };\n  }\n\n  throw new Error('Invalid input: not a Zod schema');\n}\n"],"names":["parseZod3Issues","zodErrors","validateAllFieldCriteria","errors","length","error","code","message","path","_path","join","_unionError$message","_unionError$code","unionError","unionErrors","reduce","closest","current","type","forEach","e","push","types","messages","appendErrors","concat","shift","parseZod4Issues","_unionError$message2","_unionError$code2","branch","_extends","zodResolver","schema","schemaOptions","resolverOptions","_zod","isZod4Schema","values","_","options","classicSchema","data","mode","parse","parseAsync","shouldUseNativeValidation","validateFieldsNatively","raw","Object","assign","_error$_zod","traits","has","isZod4Error","toNestErrors","issues","criteriaMode","_def","isZod3Schema","async","Array","isArray","isZod3Error","Error"],"mappings":"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"}

package/zod/dist/zod.module.js

@@ -1,2 +1,2 @@
-import{validateFieldsNatively as r,toNestErrors as e}from"@hookform/resolvers";import{appendErrors as n}from"react-hook-form";import*as o from"zod/v4/core";function t(){return t=Object.assign?Object.assign.bind():function(r){for(var e=1;e<arguments.length;e++){var n=arguments[e];for(var o in n)({}).hasOwnProperty.call(n,o)&&(r[o]=n[o])}return r},t.apply(null,arguments)}function s(r,e){try{var n=r()}catch(r){return e(r)}return n&&n.then?n.then(void 0,e):n}function i(r,e){for(var o={};r.length;){var t=r[0],s=t.code,i=t.message,u=t.path.join(".");if(!o[u])if("unionErrors"in t){var a,c,l=t.unionErrors.reduce(function(r,e){return e.errors.length<r.errors.length?e:r}).errors[0];o[u]={message:null!=(a=null==l?void 0:l.message)?a:i,type:null!=(c=null==l?void 0:l.code)?c:s}}else o[u]={message:i,type:s};if("unionErrors"in t&&t.unionErrors.forEach(function(e){return e.errors.forEach(function(e){return r.push(e)})}),e){var f=o[u].types,d=f&&f[t.code];o[u]=n(u,e,o,s,d?[].concat(d,t.message):t.message)}r.shift()}return o}function u(r,e){for(var o={},s=function(){var s=r[0],i=s.code,u=s.message,a=s.path.join(".");if(!o[a])if("invalid_union"===s.code&&s.errors.length>0){var c,l,f=s.errors.reduce(function(r,e){return e.length<r.length?e:r})[0];o[a]={message:null!=(c=null==f?void 0:f.message)?c:u,type:null!=(l=null==f?void 0:f.code)?l:i}}else o[a]={message:u,type:i};if("invalid_union"===s.code&&s.errors.forEach(function(e){return e.forEach(function(e){return r.push(t({},e,{path:[].concat(s.path,e.path)}))})}),e){var d=o[a].types,h=d&&d[s.code];o[a]=n(a,e,o,i,h?[].concat(h,s.message):s.message)}r.shift()};r.length;)s();return o}function a(n,t,a){if(void 0===a&&(a={}),function(r){return"_zod"in r&&"object"==typeof r._zod}(n))return function(i,c,l){try{return Promise.resolve(s(function(){function e(e){return l.shouldUseNativeValidation&&r({},l),{errors:{},values:a.raw?Object.assign({},i):e}}var o=n;return"sync"===a.mode?e(o.parse(i,t)):Promise.resolve(o.parseAsync(i,t)).then(e)},function(r){if(function(r){return r instanceof o.$ZodError}(r))return{values:{},errors:e(u(r.issues,!l.shouldUseNativeValidation&&"all"===l.criteriaMode),l)};throw r}))}catch(r){return Promise.reject(r)}};if(function(r){return"_def"in r&&"object"==typeof r._def}(n))return function(o,u,c){try{return Promise.resolve(s(function(){return Promise.resolve(n["sync"===a.mode?"parse":"parseAsync"](o,t)).then(function(e){return c.shouldUseNativeValidation&&r({},c),{errors:{},values:a.raw?Object.assign({},o):e}})},function(r){if(function(r){return Array.isArray(null==r?void 0:r.issues)}(r))return{values:{},errors:e(i(r.errors,!c.shouldUseNativeValidation&&"all"===c.criteriaMode),c)};throw r}))}catch(r){return Promise.reject(r)}};throw new Error("Invalid input: not a Zod schema")}export{a as zodResolver};
+import{validateFieldsNatively as r,toNestErrors as e}from"@hookform/resolvers";import{appendErrors as n}from"react-hook-form";function o(){return o=Object.assign?Object.assign.bind():function(r){for(var e=1;e<arguments.length;e++){var n=arguments[e];for(var o in n)({}).hasOwnProperty.call(n,o)&&(r[o]=n[o])}return r},o.apply(null,arguments)}function t(r,e){try{var n=r()}catch(r){return e(r)}return n&&n.then?n.then(void 0,e):n}function s(r,e){for(var o={};r.length;){var t=r[0],s=t.code,i=t.message,u=t.path.join(".");if(!o[u])if("unionErrors"in t){var a,c,l=t.unionErrors.reduce(function(r,e){return e.errors.length<r.errors.length?e:r}).errors[0];o[u]={message:null!=(a=null==l?void 0:l.message)?a:i,type:null!=(c=null==l?void 0:l.code)?c:s}}else o[u]={message:i,type:s};if("unionErrors"in t&&t.unionErrors.forEach(function(e){return e.errors.forEach(function(e){return r.push(e)})}),e){var f=o[u].types,d=f&&f[t.code];o[u]=n(u,e,o,s,d?[].concat(d,t.message):t.message)}r.shift()}return o}function i(r,e){for(var t={},s=function(){var s=r[0],i=s.code,u=s.message,a=s.path.join(".");if(!t[a])if("invalid_union"===s.code&&s.errors.length>0){var c,l,f=s.errors.reduce(function(r,e){return e.length<r.length?e:r})[0];t[a]={message:null!=(c=null==f?void 0:f.message)?c:u,type:null!=(l=null==f?void 0:f.code)?l:i}}else t[a]={message:u,type:i};if("invalid_union"===s.code&&s.errors.forEach(function(e){return e.forEach(function(e){return r.push(o({},e,{path:[].concat(s.path,e.path)}))})}),e){var d=t[a].types,h=d&&d[s.code];t[a]=n(a,e,t,i,h?[].concat(h,s.message):s.message)}r.shift()};r.length;)s();return t}function u(n,o,u){if(void 0===u&&(u={}),function(r){return"_zod"in r&&"object"==typeof r._zod}(n))return function(s,a,c){try{return Promise.resolve(t(function(){function e(e){return c.shouldUseNativeValidation&&r({},c),{errors:{},values:u.raw?Object.assign({},s):e}}var t=n;return"sync"===u.mode?e(t.parse(s,o)):Promise.resolve(t.parseAsync(s,o)).then(e)},function(r){if(function(r){var e;return!(null==r||null==(e=r._zod)||null==(e=e.traits)||!e.has("$ZodError"))}(r))return{values:{},errors:e(i(r.issues,!c.shouldUseNativeValidation&&"all"===c.criteriaMode),c)};throw r}))}catch(r){return Promise.reject(r)}};if(function(r){return"_def"in r&&"object"==typeof r._def}(n))return function(i,a,c){try{return Promise.resolve(t(function(){return Promise.resolve(n["sync"===u.mode?"parse":"parseAsync"](i,o)).then(function(e){return c.shouldUseNativeValidation&&r({},c),{errors:{},values:u.raw?Object.assign({},i):e}})},function(r){if(function(r){return Array.isArray(null==r?void 0:r.issues)}(r))return{values:{},errors:e(s(r.errors,!c.shouldUseNativeValidation&&"all"===c.criteriaMode),c)};throw r}))}catch(r){return Promise.reject(r)}};throw new Error("Invalid input: not a Zod schema")}export{u as zodResolver};
 //# sourceMappingURL=zod.module.js.map

package/zod/dist/zod.module.js.map

@@ -1 +1 @@
-{"version":3,"file":"zod.module.js","sources":["../src/zod.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport {\n  FieldError,\n  FieldValues,\n  Resolver,\n  ResolverError,\n  ResolverSuccess,\n  appendErrors,\n} from 'react-hook-form';\nimport * as z3 from 'zod/v3';\nimport * as z4 from 'zod/v4/core';\n\nconst isZod3Error = (error: any): error is z3.ZodError => {\n  return Array.isArray(error?.issues);\n};\nconst isZod3Schema = (schema: any): schema is z3.ZodSchema => {\n  // Deliberately doesn't require `typeName` in `_def` — dynamically selected\n  // schemas typed via the generic `z.ZodType<Output>` annotation (rather than\n  // a concrete subclass like `ZodObject`) don't statically expose `typeName`,\n  // even though they're genuine Zod 3 schema instances at runtime.\n  return '_def' in schema && typeof schema._def === 'object';\n};\nconst isZod4Error = (error: any): error is z4.$ZodError => {\n  // instanceof is safe in Zod 4 (uses Symbol.hasInstance)\n  return error instanceof z4.$ZodError;\n};\nconst isZod4Schema = (schema: any): schema is z4.$ZodType => {\n  return '_zod' in schema && typeof schema._zod === 'object';\n};\n\nfunction parseZod3Issues(\n  zodErrors: z3.ZodIssue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n  for (; zodErrors.length; ) {\n    const error = zodErrors[0];\n    const { code, message, path } = error;\n    const _path = path.join('.');\n\n    if (!errors[_path]) {\n      if ('unionErrors' in error) {\n        // Surface the error from whichever union member came closest to\n        // matching (fewest issues), rather than always the first member —\n        // the first member isn't necessarily the one the input was meant for.\n        const closestUnionError = error.unionErrors.reduce(\n          (closest, current) =>\n            current.errors.length < closest.errors.length ? current : closest,\n        );\n        // Fall back to the union issue's own message/code if the closest\n        // member somehow has no issues of its own (shouldn't happen, but\n        // avoids ever throwing on an unexpected/malformed union shape).\n        const unionError = closestUnionError.errors[0];\n\n        errors[_path] = {\n          message: unionError?.message ?? message,\n          type: unionError?.code ?? code,\n        };\n      } else {\n        errors[_path] = { message, type: code };\n      }\n    }\n\n    if ('unionErrors' in error) {\n      error.unionErrors.forEach((unionError) =>\n        unionError.errors.forEach((e) => zodErrors.push(e)),\n      );\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types[error.code];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        code,\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    zodErrors.shift();\n  }\n\n  return errors;\n}\n\nfunction parseZod4Issues(\n  zodErrors: z4.$ZodIssue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n  // const _zodErrors = zodErrors as z4.$ZodISsue; //\n  for (; zodErrors.length; ) {\n    const error = zodErrors[0];\n    const { code, message, path } = error;\n    const _path = path.join('.');\n\n    if (!errors[_path]) {\n      if (error.code === 'invalid_union' && error.errors.length > 0) {\n        // Surface the error from whichever union member came closest to\n        // matching (fewest issues), rather than always the first member —\n        // the first member isn't necessarily the one the input was meant for.\n        const closestBranch = error.errors.reduce((closest, branch) =>\n          branch.length < closest.length ? branch : closest,\n        );\n        // Fall back to the union issue's own message/code if the closest\n        // branch somehow has no issues of its own (shouldn't happen — a\n        // 0-issue branch means that branch matched — but this guarantees we\n        // never throw on an unexpected/malformed union shape, e.g. a \"no\n        // matching discriminator\" issue nested in a way we haven't seen).\n        const unionError = closestBranch[0];\n\n        errors[_path] = {\n          message: unionError?.message ?? message,\n          type: unionError?.code ?? code,\n        };\n      } else {\n        errors[_path] = { message, type: code };\n      }\n    }\n\n    if (error.code === 'invalid_union') {\n      error.errors.forEach((unionError) =>\n        unionError.forEach((e) =>\n          zodErrors.push({ ...e, path: [...error.path, ...e.path] }),\n        ),\n      );\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types[error.code];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        code,\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    zodErrors.shift();\n  }\n\n  return errors;\n}\n\ntype RawResolverOptions = {\n  mode?: 'async' | 'sync';\n  raw: true;\n};\ntype NonRawResolverOptions = {\n  mode?: 'async' | 'sync';\n  raw?: false;\n};\n\n// minimal interfaces to avoid asssignability issues between versions\ninterface Zod3Type<O = unknown, I = unknown> {\n  _output: O;\n  _input: I;\n  _def: object;\n}\n\n// minimal interface to avoid assignability issues between zod v4 patch/minor\n// releases, which brand the full `$ZodType` shape with an exact version literal\n// (e.g. `_zod.version.minor`)\ninterface Zod4Type<Output = unknown, Input = unknown> {\n  _zod: {\n    output: Output;\n    input: Input;\n  };\n}\n\n// some type magic to make versions pre-3.25.0 still work\ntype IsUnresolved<T> = PropertyKey extends keyof T ? true : false;\ntype UnresolvedFallback<T, Fallback> = IsUnresolved<typeof z3> extends true\n  ? Fallback\n  : T;\ntype FallbackIssue = {\n  code: string;\n  message: string;\n  path: (string | number)[];\n};\ntype Zod3ParseParams = UnresolvedFallback<\n  z3.ParseParams,\n  // fallback if user is on <3.25.0\n  {\n    path?: (string | number)[];\n    errorMap?: (\n      iss: FallbackIssue,\n      ctx: {\n        defaultError: string;\n        data: any;\n      },\n    ) => { message: string };\n    async?: boolean;\n  }\n>;\ntype Zod4ParseParams = UnresolvedFallback<\n  z4.ParseContext<z4.$ZodIssue>,\n  // fallback if user is on <3.25.0\n  {\n    readonly error?: (\n      iss: FallbackIssue,\n    ) => null | undefined | string | { message: string };\n    readonly reportInput?: boolean;\n    readonly jitless?: boolean;\n  }\n>;\n\nexport function zodResolver<Input extends FieldValues, Context, Output>(\n  schema: Zod3Type<Output, Input>,\n  schemaOptions?: Zod3ParseParams,\n  resolverOptions?: NonRawResolverOptions,\n): Resolver<Input, Context, Output>;\nexport function zodResolver<Input extends FieldValues, Context, Output>(\n  schema: Zod3Type<Output, Input>,\n  schemaOptions: Zod3ParseParams | undefined,\n  resolverOptions: RawResolverOptions,\n): Resolver<Input, Context, Input>;\n// the Zod 4 overloads need to be generic for complicated reasons\nexport function zodResolver<\n  Input extends FieldValues,\n  Context,\n  Output,\n  T extends Zod4Type<Output, Input> = Zod4Type<Output, Input>,\n>(\n  schema: T,\n  schemaOptions?: Zod4ParseParams, // already partial\n  resolverOptions?: NonRawResolverOptions,\n): Resolver<z4.input<T>, Context, z4.output<T>>;\nexport function zodResolver<\n  Input extends FieldValues,\n  Context,\n  Output,\n  T extends Zod4Type<Output, Input> = Zod4Type<Output, Input>,\n>(\n  schema: Zod4Type<Output, Input>,\n  schemaOptions: Zod4ParseParams | undefined, // already partial\n  resolverOptions: RawResolverOptions,\n): Resolver<z4.input<T>, Context, z4.input<T>>;\n/**\n * Creates a resolver function for react-hook-form that validates form data using a Zod schema\n * @param {z3.ZodSchema<Input>} schema - The Zod schema used to validate the form data\n * @param {Partial<z3.ParseParams>} [schemaOptions] - Optional configuration options for Zod parsing\n * @param {Object} [resolverOptions] - Optional resolver-specific configuration\n * @param {('async'|'sync')} [resolverOptions.mode='async'] - Validation mode. Use 'sync' for synchronous validation\n * @param {boolean} [resolverOptions.raw=false] - If true, returns the raw form values instead of the parsed data\n * @returns {Resolver<z3.output<typeof schema>>} A resolver function compatible with react-hook-form\n * @throws {Error} Throws if validation fails with a non-Zod error\n * @example\n * const schema = z3.object({\n *   name: z3.string().min(2),\n *   age: z3.number().min(18)\n * });\n *\n * useForm({\n *   resolver: zodResolver(schema)\n * });\n */\nexport function zodResolver<Input extends FieldValues, Context, Output>(\n  schema: object,\n  schemaOptions?: object,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Output | Input> {\n  // Zod 4 is checked first: its `_zod` marker is unambiguous, whereas the\n  // Zod 3 check below only requires an object-shaped `_def` (to support\n  // dynamically-selected schemas typed via the generic `z.ZodType<Output>`\n  // annotation, see `isZod3Schema`) — and Zod 4 schemas also have an\n  // object-shaped `_def`, so they'd otherwise be misdetected as Zod 3.\n  if (isZod4Schema(schema)) {\n    return async (values: Input, _, options) => {\n      try {\n        // Call the schema's own bound `parse`/`parseAsync` method rather\n        // than the standalone `z4.parse`/`z4.parseAsync` functions. Those\n        // standalone functions read from this module's own imported\n        // `zod/v4/core`, which — under bundlers that can resolve `zod` and\n        // `zod/v4/core` to two distinct module instances (e.g. Metro with\n        // package-exports resolution enabled) — may not be the same zod\n        // instance the schema was created with, silently dropping any\n        // global config (`z.config()`) or locale the app configured on its\n        // own zod instance. The schema's own method is always bound to\n        // whichever zod instance actually created it.\n        const classicSchema = schema as unknown as {\n          parse: (values: unknown, schemaOptions: unknown) => unknown;\n          parseAsync: (\n            values: unknown,\n            schemaOptions: unknown,\n          ) => Promise<unknown>;\n        };\n        const data: any =\n          resolverOptions.mode === 'sync'\n            ? classicSchema.parse(values, schemaOptions)\n            : await classicSchema.parseAsync(values, schemaOptions);\n\n        options.shouldUseNativeValidation &&\n          validateFieldsNatively({}, options);\n\n        return {\n          errors: {},\n          values: resolverOptions.raw ? Object.assign({}, values) : data,\n        } satisfies ResolverSuccess<Output | Input>;\n      } catch (error) {\n        if (isZod4Error(error)) {\n          return {\n            values: {},\n            errors: toNestErrors(\n              parseZod4Issues(\n                error.issues,\n                !options.shouldUseNativeValidation &&\n                  options.criteriaMode === 'all',\n              ),\n              options,\n            ),\n          } satisfies ResolverError<Input>;\n        }\n\n        throw error;\n      }\n    };\n  }\n\n  if (isZod3Schema(schema)) {\n    return async (values: Input, _, options) => {\n      try {\n        const data = await schema[\n          resolverOptions.mode === 'sync' ? 'parse' : 'parseAsync'\n        ](values, schemaOptions);\n\n        options.shouldUseNativeValidation &&\n          validateFieldsNatively({}, options);\n\n        return {\n          errors: {},\n          values: resolverOptions.raw ? Object.assign({}, values) : data,\n        } satisfies ResolverSuccess<Output | Input>;\n      } catch (error) {\n        if (isZod3Error(error)) {\n          return {\n            values: {},\n            errors: toNestErrors(\n              parseZod3Issues(\n                error.errors,\n                !options.shouldUseNativeValidation &&\n                  options.criteriaMode === 'all',\n              ),\n              options,\n            ),\n          } satisfies ResolverError<Input>;\n        }\n\n        throw error;\n      }\n    };\n  }\n\n  throw new Error('Invalid input: not a Zod schema');\n}\n"],"names":["parseZod3Issues","zodErrors","validateAllFieldCriteria","errors","length","error","code","message","_path","path","join","_unionError$message","_unionError$code","unionError","unionErrors","reduce","closest","current","type","forEach","e","push","types","messages","appendErrors","concat","shift","parseZod4Issues","_loop","_unionError$message2","_unionError$code2","branch","_extends","zodResolver","schema","schemaOptions","resolverOptions","_zod","isZod4Schema","values","_","options","Promise","resolve","_catch","_temp2","data","shouldUseNativeValidation","validateFieldsNatively","raw","Object","assign","classicSchema","mode","parse","parseAsync","then","z4","$ZodError","isZod4Error","toNestErrors","issues","criteriaMode","reject","_def","isZod3Schema","Array","isArray","isZod3Error","Error"],"mappings":"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"}
+{"version":3,"file":"zod.module.js","sources":["../src/zod.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport {\n  FieldError,\n  FieldValues,\n  Resolver,\n  ResolverError,\n  ResolverSuccess,\n  appendErrors,\n} from 'react-hook-form';\n// Type-only: these subpaths don't exist before zod@3.25.0, so importing them\n// as values would break resolution for anyone on an older zod 3.x. `import\n// type` is fully erased at build time, so the compiled output never\n// references these subpaths at runtime — see `isZod4Error` below for how the\n// one runtime check that used to need `z4.$ZodError` avoids that now.\nimport type * as z3 from 'zod/v3';\nimport type * as z4 from 'zod/v4/core';\n\nconst isZod3Error = (error: any): error is z3.ZodError => {\n  return Array.isArray(error?.issues);\n};\nconst isZod3Schema = (schema: any): schema is z3.ZodSchema => {\n  // Deliberately doesn't require `typeName` in `_def` — dynamically selected\n  // schemas typed via the generic `z.ZodType<Output>` annotation (rather than\n  // a concrete subclass like `ZodObject`) don't statically expose `typeName`,\n  // even though they're genuine Zod 3 schema instances at runtime.\n  return '_def' in schema && typeof schema._def === 'object';\n};\nconst isZod4Error = (error: any): error is z4.$ZodError => {\n  // Replicates zod4's own `$ZodError`/`Symbol.hasInstance` check\n  // (`inst?._zod?.traits?.has(name)`, see zod's `$constructor` in\n  // `v4/core/core.ts`) by hand rather than importing `$ZodError` as a value,\n  // since that import only exists in zod@3.25.0+ (see the `import type` note\n  // above).\n  return !!error?._zod?.traits?.has('$ZodError');\n};\nconst isZod4Schema = (schema: any): schema is z4.$ZodType => {\n  return '_zod' in schema && typeof schema._zod === 'object';\n};\n\nfunction parseZod3Issues(\n  zodErrors: z3.ZodIssue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n  for (; zodErrors.length; ) {\n    const error = zodErrors[0];\n    const { code, message, path } = error;\n    const _path = path.join('.');\n\n    if (!errors[_path]) {\n      if ('unionErrors' in error) {\n        // Surface the error from whichever union member came closest to\n        // matching (fewest issues), rather than always the first member —\n        // the first member isn't necessarily the one the input was meant for.\n        const closestUnionError = error.unionErrors.reduce(\n          (closest, current) =>\n            current.errors.length < closest.errors.length ? current : closest,\n        );\n        // Fall back to the union issue's own message/code if the closest\n        // member somehow has no issues of its own (shouldn't happen, but\n        // avoids ever throwing on an unexpected/malformed union shape).\n        const unionError = closestUnionError.errors[0];\n\n        errors[_path] = {\n          message: unionError?.message ?? message,\n          type: unionError?.code ?? code,\n        };\n      } else {\n        errors[_path] = { message, type: code };\n      }\n    }\n\n    if ('unionErrors' in error) {\n      error.unionErrors.forEach((unionError) =>\n        unionError.errors.forEach((e) => zodErrors.push(e)),\n      );\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types[error.code];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        code,\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    zodErrors.shift();\n  }\n\n  return errors;\n}\n\nfunction parseZod4Issues(\n  zodErrors: z4.$ZodIssue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n  // const _zodErrors = zodErrors as z4.$ZodISsue; //\n  for (; zodErrors.length; ) {\n    const error = zodErrors[0];\n    const { code, message, path } = error;\n    const _path = path.join('.');\n\n    if (!errors[_path]) {\n      if (error.code === 'invalid_union' && error.errors.length > 0) {\n        // Surface the error from whichever union member came closest to\n        // matching (fewest issues), rather than always the first member —\n        // the first member isn't necessarily the one the input was meant for.\n        const closestBranch = error.errors.reduce((closest, branch) =>\n          branch.length < closest.length ? branch : closest,\n        );\n        // Fall back to the union issue's own message/code if the closest\n        // branch somehow has no issues of its own (shouldn't happen — a\n        // 0-issue branch means that branch matched — but this guarantees we\n        // never throw on an unexpected/malformed union shape, e.g. a \"no\n        // matching discriminator\" issue nested in a way we haven't seen).\n        const unionError = closestBranch[0];\n\n        errors[_path] = {\n          message: unionError?.message ?? message,\n          type: unionError?.code ?? code,\n        };\n      } else {\n        errors[_path] = { message, type: code };\n      }\n    }\n\n    if (error.code === 'invalid_union') {\n      error.errors.forEach((unionError) =>\n        unionError.forEach((e) =>\n          zodErrors.push({ ...e, path: [...error.path, ...e.path] }),\n        ),\n      );\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types[error.code];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        code,\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    zodErrors.shift();\n  }\n\n  return errors;\n}\n\ntype RawResolverOptions = {\n  mode?: 'async' | 'sync';\n  raw: true;\n};\ntype NonRawResolverOptions = {\n  mode?: 'async' | 'sync';\n  raw?: false;\n};\n\n// minimal interfaces to avoid asssignability issues between versions\ninterface Zod3Type<O = unknown, I = unknown> {\n  _output: O;\n  _input: I;\n  _def: object;\n}\n\n// minimal interface to avoid assignability issues between zod v4 patch/minor\n// releases, which brand the full `$ZodType` shape with an exact version literal\n// (e.g. `_zod.version.minor`)\ninterface Zod4Type<Output = unknown, Input = unknown> {\n  _zod: {\n    output: Output;\n    input: Input;\n  };\n}\n\n// some type magic to make versions pre-3.25.0 still work\ntype IsUnresolved<T> = PropertyKey extends keyof T ? true : false;\ntype UnresolvedFallback<T, Fallback> = IsUnresolved<typeof z3> extends true\n  ? Fallback\n  : T;\ntype FallbackIssue = {\n  code: string;\n  message: string;\n  path: (string | number)[];\n};\ntype Zod3ParseParams = UnresolvedFallback<\n  z3.ParseParams,\n  // fallback if user is on <3.25.0\n  {\n    path?: (string | number)[];\n    errorMap?: (\n      iss: FallbackIssue,\n      ctx: {\n        defaultError: string;\n        data: any;\n      },\n    ) => { message: string };\n    async?: boolean;\n  }\n>;\ntype Zod4ParseParams = UnresolvedFallback<\n  z4.ParseContext<z4.$ZodIssue>,\n  // fallback if user is on <3.25.0\n  {\n    readonly error?: (\n      iss: FallbackIssue,\n    ) => null | undefined | string | { message: string };\n    readonly reportInput?: boolean;\n    readonly jitless?: boolean;\n  }\n>;\n\nexport function zodResolver<Input extends FieldValues, Context, Output>(\n  schema: Zod3Type<Output, Input>,\n  schemaOptions?: Zod3ParseParams,\n  resolverOptions?: NonRawResolverOptions,\n): Resolver<Input, Context, Output>;\nexport function zodResolver<Input extends FieldValues, Context, Output>(\n  schema: Zod3Type<Output, Input>,\n  schemaOptions: Zod3ParseParams | undefined,\n  resolverOptions: RawResolverOptions,\n): Resolver<Input, Context, Input>;\n// the Zod 4 overloads need to be generic for complicated reasons\nexport function zodResolver<\n  Input extends FieldValues,\n  Context,\n  Output,\n  T extends Zod4Type<Output, Input> = Zod4Type<Output, Input>,\n>(\n  schema: T,\n  schemaOptions?: Zod4ParseParams, // already partial\n  resolverOptions?: NonRawResolverOptions,\n): Resolver<z4.input<T>, Context, z4.output<T>>;\nexport function zodResolver<\n  Input extends FieldValues,\n  Context,\n  Output,\n  T extends Zod4Type<Output, Input> = Zod4Type<Output, Input>,\n>(\n  schema: Zod4Type<Output, Input>,\n  schemaOptions: Zod4ParseParams | undefined, // already partial\n  resolverOptions: RawResolverOptions,\n): Resolver<z4.input<T>, Context, z4.input<T>>;\n/**\n * Creates a resolver function for react-hook-form that validates form data using a Zod schema\n * @param {z3.ZodSchema<Input>} schema - The Zod schema used to validate the form data\n * @param {Partial<z3.ParseParams>} [schemaOptions] - Optional configuration options for Zod parsing\n * @param {Object} [resolverOptions] - Optional resolver-specific configuration\n * @param {('async'|'sync')} [resolverOptions.mode='async'] - Validation mode. Use 'sync' for synchronous validation\n * @param {boolean} [resolverOptions.raw=false] - If true, returns the raw form values instead of the parsed data\n * @returns {Resolver<z3.output<typeof schema>>} A resolver function compatible with react-hook-form\n * @throws {Error} Throws if validation fails with a non-Zod error\n * @example\n * const schema = z3.object({\n *   name: z3.string().min(2),\n *   age: z3.number().min(18)\n * });\n *\n * useForm({\n *   resolver: zodResolver(schema)\n * });\n */\nexport function zodResolver<Input extends FieldValues, Context, Output>(\n  schema: object,\n  schemaOptions?: object,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Output | Input> {\n  // Zod 4 is checked first: its `_zod` marker is unambiguous, whereas the\n  // Zod 3 check below only requires an object-shaped `_def` (to support\n  // dynamically-selected schemas typed via the generic `z.ZodType<Output>`\n  // annotation, see `isZod3Schema`) — and Zod 4 schemas also have an\n  // object-shaped `_def`, so they'd otherwise be misdetected as Zod 3.\n  if (isZod4Schema(schema)) {\n    return async (values: Input, _, options) => {\n      try {\n        // Call the schema's own bound `parse`/`parseAsync` method rather\n        // than the standalone `z4.parse`/`z4.parseAsync` functions. Those\n        // standalone functions read from this module's own imported\n        // `zod/v4/core`, which — under bundlers that can resolve `zod` and\n        // `zod/v4/core` to two distinct module instances (e.g. Metro with\n        // package-exports resolution enabled) — may not be the same zod\n        // instance the schema was created with, silently dropping any\n        // global config (`z.config()`) or locale the app configured on its\n        // own zod instance. The schema's own method is always bound to\n        // whichever zod instance actually created it.\n        const classicSchema = schema as unknown as {\n          parse: (values: unknown, schemaOptions: unknown) => unknown;\n          parseAsync: (\n            values: unknown,\n            schemaOptions: unknown,\n          ) => Promise<unknown>;\n        };\n        const data: any =\n          resolverOptions.mode === 'sync'\n            ? classicSchema.parse(values, schemaOptions)\n            : await classicSchema.parseAsync(values, schemaOptions);\n\n        options.shouldUseNativeValidation &&\n          validateFieldsNatively({}, options);\n\n        return {\n          errors: {},\n          values: resolverOptions.raw ? Object.assign({}, values) : data,\n        } satisfies ResolverSuccess<Output | Input>;\n      } catch (error) {\n        if (isZod4Error(error)) {\n          return {\n            values: {},\n            errors: toNestErrors(\n              parseZod4Issues(\n                error.issues,\n                !options.shouldUseNativeValidation &&\n                  options.criteriaMode === 'all',\n              ),\n              options,\n            ),\n          } satisfies ResolverError<Input>;\n        }\n\n        throw error;\n      }\n    };\n  }\n\n  if (isZod3Schema(schema)) {\n    return async (values: Input, _, options) => {\n      try {\n        const data = await schema[\n          resolverOptions.mode === 'sync' ? 'parse' : 'parseAsync'\n        ](values, schemaOptions);\n\n        options.shouldUseNativeValidation &&\n          validateFieldsNatively({}, options);\n\n        return {\n          errors: {},\n          values: resolverOptions.raw ? Object.assign({}, values) : data,\n        } satisfies ResolverSuccess<Output | Input>;\n      } catch (error) {\n        if (isZod3Error(error)) {\n          return {\n            values: {},\n            errors: toNestErrors(\n              parseZod3Issues(\n                error.errors,\n                !options.shouldUseNativeValidation &&\n                  options.criteriaMode === 'all',\n              ),\n              options,\n            ),\n          } satisfies ResolverError<Input>;\n        }\n\n        throw error;\n      }\n    };\n  }\n\n  throw new Error('Invalid input: not a Zod schema');\n}\n"],"names":["parseZod3Issues","zodErrors","validateAllFieldCriteria","errors","length","error","code","message","_path","path","join","_unionError$message","_unionError$code","unionError","unionErrors","reduce","closest","current","type","forEach","e","push","types","messages","appendErrors","concat","shift","parseZod4Issues","_loop","_unionError$message2","_unionError$code2","branch","_extends","zodResolver","schema","schemaOptions","resolverOptions","_zod","isZod4Schema","values","_","options","Promise","resolve","_catch","_temp2","data","shouldUseNativeValidation","validateFieldsNatively","raw","Object","assign","classicSchema","mode","parse","parseAsync","then","_error$_zod","traits","has","isZod4Error","toNestErrors","issues","criteriaMode","reject","_def","isZod3Schema","Array","isArray","isZod3Error","Error"],"mappings":"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"}

package/zod/dist/zod.umd.js

@@ -1,2 +1,2 @@
-!function(e,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports,require("@hookform/resolvers"),require("react-hook-form"),require("zod/v4/core")):"function"==typeof define&&define.amd?define(["exports","@hookform/resolvers","react-hook-form","zod/v4/core"],r):r((e||self).hookformResolversZod={},e.hookformResolvers,e.ReactHookForm,e.z4)}(this,function(e,r,o,n){function t(e){if(e&&e.__esModule)return e;var r=Object.create(null);return e&&Object.keys(e).forEach(function(o){if("default"!==o){var n=Object.getOwnPropertyDescriptor(e,o);Object.defineProperty(r,o,n.get?n:{enumerable:!0,get:function(){return e[o]}})}}),r.default=e,r}var s=/*#__PURE__*/t(n);function i(){return i=Object.assign?Object.assign.bind():function(e){for(var r=1;r<arguments.length;r++){var o=arguments[r];for(var n in o)({}).hasOwnProperty.call(o,n)&&(e[n]=o[n])}return e},i.apply(null,arguments)}function u(e,r){try{var o=e()}catch(e){return r(e)}return o&&o.then?o.then(void 0,r):o}function a(e,r){for(var n={};e.length;){var t=e[0],s=t.code,i=t.message,u=t.path.join(".");if(!n[u])if("unionErrors"in t){var a,c,l=t.unionErrors.reduce(function(e,r){return r.errors.length<e.errors.length?r:e}).errors[0];n[u]={message:null!=(a=null==l?void 0:l.message)?a:i,type:null!=(c=null==l?void 0:l.code)?c:s}}else n[u]={message:i,type:s};if("unionErrors"in t&&t.unionErrors.forEach(function(r){return r.errors.forEach(function(r){return e.push(r)})}),r){var f=n[u].types,d=f&&f[t.code];n[u]=o.appendErrors(u,r,n,s,d?[].concat(d,t.message):t.message)}e.shift()}return n}function c(e,r){for(var n={},t=function(){var t=e[0],s=t.code,u=t.message,a=t.path.join(".");if(!n[a])if("invalid_union"===t.code&&t.errors.length>0){var c,l,f=t.errors.reduce(function(e,r){return r.length<e.length?r:e})[0];n[a]={message:null!=(c=null==f?void 0:f.message)?c:u,type:null!=(l=null==f?void 0:f.code)?l:s}}else n[a]={message:u,type:s};if("invalid_union"===t.code&&t.errors.forEach(function(r){return r.forEach(function(r){return e.push(i({},r,{path:[].concat(t.path,r.path)}))})}),r){var d=n[a].types,v=d&&d[t.code];n[a]=o.appendErrors(a,r,n,s,v?[].concat(v,t.message):t.message)}e.shift()};e.length;)t();return n}e.zodResolver=function(e,o,n){if(void 0===n&&(n={}),function(e){return"_zod"in e&&"object"==typeof e._zod}(e))return function(t,i,a){try{return Promise.resolve(u(function(){function s(e){return a.shouldUseNativeValidation&&r.validateFieldsNatively({},a),{errors:{},values:n.raw?Object.assign({},t):e}}var i=e;return"sync"===n.mode?s(i.parse(t,o)):Promise.resolve(i.parseAsync(t,o)).then(s)},function(e){if(function(e){return e instanceof s.$ZodError}(e))return{values:{},errors:r.toNestErrors(c(e.issues,!a.shouldUseNativeValidation&&"all"===a.criteriaMode),a)};throw e}))}catch(e){return Promise.reject(e)}};if(function(e){return"_def"in e&&"object"==typeof e._def}(e))return function(t,s,i){try{return Promise.resolve(u(function(){return Promise.resolve(e["sync"===n.mode?"parse":"parseAsync"](t,o)).then(function(e){return i.shouldUseNativeValidation&&r.validateFieldsNatively({},i),{errors:{},values:n.raw?Object.assign({},t):e}})},function(e){if(function(e){return Array.isArray(null==e?void 0:e.issues)}(e))return{values:{},errors:r.toNestErrors(a(e.errors,!i.shouldUseNativeValidation&&"all"===i.criteriaMode),i)};throw e}))}catch(e){return Promise.reject(e)}};throw new Error("Invalid input: not a Zod schema")}});
+!function(r,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports,require("@hookform/resolvers"),require("react-hook-form")):"function"==typeof define&&define.amd?define(["exports","@hookform/resolvers","react-hook-form"],e):e((r||self).hookformResolversZod={},r.hookformResolvers,r.ReactHookForm)}(this,function(r,e,o){function n(){return n=Object.assign?Object.assign.bind():function(r){for(var e=1;e<arguments.length;e++){var o=arguments[e];for(var n in o)({}).hasOwnProperty.call(o,n)&&(r[n]=o[n])}return r},n.apply(null,arguments)}function t(r,e){try{var o=r()}catch(r){return e(r)}return o&&o.then?o.then(void 0,e):o}function s(r,e){for(var n={};r.length;){var t=r[0],s=t.code,i=t.message,a=t.path.join(".");if(!n[a])if("unionErrors"in t){var u,l,c=t.unionErrors.reduce(function(r,e){return e.errors.length<r.errors.length?e:r}).errors[0];n[a]={message:null!=(u=null==c?void 0:c.message)?u:i,type:null!=(l=null==c?void 0:c.code)?l:s}}else n[a]={message:i,type:s};if("unionErrors"in t&&t.unionErrors.forEach(function(e){return e.errors.forEach(function(e){return r.push(e)})}),e){var f=n[a].types,d=f&&f[t.code];n[a]=o.appendErrors(a,e,n,s,d?[].concat(d,t.message):t.message)}r.shift()}return n}function i(r,e){for(var t={},s=function(){var s=r[0],i=s.code,a=s.message,u=s.path.join(".");if(!t[u])if("invalid_union"===s.code&&s.errors.length>0){var l,c,f=s.errors.reduce(function(r,e){return e.length<r.length?e:r})[0];t[u]={message:null!=(l=null==f?void 0:f.message)?l:a,type:null!=(c=null==f?void 0:f.code)?c:i}}else t[u]={message:a,type:i};if("invalid_union"===s.code&&s.errors.forEach(function(e){return e.forEach(function(e){return r.push(n({},e,{path:[].concat(s.path,e.path)}))})}),e){var d=t[u].types,h=d&&d[s.code];t[u]=o.appendErrors(u,e,t,i,h?[].concat(h,s.message):s.message)}r.shift()};r.length;)s();return t}r.zodResolver=function(r,o,n){if(void 0===n&&(n={}),function(r){return"_zod"in r&&"object"==typeof r._zod}(r))return function(s,a,u){try{return Promise.resolve(t(function(){function t(r){return u.shouldUseNativeValidation&&e.validateFieldsNatively({},u),{errors:{},values:n.raw?Object.assign({},s):r}}var i=r;return"sync"===n.mode?t(i.parse(s,o)):Promise.resolve(i.parseAsync(s,o)).then(t)},function(r){if(function(r){var e;return!(null==r||null==(e=r._zod)||null==(e=e.traits)||!e.has("$ZodError"))}(r))return{values:{},errors:e.toNestErrors(i(r.issues,!u.shouldUseNativeValidation&&"all"===u.criteriaMode),u)};throw r}))}catch(r){return Promise.reject(r)}};if(function(r){return"_def"in r&&"object"==typeof r._def}(r))return function(i,a,u){try{return Promise.resolve(t(function(){return Promise.resolve(r["sync"===n.mode?"parse":"parseAsync"](i,o)).then(function(r){return u.shouldUseNativeValidation&&e.validateFieldsNatively({},u),{errors:{},values:n.raw?Object.assign({},i):r}})},function(r){if(function(r){return Array.isArray(null==r?void 0:r.issues)}(r))return{values:{},errors:e.toNestErrors(s(r.errors,!u.shouldUseNativeValidation&&"all"===u.criteriaMode),u)};throw r}))}catch(r){return Promise.reject(r)}};throw new Error("Invalid input: not a Zod schema")}});
 //# sourceMappingURL=zod.umd.js.map

package/zod/dist/zod.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"zod.umd.js","sources":["../src/zod.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport {\n  FieldError,\n  FieldValues,\n  Resolver,\n  ResolverError,\n  ResolverSuccess,\n  appendErrors,\n} from 'react-hook-form';\nimport * as z3 from 'zod/v3';\nimport * as z4 from 'zod/v4/core';\n\nconst isZod3Error = (error: any): error is z3.ZodError => {\n  return Array.isArray(error?.issues);\n};\nconst isZod3Schema = (schema: any): schema is z3.ZodSchema => {\n  // Deliberately doesn't require `typeName` in `_def` — dynamically selected\n  // schemas typed via the generic `z.ZodType<Output>` annotation (rather than\n  // a concrete subclass like `ZodObject`) don't statically expose `typeName`,\n  // even though they're genuine Zod 3 schema instances at runtime.\n  return '_def' in schema && typeof schema._def === 'object';\n};\nconst isZod4Error = (error: any): error is z4.$ZodError => {\n  // instanceof is safe in Zod 4 (uses Symbol.hasInstance)\n  return error instanceof z4.$ZodError;\n};\nconst isZod4Schema = (schema: any): schema is z4.$ZodType => {\n  return '_zod' in schema && typeof schema._zod === 'object';\n};\n\nfunction parseZod3Issues(\n  zodErrors: z3.ZodIssue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n  for (; zodErrors.length; ) {\n    const error = zodErrors[0];\n    const { code, message, path } = error;\n    const _path = path.join('.');\n\n    if (!errors[_path]) {\n      if ('unionErrors' in error) {\n        // Surface the error from whichever union member came closest to\n        // matching (fewest issues), rather than always the first member —\n        // the first member isn't necessarily the one the input was meant for.\n        const closestUnionError = error.unionErrors.reduce(\n          (closest, current) =>\n            current.errors.length < closest.errors.length ? current : closest,\n        );\n        // Fall back to the union issue's own message/code if the closest\n        // member somehow has no issues of its own (shouldn't happen, but\n        // avoids ever throwing on an unexpected/malformed union shape).\n        const unionError = closestUnionError.errors[0];\n\n        errors[_path] = {\n          message: unionError?.message ?? message,\n          type: unionError?.code ?? code,\n        };\n      } else {\n        errors[_path] = { message, type: code };\n      }\n    }\n\n    if ('unionErrors' in error) {\n      error.unionErrors.forEach((unionError) =>\n        unionError.errors.forEach((e) => zodErrors.push(e)),\n      );\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types[error.code];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        code,\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    zodErrors.shift();\n  }\n\n  return errors;\n}\n\nfunction parseZod4Issues(\n  zodErrors: z4.$ZodIssue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n  // const _zodErrors = zodErrors as z4.$ZodISsue; //\n  for (; zodErrors.length; ) {\n    const error = zodErrors[0];\n    const { code, message, path } = error;\n    const _path = path.join('.');\n\n    if (!errors[_path]) {\n      if (error.code === 'invalid_union' && error.errors.length > 0) {\n        // Surface the error from whichever union member came closest to\n        // matching (fewest issues), rather than always the first member —\n        // the first member isn't necessarily the one the input was meant for.\n        const closestBranch = error.errors.reduce((closest, branch) =>\n          branch.length < closest.length ? branch : closest,\n        );\n        // Fall back to the union issue's own message/code if the closest\n        // branch somehow has no issues of its own (shouldn't happen — a\n        // 0-issue branch means that branch matched — but this guarantees we\n        // never throw on an unexpected/malformed union shape, e.g. a \"no\n        // matching discriminator\" issue nested in a way we haven't seen).\n        const unionError = closestBranch[0];\n\n        errors[_path] = {\n          message: unionError?.message ?? message,\n          type: unionError?.code ?? code,\n        };\n      } else {\n        errors[_path] = { message, type: code };\n      }\n    }\n\n    if (error.code === 'invalid_union') {\n      error.errors.forEach((unionError) =>\n        unionError.forEach((e) =>\n          zodErrors.push({ ...e, path: [...error.path, ...e.path] }),\n        ),\n      );\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types[error.code];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        code,\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    zodErrors.shift();\n  }\n\n  return errors;\n}\n\ntype RawResolverOptions = {\n  mode?: 'async' | 'sync';\n  raw: true;\n};\ntype NonRawResolverOptions = {\n  mode?: 'async' | 'sync';\n  raw?: false;\n};\n\n// minimal interfaces to avoid asssignability issues between versions\ninterface Zod3Type<O = unknown, I = unknown> {\n  _output: O;\n  _input: I;\n  _def: object;\n}\n\n// minimal interface to avoid assignability issues between zod v4 patch/minor\n// releases, which brand the full `$ZodType` shape with an exact version literal\n// (e.g. `_zod.version.minor`)\ninterface Zod4Type<Output = unknown, Input = unknown> {\n  _zod: {\n    output: Output;\n    input: Input;\n  };\n}\n\n// some type magic to make versions pre-3.25.0 still work\ntype IsUnresolved<T> = PropertyKey extends keyof T ? true : false;\ntype UnresolvedFallback<T, Fallback> = IsUnresolved<typeof z3> extends true\n  ? Fallback\n  : T;\ntype FallbackIssue = {\n  code: string;\n  message: string;\n  path: (string | number)[];\n};\ntype Zod3ParseParams = UnresolvedFallback<\n  z3.ParseParams,\n  // fallback if user is on <3.25.0\n  {\n    path?: (string | number)[];\n    errorMap?: (\n      iss: FallbackIssue,\n      ctx: {\n        defaultError: string;\n        data: any;\n      },\n    ) => { message: string };\n    async?: boolean;\n  }\n>;\ntype Zod4ParseParams = UnresolvedFallback<\n  z4.ParseContext<z4.$ZodIssue>,\n  // fallback if user is on <3.25.0\n  {\n    readonly error?: (\n      iss: FallbackIssue,\n    ) => null | undefined | string | { message: string };\n    readonly reportInput?: boolean;\n    readonly jitless?: boolean;\n  }\n>;\n\nexport function zodResolver<Input extends FieldValues, Context, Output>(\n  schema: Zod3Type<Output, Input>,\n  schemaOptions?: Zod3ParseParams,\n  resolverOptions?: NonRawResolverOptions,\n): Resolver<Input, Context, Output>;\nexport function zodResolver<Input extends FieldValues, Context, Output>(\n  schema: Zod3Type<Output, Input>,\n  schemaOptions: Zod3ParseParams | undefined,\n  resolverOptions: RawResolverOptions,\n): Resolver<Input, Context, Input>;\n// the Zod 4 overloads need to be generic for complicated reasons\nexport function zodResolver<\n  Input extends FieldValues,\n  Context,\n  Output,\n  T extends Zod4Type<Output, Input> = Zod4Type<Output, Input>,\n>(\n  schema: T,\n  schemaOptions?: Zod4ParseParams, // already partial\n  resolverOptions?: NonRawResolverOptions,\n): Resolver<z4.input<T>, Context, z4.output<T>>;\nexport function zodResolver<\n  Input extends FieldValues,\n  Context,\n  Output,\n  T extends Zod4Type<Output, Input> = Zod4Type<Output, Input>,\n>(\n  schema: Zod4Type<Output, Input>,\n  schemaOptions: Zod4ParseParams | undefined, // already partial\n  resolverOptions: RawResolverOptions,\n): Resolver<z4.input<T>, Context, z4.input<T>>;\n/**\n * Creates a resolver function for react-hook-form that validates form data using a Zod schema\n * @param {z3.ZodSchema<Input>} schema - The Zod schema used to validate the form data\n * @param {Partial<z3.ParseParams>} [schemaOptions] - Optional configuration options for Zod parsing\n * @param {Object} [resolverOptions] - Optional resolver-specific configuration\n * @param {('async'|'sync')} [resolverOptions.mode='async'] - Validation mode. Use 'sync' for synchronous validation\n * @param {boolean} [resolverOptions.raw=false] - If true, returns the raw form values instead of the parsed data\n * @returns {Resolver<z3.output<typeof schema>>} A resolver function compatible with react-hook-form\n * @throws {Error} Throws if validation fails with a non-Zod error\n * @example\n * const schema = z3.object({\n *   name: z3.string().min(2),\n *   age: z3.number().min(18)\n * });\n *\n * useForm({\n *   resolver: zodResolver(schema)\n * });\n */\nexport function zodResolver<Input extends FieldValues, Context, Output>(\n  schema: object,\n  schemaOptions?: object,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Output | Input> {\n  // Zod 4 is checked first: its `_zod` marker is unambiguous, whereas the\n  // Zod 3 check below only requires an object-shaped `_def` (to support\n  // dynamically-selected schemas typed via the generic `z.ZodType<Output>`\n  // annotation, see `isZod3Schema`) — and Zod 4 schemas also have an\n  // object-shaped `_def`, so they'd otherwise be misdetected as Zod 3.\n  if (isZod4Schema(schema)) {\n    return async (values: Input, _, options) => {\n      try {\n        // Call the schema's own bound `parse`/`parseAsync` method rather\n        // than the standalone `z4.parse`/`z4.parseAsync` functions. Those\n        // standalone functions read from this module's own imported\n        // `zod/v4/core`, which — under bundlers that can resolve `zod` and\n        // `zod/v4/core` to two distinct module instances (e.g. Metro with\n        // package-exports resolution enabled) — may not be the same zod\n        // instance the schema was created with, silently dropping any\n        // global config (`z.config()`) or locale the app configured on its\n        // own zod instance. The schema's own method is always bound to\n        // whichever zod instance actually created it.\n        const classicSchema = schema as unknown as {\n          parse: (values: unknown, schemaOptions: unknown) => unknown;\n          parseAsync: (\n            values: unknown,\n            schemaOptions: unknown,\n          ) => Promise<unknown>;\n        };\n        const data: any =\n          resolverOptions.mode === 'sync'\n            ? classicSchema.parse(values, schemaOptions)\n            : await classicSchema.parseAsync(values, schemaOptions);\n\n        options.shouldUseNativeValidation &&\n          validateFieldsNatively({}, options);\n\n        return {\n          errors: {},\n          values: resolverOptions.raw ? Object.assign({}, values) : data,\n        } satisfies ResolverSuccess<Output | Input>;\n      } catch (error) {\n        if (isZod4Error(error)) {\n          return {\n            values: {},\n            errors: toNestErrors(\n              parseZod4Issues(\n                error.issues,\n                !options.shouldUseNativeValidation &&\n                  options.criteriaMode === 'all',\n              ),\n              options,\n            ),\n          } satisfies ResolverError<Input>;\n        }\n\n        throw error;\n      }\n    };\n  }\n\n  if (isZod3Schema(schema)) {\n    return async (values: Input, _, options) => {\n      try {\n        const data = await schema[\n          resolverOptions.mode === 'sync' ? 'parse' : 'parseAsync'\n        ](values, schemaOptions);\n\n        options.shouldUseNativeValidation &&\n          validateFieldsNatively({}, options);\n\n        return {\n          errors: {},\n          values: resolverOptions.raw ? Object.assign({}, values) : data,\n        } satisfies ResolverSuccess<Output | Input>;\n      } catch (error) {\n        if (isZod3Error(error)) {\n          return {\n            values: {},\n            errors: toNestErrors(\n              parseZod3Issues(\n                error.errors,\n                !options.shouldUseNativeValidation &&\n                  options.criteriaMode === 'all',\n              ),\n              options,\n            ),\n          } satisfies ResolverError<Input>;\n        }\n\n        throw error;\n      }\n    };\n  }\n\n  throw new Error('Invalid input: not a Zod schema');\n}\n"],"names":["parseZod3Issues","zodErrors","validateAllFieldCriteria","errors","length","error","code","message","_path","path","join","_unionError$message","_unionError$code","unionError","unionErrors","reduce","closest","current","type","forEach","e","push","types","messages","appendErrors","concat","shift","parseZod4Issues","_loop","_unionError$message2","_unionError$code2","branch","_extends","schema","schemaOptions","resolverOptions","_zod","isZod4Schema","values","_","options","Promise","resolve","_catch","_temp2","data","shouldUseNativeValidation","validateFieldsNatively","raw","Object","assign","classicSchema","mode","parse","parseAsync","then","z4","$ZodError","isZod4Error","toNestErrors","issues","criteriaMode","reject","_def","isZod3Schema","Array","isArray","isZod3Error","Error"],"mappings":"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"}
+{"version":3,"file":"zod.umd.js","sources":["../src/zod.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport {\n  FieldError,\n  FieldValues,\n  Resolver,\n  ResolverError,\n  ResolverSuccess,\n  appendErrors,\n} from 'react-hook-form';\n// Type-only: these subpaths don't exist before zod@3.25.0, so importing them\n// as values would break resolution for anyone on an older zod 3.x. `import\n// type` is fully erased at build time, so the compiled output never\n// references these subpaths at runtime — see `isZod4Error` below for how the\n// one runtime check that used to need `z4.$ZodError` avoids that now.\nimport type * as z3 from 'zod/v3';\nimport type * as z4 from 'zod/v4/core';\n\nconst isZod3Error = (error: any): error is z3.ZodError => {\n  return Array.isArray(error?.issues);\n};\nconst isZod3Schema = (schema: any): schema is z3.ZodSchema => {\n  // Deliberately doesn't require `typeName` in `_def` — dynamically selected\n  // schemas typed via the generic `z.ZodType<Output>` annotation (rather than\n  // a concrete subclass like `ZodObject`) don't statically expose `typeName`,\n  // even though they're genuine Zod 3 schema instances at runtime.\n  return '_def' in schema && typeof schema._def === 'object';\n};\nconst isZod4Error = (error: any): error is z4.$ZodError => {\n  // Replicates zod4's own `$ZodError`/`Symbol.hasInstance` check\n  // (`inst?._zod?.traits?.has(name)`, see zod's `$constructor` in\n  // `v4/core/core.ts`) by hand rather than importing `$ZodError` as a value,\n  // since that import only exists in zod@3.25.0+ (see the `import type` note\n  // above).\n  return !!error?._zod?.traits?.has('$ZodError');\n};\nconst isZod4Schema = (schema: any): schema is z4.$ZodType => {\n  return '_zod' in schema && typeof schema._zod === 'object';\n};\n\nfunction parseZod3Issues(\n  zodErrors: z3.ZodIssue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n  for (; zodErrors.length; ) {\n    const error = zodErrors[0];\n    const { code, message, path } = error;\n    const _path = path.join('.');\n\n    if (!errors[_path]) {\n      if ('unionErrors' in error) {\n        // Surface the error from whichever union member came closest to\n        // matching (fewest issues), rather than always the first member —\n        // the first member isn't necessarily the one the input was meant for.\n        const closestUnionError = error.unionErrors.reduce(\n          (closest, current) =>\n            current.errors.length < closest.errors.length ? current : closest,\n        );\n        // Fall back to the union issue's own message/code if the closest\n        // member somehow has no issues of its own (shouldn't happen, but\n        // avoids ever throwing on an unexpected/malformed union shape).\n        const unionError = closestUnionError.errors[0];\n\n        errors[_path] = {\n          message: unionError?.message ?? message,\n          type: unionError?.code ?? code,\n        };\n      } else {\n        errors[_path] = { message, type: code };\n      }\n    }\n\n    if ('unionErrors' in error) {\n      error.unionErrors.forEach((unionError) =>\n        unionError.errors.forEach((e) => zodErrors.push(e)),\n      );\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types[error.code];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        code,\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    zodErrors.shift();\n  }\n\n  return errors;\n}\n\nfunction parseZod4Issues(\n  zodErrors: z4.$ZodIssue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n  // const _zodErrors = zodErrors as z4.$ZodISsue; //\n  for (; zodErrors.length; ) {\n    const error = zodErrors[0];\n    const { code, message, path } = error;\n    const _path = path.join('.');\n\n    if (!errors[_path]) {\n      if (error.code === 'invalid_union' && error.errors.length > 0) {\n        // Surface the error from whichever union member came closest to\n        // matching (fewest issues), rather than always the first member —\n        // the first member isn't necessarily the one the input was meant for.\n        const closestBranch = error.errors.reduce((closest, branch) =>\n          branch.length < closest.length ? branch : closest,\n        );\n        // Fall back to the union issue's own message/code if the closest\n        // branch somehow has no issues of its own (shouldn't happen — a\n        // 0-issue branch means that branch matched — but this guarantees we\n        // never throw on an unexpected/malformed union shape, e.g. a \"no\n        // matching discriminator\" issue nested in a way we haven't seen).\n        const unionError = closestBranch[0];\n\n        errors[_path] = {\n          message: unionError?.message ?? message,\n          type: unionError?.code ?? code,\n        };\n      } else {\n        errors[_path] = { message, type: code };\n      }\n    }\n\n    if (error.code === 'invalid_union') {\n      error.errors.forEach((unionError) =>\n        unionError.forEach((e) =>\n          zodErrors.push({ ...e, path: [...error.path, ...e.path] }),\n        ),\n      );\n    }\n\n    if (validateAllFieldCriteria) {\n      const types = errors[_path].types;\n      const messages = types && types[error.code];\n\n      errors[_path] = appendErrors(\n        _path,\n        validateAllFieldCriteria,\n        errors,\n        code,\n        messages\n          ? ([] as string[]).concat(messages as string[], error.message)\n          : error.message,\n      ) as FieldError;\n    }\n\n    zodErrors.shift();\n  }\n\n  return errors;\n}\n\ntype RawResolverOptions = {\n  mode?: 'async' | 'sync';\n  raw: true;\n};\ntype NonRawResolverOptions = {\n  mode?: 'async' | 'sync';\n  raw?: false;\n};\n\n// minimal interfaces to avoid asssignability issues between versions\ninterface Zod3Type<O = unknown, I = unknown> {\n  _output: O;\n  _input: I;\n  _def: object;\n}\n\n// minimal interface to avoid assignability issues between zod v4 patch/minor\n// releases, which brand the full `$ZodType` shape with an exact version literal\n// (e.g. `_zod.version.minor`)\ninterface Zod4Type<Output = unknown, Input = unknown> {\n  _zod: {\n    output: Output;\n    input: Input;\n  };\n}\n\n// some type magic to make versions pre-3.25.0 still work\ntype IsUnresolved<T> = PropertyKey extends keyof T ? true : false;\ntype UnresolvedFallback<T, Fallback> = IsUnresolved<typeof z3> extends true\n  ? Fallback\n  : T;\ntype FallbackIssue = {\n  code: string;\n  message: string;\n  path: (string | number)[];\n};\ntype Zod3ParseParams = UnresolvedFallback<\n  z3.ParseParams,\n  // fallback if user is on <3.25.0\n  {\n    path?: (string | number)[];\n    errorMap?: (\n      iss: FallbackIssue,\n      ctx: {\n        defaultError: string;\n        data: any;\n      },\n    ) => { message: string };\n    async?: boolean;\n  }\n>;\ntype Zod4ParseParams = UnresolvedFallback<\n  z4.ParseContext<z4.$ZodIssue>,\n  // fallback if user is on <3.25.0\n  {\n    readonly error?: (\n      iss: FallbackIssue,\n    ) => null | undefined | string | { message: string };\n    readonly reportInput?: boolean;\n    readonly jitless?: boolean;\n  }\n>;\n\nexport function zodResolver<Input extends FieldValues, Context, Output>(\n  schema: Zod3Type<Output, Input>,\n  schemaOptions?: Zod3ParseParams,\n  resolverOptions?: NonRawResolverOptions,\n): Resolver<Input, Context, Output>;\nexport function zodResolver<Input extends FieldValues, Context, Output>(\n  schema: Zod3Type<Output, Input>,\n  schemaOptions: Zod3ParseParams | undefined,\n  resolverOptions: RawResolverOptions,\n): Resolver<Input, Context, Input>;\n// the Zod 4 overloads need to be generic for complicated reasons\nexport function zodResolver<\n  Input extends FieldValues,\n  Context,\n  Output,\n  T extends Zod4Type<Output, Input> = Zod4Type<Output, Input>,\n>(\n  schema: T,\n  schemaOptions?: Zod4ParseParams, // already partial\n  resolverOptions?: NonRawResolverOptions,\n): Resolver<z4.input<T>, Context, z4.output<T>>;\nexport function zodResolver<\n  Input extends FieldValues,\n  Context,\n  Output,\n  T extends Zod4Type<Output, Input> = Zod4Type<Output, Input>,\n>(\n  schema: Zod4Type<Output, Input>,\n  schemaOptions: Zod4ParseParams | undefined, // already partial\n  resolverOptions: RawResolverOptions,\n): Resolver<z4.input<T>, Context, z4.input<T>>;\n/**\n * Creates a resolver function for react-hook-form that validates form data using a Zod schema\n * @param {z3.ZodSchema<Input>} schema - The Zod schema used to validate the form data\n * @param {Partial<z3.ParseParams>} [schemaOptions] - Optional configuration options for Zod parsing\n * @param {Object} [resolverOptions] - Optional resolver-specific configuration\n * @param {('async'|'sync')} [resolverOptions.mode='async'] - Validation mode. Use 'sync' for synchronous validation\n * @param {boolean} [resolverOptions.raw=false] - If true, returns the raw form values instead of the parsed data\n * @returns {Resolver<z3.output<typeof schema>>} A resolver function compatible with react-hook-form\n * @throws {Error} Throws if validation fails with a non-Zod error\n * @example\n * const schema = z3.object({\n *   name: z3.string().min(2),\n *   age: z3.number().min(18)\n * });\n *\n * useForm({\n *   resolver: zodResolver(schema)\n * });\n */\nexport function zodResolver<Input extends FieldValues, Context, Output>(\n  schema: object,\n  schemaOptions?: object,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Output | Input> {\n  // Zod 4 is checked first: its `_zod` marker is unambiguous, whereas the\n  // Zod 3 check below only requires an object-shaped `_def` (to support\n  // dynamically-selected schemas typed via the generic `z.ZodType<Output>`\n  // annotation, see `isZod3Schema`) — and Zod 4 schemas also have an\n  // object-shaped `_def`, so they'd otherwise be misdetected as Zod 3.\n  if (isZod4Schema(schema)) {\n    return async (values: Input, _, options) => {\n      try {\n        // Call the schema's own bound `parse`/`parseAsync` method rather\n        // than the standalone `z4.parse`/`z4.parseAsync` functions. Those\n        // standalone functions read from this module's own imported\n        // `zod/v4/core`, which — under bundlers that can resolve `zod` and\n        // `zod/v4/core` to two distinct module instances (e.g. Metro with\n        // package-exports resolution enabled) — may not be the same zod\n        // instance the schema was created with, silently dropping any\n        // global config (`z.config()`) or locale the app configured on its\n        // own zod instance. The schema's own method is always bound to\n        // whichever zod instance actually created it.\n        const classicSchema = schema as unknown as {\n          parse: (values: unknown, schemaOptions: unknown) => unknown;\n          parseAsync: (\n            values: unknown,\n            schemaOptions: unknown,\n          ) => Promise<unknown>;\n        };\n        const data: any =\n          resolverOptions.mode === 'sync'\n            ? classicSchema.parse(values, schemaOptions)\n            : await classicSchema.parseAsync(values, schemaOptions);\n\n        options.shouldUseNativeValidation &&\n          validateFieldsNatively({}, options);\n\n        return {\n          errors: {},\n          values: resolverOptions.raw ? Object.assign({}, values) : data,\n        } satisfies ResolverSuccess<Output | Input>;\n      } catch (error) {\n        if (isZod4Error(error)) {\n          return {\n            values: {},\n            errors: toNestErrors(\n              parseZod4Issues(\n                error.issues,\n                !options.shouldUseNativeValidation &&\n                  options.criteriaMode === 'all',\n              ),\n              options,\n            ),\n          } satisfies ResolverError<Input>;\n        }\n\n        throw error;\n      }\n    };\n  }\n\n  if (isZod3Schema(schema)) {\n    return async (values: Input, _, options) => {\n      try {\n        const data = await schema[\n          resolverOptions.mode === 'sync' ? 'parse' : 'parseAsync'\n        ](values, schemaOptions);\n\n        options.shouldUseNativeValidation &&\n          validateFieldsNatively({}, options);\n\n        return {\n          errors: {},\n          values: resolverOptions.raw ? Object.assign({}, values) : data,\n        } satisfies ResolverSuccess<Output | Input>;\n      } catch (error) {\n        if (isZod3Error(error)) {\n          return {\n            values: {},\n            errors: toNestErrors(\n              parseZod3Issues(\n                error.errors,\n                !options.shouldUseNativeValidation &&\n                  options.criteriaMode === 'all',\n              ),\n              options,\n            ),\n          } satisfies ResolverError<Input>;\n        }\n\n        throw error;\n      }\n    };\n  }\n\n  throw new Error('Invalid input: not a Zod schema');\n}\n"],"names":["parseZod3Issues","zodErrors","validateAllFieldCriteria","errors","length","error","code","message","_path","path","join","_unionError$message","_unionError$code","unionError","unionErrors","reduce","closest","current","type","forEach","e","push","types","messages","appendErrors","concat","shift","parseZod4Issues","_loop","_unionError$message2","_unionError$code2","branch","_extends","schema","schemaOptions","resolverOptions","_zod","isZod4Schema","values","_","options","Promise","resolve","_catch","_temp2","data","shouldUseNativeValidation","validateFieldsNatively","raw","Object","assign","classicSchema","mode","parse","parseAsync","then","_error$_zod","traits","has","isZod4Error","toNestErrors","issues","criteriaMode","reject","_def","isZod3Schema","Array","isArray","isZod3Error","Error"],"mappings":"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"}

package/zod/src/__tests__/subpath-imports.ts

@@ -0,0 +1,16 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+// `zod/v3` and `zod/v4/core` don't exist before zod@3.25.0. Importing either
+// as a value (rather than `import type`) makes the compiled output reference
+// that subpath at runtime, which breaks module resolution for anyone on an
+// older zod 3.x — even if they never touch the zod4 code path (#811).
+test('zod/v3 and zod/v4/core are only ever imported as types', () => {
+  const source = readFileSync(join(__dirname, '..', 'zod.ts'), 'utf8');
+
+  const v3Import = source.match(/^import .*'zod\/v3';$/m)?.[0];
+  const v4Import = source.match(/^import .*'zod\/v4\/core';$/m)?.[0];
+
+  expect(v3Import).toMatch(/^import type /);
+  expect(v4Import).toMatch(/^import type /);
+});

package/zod/src/zod.ts

@@ -7,8 +7,13 @@ import {
   ResolverSuccess,
   appendErrors,
 } from 'react-hook-form';
-import * as z3 from 'zod/v3';
-import * as z4 from 'zod/v4/core';
+// Type-only: these subpaths don't exist before zod@3.25.0, so importing them
+// as values would break resolution for anyone on an older zod 3.x. `import
+// type` is fully erased at build time, so the compiled output never
+// references these subpaths at runtime — see `isZod4Error` below for how the
+// one runtime check that used to need `z4.$ZodError` avoids that now.
+import type * as z3 from 'zod/v3';
+import type * as z4 from 'zod/v4/core';
 
 const isZod3Error = (error: any): error is z3.ZodError => {
   return Array.isArray(error?.issues);
@@ -21,8 +26,12 @@ const isZod3Schema = (schema: any): schema is z3.ZodSchema => {
   return '_def' in schema && typeof schema._def === 'object';
 };
 const isZod4Error = (error: any): error is z4.$ZodError => {
-  // instanceof is safe in Zod 4 (uses Symbol.hasInstance)
-  return error instanceof z4.$ZodError;
+  // Replicates zod4's own `$ZodError`/`Symbol.hasInstance` check
+  // (`inst?._zod?.traits?.has(name)`, see zod's `$constructor` in
+  // `v4/core/core.ts`) by hand rather than importing `$ZodError` as a value,
+  // since that import only exists in zod@3.25.0+ (see the `import type` note
+  // above).
+  return !!error?._zod?.traits?.has('$ZodError');
 };
 const isZod4Schema = (schema: any): schema is z4.$ZodType => {
   return '_zod' in schema && typeof schema._zod === 'object';