@hookform/resolvers 4.1.3 → 5.0.1

package/README.md

@@ -55,6 +55,36 @@ Install your preferred validation library alongside `@hookform/resolvers`.
 | zod  | ✅ | `firstError | all` |
 </details>
 
+## TypeScript
+
+Most of the resolvers can infer the output type from the schema. See comparison table for more details.
+
+```tsx
+useForm<Input, Context, Output>()
+```
+
+Example:
+
+```tsx
+import { useForm } from 'react-hook-form';
+import { zodResolver } from '@hookform/resolvers/zod';
+import { z } from 'zod';
+
+const schema = z.object({
+  id: z.number(),
+});
+
+// Automatically infers the output type from the schema
+useForm({
+  resolver: zodResolver(schema),
+});
+
+// Force the output type
+useForm<z.input<typeof schema>, any, z.output<typeof schema>>({
+  resolver: zodResolver(schema),
+});
+```
+
 ## Links
 
 - [React-hook-form validation resolver documentation ](https://react-hook-form.com/docs/useform#resolver)

package/ajv/package.json

@@ -11,7 +11,7 @@
   "types": "dist/index.d.ts",
   "license": "MIT",
   "peerDependencies": {
-    "react-hook-form": "^7.0.0",
+    "react-hook-form": "^7.55.0",
     "@hookform/resolvers": "^2.0.0",
     "ajv": "^8.12.0",
     "ajv-errors": "^3.0.0"

package/arktype/dist/arktype.d.ts

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

package/arktype/dist/arktype.js

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

package/arktype/dist/arktype.js.map

@@ -1 +1 @@
-{"version":3,"file":"arktype.js","sources":["../src/arktype.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { ArkErrors, Type } from 'arktype';\nimport { FieldError, FieldErrors, Resolver } from 'react-hook-form';\n\nfunction parseErrorSchema(arkErrors: ArkErrors): Record<string, FieldError> {\n  const errors = [...arkErrors];\n  const fieldsErrors: Record<string, FieldError> = {};\n\n  for (; errors.length; ) {\n    const error = errors[0];\n    const _path = error.path.join('.');\n\n    if (!fieldsErrors[_path]) {\n      fieldsErrors[_path] = { message: error.message, type: error.code };\n    }\n\n    errors.shift();\n  }\n\n  return fieldsErrors;\n}\n\n/**\n * Creates a resolver for react-hook-form using Arktype schema validation\n * @param {Schema} schema - The Arktype schema to validate against\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {string} [resolverOptions.mode='raw'] - Return the raw input values rather than the parsed values\n * @returns {Resolver<Schema['inferOut']>} A resolver function compatible with react-hook-form\n * @example\n * const schema = type({\n *   username: 'string>2'\n * });\n *\n * useForm({\n *   resolver: arktypeResolver(schema)\n * });\n */\nexport function arktypeResolver<Schema extends Type<any, any>>(\n  schema: Schema,\n  _schemaOptions?: never,\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Schema['inferOut']> {\n  return (values, _, options) => {\n    const out = schema(values);\n\n    if (out instanceof ArkErrors) {\n      return {\n        values: {},\n        errors: toNestErrors(parseErrorSchema(out), options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      errors: {} as FieldErrors,\n      values: resolverOptions.raw ? Object.assign({}, values) : out,\n    };\n  };\n}\n"],"names":["parseErrorSchema","arkErrors","errors","concat","fieldsErrors","length","error","_path","path","join","message","type","code","shift","schema","_schemaOptions","resolverOptions","values","_","options","out","ArkErrors","toNestErrors","shouldUseNativeValidation","validateFieldsNatively","raw","Object","assign"],"mappings":"0DAIA,SAASA,EAAiBC,GAIxB,IAHA,IAAMC,EAAMC,GAAAA,OAAOF,GACbG,EAA2C,CAAE,EAE5CF,EAAOG,QAAU,CACtB,IAAMC,EAAQJ,EAAO,GACfK,EAAQD,EAAME,KAAKC,KAAK,KAEzBL,EAAaG,KAChBH,EAAaG,GAAS,CAAEG,QAASJ,EAAMI,QAASC,KAAML,EAAMM,OAG9DV,EAAOW,OACT,CAEA,OAAOT,CACT,kCAkBEU,EACAC,EACAC,GAIA,gBAJAA,IAAAA,EAEI,CAAE,GAEEC,SAAAA,EAAQC,EAAGC,GACjB,IAAMC,EAAMN,EAAOG,GAEnB,OAAIG,aAAeC,YACV,CACLJ,OAAQ,CAAE,EACVf,OAAQoB,EAAAA,aAAatB,EAAiBoB,GAAMD,KAIhDA,EAAQI,2BAA6BC,yBAAuB,CAAA,EAAIL,GAEzD,CACLjB,OAAQ,GACRe,OAAQD,EAAgBS,IAAMC,OAAOC,OAAO,GAAIV,GAAUG,GAE9D,CACF"}
+{"version":3,"file":"arktype.js","sources":["../../node_modules/@standard-schema/utils/dist/index.js","../src/arktype.ts"],"sourcesContent":["// src/getDotPath/getDotPath.ts\nfunction getDotPath(issue) {\n  if (issue.path?.length) {\n    let dotPath = \"\";\n    for (const item of issue.path) {\n      const key = typeof item === \"object\" ? item.key : item;\n      if (typeof key === \"string\" || typeof key === \"number\") {\n        if (dotPath) {\n          dotPath += `.${key}`;\n        } else {\n          dotPath += key;\n        }\n      } else {\n        return null;\n      }\n    }\n    return dotPath;\n  }\n  return null;\n}\n\n// src/SchemaError/SchemaError.ts\nvar SchemaError = class extends Error {\n  /**\n   * The schema issues.\n   */\n  issues;\n  /**\n   * Creates a schema error with useful information.\n   *\n   * @param issues The schema issues.\n   */\n  constructor(issues) {\n    super(issues[0].message);\n    this.name = \"SchemaError\";\n    this.issues = issues;\n  }\n};\nexport {\n  SchemaError,\n  getDotPath\n};\n","import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { StandardSchemaV1 } from '@standard-schema/spec';\nimport { getDotPath } from '@standard-schema/utils';\nimport { FieldError, FieldValues, Resolver } from 'react-hook-form';\n\nfunction parseErrorSchema(\n  issues: readonly StandardSchemaV1.Issue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n\n  for (let i = 0; i < issues.length; i++) {\n    const error = issues[i];\n    const path = getDotPath(error);\n\n    if (path) {\n      if (!errors[path]) {\n        errors[path] = { message: error.message, type: '' };\n      }\n\n      if (validateAllFieldCriteria) {\n        const types = errors[path].types || {};\n\n        errors[path].types = {\n          ...types,\n          [Object.keys(types).length]: error.message,\n        };\n      }\n    }\n  }\n\n  return errors;\n}\n\nexport function arktypeResolver<Input extends FieldValues, Context, Output>(\n  schema: StandardSchemaV1<Input, Output>,\n  _schemaOptions?: never,\n  resolverOptions?: {\n    raw?: false;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function arktypeResolver<Input extends FieldValues, Context, Output>(\n  schema: StandardSchemaV1<Input, Output>,\n  _schemaOptions: never | undefined,\n  resolverOptions: {\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Arktype schema validation\n * @param {Schema} schema - The Arktype schema to validate against\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {string} [resolverOptions.mode='raw'] - Return the raw input values rather than the parsed values\n * @returns {Resolver<Schema['inferOut']>} A resolver function compatible with react-hook-form\n * @example\n * const schema = type({\n *   username: 'string>2'\n * });\n *\n * useForm({\n *   resolver: arktypeResolver(schema)\n * });\n */\nexport function arktypeResolver<Input extends FieldValues, Context, Output>(\n  schema: StandardSchemaV1<Input, Output>,\n  _schemaOptions?: never,\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Input | Output> {\n  return async (values: Input, _, options) => {\n    let result = schema['~standard'].validate(values);\n    if (result instanceof Promise) {\n      result = await result;\n    }\n\n    if (result.issues) {\n      const errors = parseErrorSchema(\n        result.issues,\n        !options.shouldUseNativeValidation && options.criteriaMode === 'all',\n      );\n\n      return {\n        values: {},\n        errors: toNestErrors(errors, options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      values: resolverOptions.raw ? Object.assign({}, values) : result.value,\n      errors: {},\n    };\n  };\n}\n"],"names":["getDotPath","issue","path","length","dotPath","item","key","schema","_schemaOptions","resolverOptions","values","_","options","_temp2","result","issues","errors","validateAllFieldCriteria","i","error","message","type","_extends2","types","_extends","Object","keys","parseErrorSchema","shouldUseNativeValidation","criteriaMode","toNestErrors","validateFieldsNatively","raw","assign","value","validate","_temp","Promise","resolve","then","_result","e","reject"],"mappings":"6PACA,SAASA,EAAWC,GAClB,GAAIA,EAAMC,MAAMC,OAAQ,CACtB,IAAIC,EAAU,GACd,IAAK,MAAMC,KAAQJ,EAAMC,KAAM,CAC7B,MAAMI,EAAsB,iBAATD,EAAoBA,EAAKC,IAAMD,EAClD,GAAmB,iBAARC,GAAmC,iBAARA,EAOpC,OAAO,KALLF,GADEA,EACS,IAAIE,IAEJA,CAKhB,CACD,OAAOF,CACR,CACD,OAAO,IACT,yBC8CM,SACJG,EACAC,EACAC,GAIA,gBAJAA,IAAAA,EAEI,CAAE,GAEQC,SAAAA,EAAeC,EAAGC,GAAO,IAAIC,IAAAA,aAMzC,GAAIC,EAAOC,OAAQ,CACjB,IAAMC,EA1EZ,SACED,EACAE,GAIA,IAFA,IAAMD,EAAqC,GAElCE,EAAI,EAAGA,EAAIH,EAAOZ,OAAQe,IAAK,CACtC,IAAMC,EAAQJ,EAAOG,GACfhB,EAAOF,EAAWmB,GAExB,GAAIjB,IACGc,EAAOd,KACVc,EAAOd,GAAQ,CAAEkB,QAASD,EAAMC,QAASC,KAAM,KAG7CJ,GAA0B,CAAAK,IAAAA,EACtBC,EAAQP,EAAOd,GAAMqB,OAAS,GAEpCP,EAAOd,GAAMqB,MAAKC,KACbD,IAAKD,EAAA,CAAA,GACPG,OAAOC,KAAKH,GAAOpB,QAASgB,EAAMC,QAAOE,GAE9C,CAEJ,CAEA,OAAON,CACT,CA+CqBW,CACbb,EAAOC,QACNH,EAAQgB,2BAAsD,QAAzBhB,EAAQiB,cAGhD,MAAO,CACLnB,OAAQ,CAAA,EACRM,OAAQc,eAAad,EAAQJ,GAEjC,CAIA,OAFAA,EAAQgB,2BAA6BG,EAAAA,uBAAuB,CAAA,EAAInB,GAEzD,CACLF,OAAQD,EAAgBuB,IAAMP,OAAOQ,OAAO,CAAA,EAAIvB,GAAUI,EAAOoB,MACjElB,OAAQ,CAAA,EACR,EAtBEF,EAASP,EAAO,aAAa4B,SAASzB,GAAQ0B,gBAC9CtB,aAAkBuB,QAAO,OAAAA,QAAAC,QACZxB,GAAMyB,KAAA,SAAAC,GAArB1B,EAAM0B,CAAgB,EAAAH,IAAAA,OAAAA,QAAAC,QAAAF,GAAAA,EAAAG,KAAAH,EAAAG,KAAA1B,GAAAA,IAqB1B,CAAC,MAAA4B,GAAAJ,OAAAA,QAAAK,OAAAD,EACH,CAAA,CAAA"}

package/arktype/dist/arktype.mjs

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

package/arktype/dist/arktype.modern.mjs

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

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

@@ -1 +1 @@
-{"version":3,"file":"arktype.modern.mjs","sources":["../src/arktype.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { ArkErrors, Type } from 'arktype';\nimport { FieldError, FieldErrors, Resolver } from 'react-hook-form';\n\nfunction parseErrorSchema(arkErrors: ArkErrors): Record<string, FieldError> {\n  const errors = [...arkErrors];\n  const fieldsErrors: Record<string, FieldError> = {};\n\n  for (; errors.length; ) {\n    const error = errors[0];\n    const _path = error.path.join('.');\n\n    if (!fieldsErrors[_path]) {\n      fieldsErrors[_path] = { message: error.message, type: error.code };\n    }\n\n    errors.shift();\n  }\n\n  return fieldsErrors;\n}\n\n/**\n * Creates a resolver for react-hook-form using Arktype schema validation\n * @param {Schema} schema - The Arktype schema to validate against\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {string} [resolverOptions.mode='raw'] - Return the raw input values rather than the parsed values\n * @returns {Resolver<Schema['inferOut']>} A resolver function compatible with react-hook-form\n * @example\n * const schema = type({\n *   username: 'string>2'\n * });\n *\n * useForm({\n *   resolver: arktypeResolver(schema)\n * });\n */\nexport function arktypeResolver<Schema extends Type<any, any>>(\n  schema: Schema,\n  _schemaOptions?: never,\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Schema['inferOut']> {\n  return (values, _, options) => {\n    const out = schema(values);\n\n    if (out instanceof ArkErrors) {\n      return {\n        values: {},\n        errors: toNestErrors(parseErrorSchema(out), options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      errors: {} as FieldErrors,\n      values: resolverOptions.raw ? Object.assign({}, values) : out,\n    };\n  };\n}\n"],"names":["parseErrorSchema","arkErrors","errors","fieldsErrors","length","error","_path","path","join","message","type","code","shift","arktypeResolver","schema","_schemaOptions","resolverOptions","values","_","options","out","ArkErrors","toNestErrors","shouldUseNativeValidation","validateFieldsNatively","raw","Object","assign"],"mappings":"mHAIA,SAASA,EAAiBC,GACxB,MAAMC,EAAS,IAAID,GACbE,EAA2C,GAEjD,KAAOD,EAAOE,QAAU,CACtB,MAAMC,EAAQH,EAAO,GACfI,EAAQD,EAAME,KAAKC,KAAK,KAEzBL,EAAaG,KAChBH,EAAaG,GAAS,CAAEG,QAASJ,EAAMI,QAASC,KAAML,EAAMM,OAG9DT,EAAOU,OACT,CAEA,OAAOT,CACT,CAiBM,SAAUU,EACdC,EACAC,EACAC,EAEI,CAAE,GAEN,MAAO,CAACC,EAAQC,EAAGC,KACjB,MAAMC,EAAMN,EAAOG,GAEnB,OAAIG,aAAeC,EACV,CACLJ,OAAQ,CAAE,EACVf,OAAQoB,EAAatB,EAAiBoB,GAAMD,KAIhDA,EAAQI,2BAA6BC,EAAuB,CAAE,EAAEL,GAEzD,CACLjB,OAAQ,CAAA,EACRe,OAAQD,EAAgBS,IAAMC,OAAOC,OAAO,GAAIV,GAAUG,IAGhE"}
+{"version":3,"file":"arktype.modern.mjs","sources":["../../node_modules/@standard-schema/utils/dist/index.js","../src/arktype.ts"],"sourcesContent":["// src/getDotPath/getDotPath.ts\nfunction getDotPath(issue) {\n  if (issue.path?.length) {\n    let dotPath = \"\";\n    for (const item of issue.path) {\n      const key = typeof item === \"object\" ? item.key : item;\n      if (typeof key === \"string\" || typeof key === \"number\") {\n        if (dotPath) {\n          dotPath += `.${key}`;\n        } else {\n          dotPath += key;\n        }\n      } else {\n        return null;\n      }\n    }\n    return dotPath;\n  }\n  return null;\n}\n\n// src/SchemaError/SchemaError.ts\nvar SchemaError = class extends Error {\n  /**\n   * The schema issues.\n   */\n  issues;\n  /**\n   * Creates a schema error with useful information.\n   *\n   * @param issues The schema issues.\n   */\n  constructor(issues) {\n    super(issues[0].message);\n    this.name = \"SchemaError\";\n    this.issues = issues;\n  }\n};\nexport {\n  SchemaError,\n  getDotPath\n};\n","import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { StandardSchemaV1 } from '@standard-schema/spec';\nimport { getDotPath } from '@standard-schema/utils';\nimport { FieldError, FieldValues, Resolver } from 'react-hook-form';\n\nfunction parseErrorSchema(\n  issues: readonly StandardSchemaV1.Issue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n\n  for (let i = 0; i < issues.length; i++) {\n    const error = issues[i];\n    const path = getDotPath(error);\n\n    if (path) {\n      if (!errors[path]) {\n        errors[path] = { message: error.message, type: '' };\n      }\n\n      if (validateAllFieldCriteria) {\n        const types = errors[path].types || {};\n\n        errors[path].types = {\n          ...types,\n          [Object.keys(types).length]: error.message,\n        };\n      }\n    }\n  }\n\n  return errors;\n}\n\nexport function arktypeResolver<Input extends FieldValues, Context, Output>(\n  schema: StandardSchemaV1<Input, Output>,\n  _schemaOptions?: never,\n  resolverOptions?: {\n    raw?: false;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function arktypeResolver<Input extends FieldValues, Context, Output>(\n  schema: StandardSchemaV1<Input, Output>,\n  _schemaOptions: never | undefined,\n  resolverOptions: {\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Arktype schema validation\n * @param {Schema} schema - The Arktype schema to validate against\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {string} [resolverOptions.mode='raw'] - Return the raw input values rather than the parsed values\n * @returns {Resolver<Schema['inferOut']>} A resolver function compatible with react-hook-form\n * @example\n * const schema = type({\n *   username: 'string>2'\n * });\n *\n * useForm({\n *   resolver: arktypeResolver(schema)\n * });\n */\nexport function arktypeResolver<Input extends FieldValues, Context, Output>(\n  schema: StandardSchemaV1<Input, Output>,\n  _schemaOptions?: never,\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Input | Output> {\n  return async (values: Input, _, options) => {\n    let result = schema['~standard'].validate(values);\n    if (result instanceof Promise) {\n      result = await result;\n    }\n\n    if (result.issues) {\n      const errors = parseErrorSchema(\n        result.issues,\n        !options.shouldUseNativeValidation && options.criteriaMode === 'all',\n      );\n\n      return {\n        values: {},\n        errors: toNestErrors(errors, options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      values: resolverOptions.raw ? Object.assign({}, values) : result.value,\n      errors: {},\n    };\n  };\n}\n"],"names":["getDotPath","issue","path","length","dotPath","item","key","arktypeResolver","schema","_schemaOptions","resolverOptions","values","_","options","result","validate","Promise","issues","errors","validateAllFieldCriteria","i","error","message","type","types","_extends","Object","keys","parseErrorSchema","shouldUseNativeValidation","criteriaMode","toNestErrors","validateFieldsNatively","raw","assign","value"],"mappings":"uSACA,SAASA,EAAWC,GAClB,GAAIA,EAAMC,MAAMC,OAAQ,CACtB,IAAIC,EAAU,GACd,IAAK,MAAMC,KAAQJ,EAAMC,KAAM,CAC7B,MAAMI,EAAsB,iBAATD,EAAoBA,EAAKC,IAAMD,EAClD,GAAmB,iBAARC,GAAmC,iBAARA,EAOpC,OAAO,KALLF,GADEA,EACS,IAAIE,IAEJA,CAKhB,CACD,OAAOF,CACR,CACD,OAAO,IACT,CC8CgB,SAAAG,EACdC,EACAC,EACAC,EAEI,CAAE,GAEN,OAAcC,MAAAA,EAAeC,EAAGC,KAC9B,IAAIC,EAASN,EAAO,aAAaO,SAASJ,GAK1C,GAJIG,aAAkBE,UACpBF,QAAeA,GAGbA,EAAOG,OAAQ,CACjB,MAAMC,EA1EZ,SACED,EACAE,GAEA,MAAMD,EAAqC,CAAA,EAE3C,IAAK,IAAIE,EAAI,EAAGA,EAAIH,EAAOd,OAAQiB,IAAK,CACtC,MAAMC,EAAQJ,EAAOG,GACflB,EAAOF,EAAWqB,GAExB,GAAInB,IACGgB,EAAOhB,KACVgB,EAAOhB,GAAQ,CAAEoB,QAASD,EAAMC,QAASC,KAAM,KAG7CJ,GAA0B,CAC5B,MAAMK,EAAQN,EAAOhB,GAAMsB,OAAS,CAAA,EAEpCN,EAAOhB,GAAMsB,MAAKC,KACbD,EAAK,CACR,CAACE,OAAOC,KAAKH,GAAOrB,QAASkB,EAAMC,SAEvC,CAEJ,CAEA,OAAOJ,CACT,CA+CqBU,CACbd,EAAOG,QACNJ,EAAQgB,2BAAsD,QAAzBhB,EAAQiB,cAGhD,MAAO,CACLnB,OAAQ,CAAE,EACVO,OAAQa,EAAab,EAAQL,GAEjC,CAIA,OAFAA,EAAQgB,2BAA6BG,EAAuB,CAAE,EAAEnB,GAEzD,CACLF,OAAQD,EAAgBuB,IAAMP,OAAOQ,OAAO,CAAA,EAAIvB,GAAUG,EAAOqB,MACjEjB,OAAQ,IAGd"}

package/arktype/dist/arktype.module.js

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

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

@@ -1 +1 @@
-{"version":3,"file":"arktype.module.js","sources":["../src/arktype.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { ArkErrors, Type } from 'arktype';\nimport { FieldError, FieldErrors, Resolver } from 'react-hook-form';\n\nfunction parseErrorSchema(arkErrors: ArkErrors): Record<string, FieldError> {\n  const errors = [...arkErrors];\n  const fieldsErrors: Record<string, FieldError> = {};\n\n  for (; errors.length; ) {\n    const error = errors[0];\n    const _path = error.path.join('.');\n\n    if (!fieldsErrors[_path]) {\n      fieldsErrors[_path] = { message: error.message, type: error.code };\n    }\n\n    errors.shift();\n  }\n\n  return fieldsErrors;\n}\n\n/**\n * Creates a resolver for react-hook-form using Arktype schema validation\n * @param {Schema} schema - The Arktype schema to validate against\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {string} [resolverOptions.mode='raw'] - Return the raw input values rather than the parsed values\n * @returns {Resolver<Schema['inferOut']>} A resolver function compatible with react-hook-form\n * @example\n * const schema = type({\n *   username: 'string>2'\n * });\n *\n * useForm({\n *   resolver: arktypeResolver(schema)\n * });\n */\nexport function arktypeResolver<Schema extends Type<any, any>>(\n  schema: Schema,\n  _schemaOptions?: never,\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Schema['inferOut']> {\n  return (values, _, options) => {\n    const out = schema(values);\n\n    if (out instanceof ArkErrors) {\n      return {\n        values: {},\n        errors: toNestErrors(parseErrorSchema(out), options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      errors: {} as FieldErrors,\n      values: resolverOptions.raw ? Object.assign({}, values) : out,\n    };\n  };\n}\n"],"names":["parseErrorSchema","arkErrors","errors","concat","fieldsErrors","length","error","_path","path","join","message","type","code","shift","arktypeResolver","schema","_schemaOptions","resolverOptions","values","_","options","out","ArkErrors","toNestErrors","shouldUseNativeValidation","validateFieldsNatively","raw","Object","assign"],"mappings":"mHAIA,SAASA,EAAiBC,GAIxB,IAHA,IAAMC,EAAMC,GAAAA,OAAOF,GACbG,EAA2C,CAAE,EAE5CF,EAAOG,QAAU,CACtB,IAAMC,EAAQJ,EAAO,GACfK,EAAQD,EAAME,KAAKC,KAAK,KAEzBL,EAAaG,KAChBH,EAAaG,GAAS,CAAEG,QAASJ,EAAMI,QAASC,KAAML,EAAMM,OAG9DV,EAAOW,OACT,CAEA,OAAOT,CACT,UAiBgBU,EACdC,EACAC,EACAC,GAIA,gBAJAA,IAAAA,EAEI,CAAE,GAEEC,SAAAA,EAAQC,EAAGC,GACjB,IAAMC,EAAMN,EAAOG,GAEnB,OAAIG,aAAeC,EACV,CACLJ,OAAQ,CAAE,EACVhB,OAAQqB,EAAavB,EAAiBqB,GAAMD,KAIhDA,EAAQI,2BAA6BC,EAAuB,CAAA,EAAIL,GAEzD,CACLlB,OAAQ,GACRgB,OAAQD,EAAgBS,IAAMC,OAAOC,OAAO,GAAIV,GAAUG,GAE9D,CACF"}
+{"version":3,"file":"arktype.module.js","sources":["../../node_modules/@standard-schema/utils/dist/index.js","../src/arktype.ts"],"sourcesContent":["// src/getDotPath/getDotPath.ts\nfunction getDotPath(issue) {\n  if (issue.path?.length) {\n    let dotPath = \"\";\n    for (const item of issue.path) {\n      const key = typeof item === \"object\" ? item.key : item;\n      if (typeof key === \"string\" || typeof key === \"number\") {\n        if (dotPath) {\n          dotPath += `.${key}`;\n        } else {\n          dotPath += key;\n        }\n      } else {\n        return null;\n      }\n    }\n    return dotPath;\n  }\n  return null;\n}\n\n// src/SchemaError/SchemaError.ts\nvar SchemaError = class extends Error {\n  /**\n   * The schema issues.\n   */\n  issues;\n  /**\n   * Creates a schema error with useful information.\n   *\n   * @param issues The schema issues.\n   */\n  constructor(issues) {\n    super(issues[0].message);\n    this.name = \"SchemaError\";\n    this.issues = issues;\n  }\n};\nexport {\n  SchemaError,\n  getDotPath\n};\n","import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { StandardSchemaV1 } from '@standard-schema/spec';\nimport { getDotPath } from '@standard-schema/utils';\nimport { FieldError, FieldValues, Resolver } from 'react-hook-form';\n\nfunction parseErrorSchema(\n  issues: readonly StandardSchemaV1.Issue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n\n  for (let i = 0; i < issues.length; i++) {\n    const error = issues[i];\n    const path = getDotPath(error);\n\n    if (path) {\n      if (!errors[path]) {\n        errors[path] = { message: error.message, type: '' };\n      }\n\n      if (validateAllFieldCriteria) {\n        const types = errors[path].types || {};\n\n        errors[path].types = {\n          ...types,\n          [Object.keys(types).length]: error.message,\n        };\n      }\n    }\n  }\n\n  return errors;\n}\n\nexport function arktypeResolver<Input extends FieldValues, Context, Output>(\n  schema: StandardSchemaV1<Input, Output>,\n  _schemaOptions?: never,\n  resolverOptions?: {\n    raw?: false;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function arktypeResolver<Input extends FieldValues, Context, Output>(\n  schema: StandardSchemaV1<Input, Output>,\n  _schemaOptions: never | undefined,\n  resolverOptions: {\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Arktype schema validation\n * @param {Schema} schema - The Arktype schema to validate against\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {string} [resolverOptions.mode='raw'] - Return the raw input values rather than the parsed values\n * @returns {Resolver<Schema['inferOut']>} A resolver function compatible with react-hook-form\n * @example\n * const schema = type({\n *   username: 'string>2'\n * });\n *\n * useForm({\n *   resolver: arktypeResolver(schema)\n * });\n */\nexport function arktypeResolver<Input extends FieldValues, Context, Output>(\n  schema: StandardSchemaV1<Input, Output>,\n  _schemaOptions?: never,\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Input | Output> {\n  return async (values: Input, _, options) => {\n    let result = schema['~standard'].validate(values);\n    if (result instanceof Promise) {\n      result = await result;\n    }\n\n    if (result.issues) {\n      const errors = parseErrorSchema(\n        result.issues,\n        !options.shouldUseNativeValidation && options.criteriaMode === 'all',\n      );\n\n      return {\n        values: {},\n        errors: toNestErrors(errors, options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      values: resolverOptions.raw ? Object.assign({}, values) : result.value,\n      errors: {},\n    };\n  };\n}\n"],"names":["getDotPath","issue","path","length","dotPath","item","key","arktypeResolver","schema","_schemaOptions","resolverOptions","values","_","options","_temp2","result","issues","errors","validateAllFieldCriteria","i","error","message","type","_extends2","types","_extends","Object","keys","parseErrorSchema","shouldUseNativeValidation","criteriaMode","toNestErrors","validateFieldsNatively","raw","assign","value","validate","_temp","Promise","resolve","then","_result","e","reject"],"mappings":"uSACA,SAASA,EAAWC,GAClB,GAAIA,EAAMC,MAAMC,OAAQ,CACtB,IAAIC,EAAU,GACd,IAAK,MAAMC,KAAQJ,EAAMC,KAAM,CAC7B,MAAMI,EAAsB,iBAATD,EAAoBA,EAAKC,IAAMD,EAClD,GAAmB,iBAARC,GAAmC,iBAARA,EAOpC,OAAO,KALLF,GADEA,EACS,IAAIE,IAEJA,CAKhB,CACD,OAAOF,CACR,CACD,OAAO,IACT,CC8CM,SAAUG,EACdC,EACAC,EACAC,GAIA,gBAJAA,IAAAA,EAEI,CAAE,GAEQC,SAAAA,EAAeC,EAAGC,GAAO,IAAIC,IAAAA,aAMzC,GAAIC,EAAOC,OAAQ,CACjB,IAAMC,EA1EZ,SACED,EACAE,GAIA,IAFA,IAAMD,EAAqC,GAElCE,EAAI,EAAGA,EAAIH,EAAOb,OAAQgB,IAAK,CACtC,IAAMC,EAAQJ,EAAOG,GACfjB,EAAOF,EAAWoB,GAExB,GAAIlB,IACGe,EAAOf,KACVe,EAAOf,GAAQ,CAAEmB,QAASD,EAAMC,QAASC,KAAM,KAG7CJ,GAA0B,CAAAK,IAAAA,EACtBC,EAAQP,EAAOf,GAAMsB,OAAS,GAEpCP,EAAOf,GAAMsB,MAAKC,KACbD,IAAKD,EAAA,CAAA,GACPG,OAAOC,KAAKH,GAAOrB,QAASiB,EAAMC,QAAOE,GAE9C,CAEJ,CAEA,OAAON,CACT,CA+CqBW,CACbb,EAAOC,QACNH,EAAQgB,2BAAsD,QAAzBhB,EAAQiB,cAGhD,MAAO,CACLnB,OAAQ,CAAA,EACRM,OAAQc,EAAad,EAAQJ,GAEjC,CAIA,OAFAA,EAAQgB,2BAA6BG,EAAuB,CAAA,EAAInB,GAEzD,CACLF,OAAQD,EAAgBuB,IAAMP,OAAOQ,OAAO,CAAA,EAAIvB,GAAUI,EAAOoB,MACjElB,OAAQ,CAAA,EACR,EAtBEF,EAASP,EAAO,aAAa4B,SAASzB,GAAQ0B,gBAC9CtB,aAAkBuB,QAAO,OAAAA,QAAAC,QACZxB,GAAMyB,KAAA,SAAAC,GAArB1B,EAAM0B,CAAgB,EAAAH,IAAAA,OAAAA,QAAAC,QAAAF,GAAAA,EAAAG,KAAAH,EAAAG,KAAA1B,GAAAA,IAqB1B,CAAC,MAAA4B,GAAAJ,OAAAA,QAAAK,OAAAD,EACH,CAAA,CAAA"}

package/arktype/dist/arktype.umd.js

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

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

@@ -1 +1 @@
-{"version":3,"file":"arktype.umd.js","sources":["../src/arktype.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { ArkErrors, Type } from 'arktype';\nimport { FieldError, FieldErrors, Resolver } from 'react-hook-form';\n\nfunction parseErrorSchema(arkErrors: ArkErrors): Record<string, FieldError> {\n  const errors = [...arkErrors];\n  const fieldsErrors: Record<string, FieldError> = {};\n\n  for (; errors.length; ) {\n    const error = errors[0];\n    const _path = error.path.join('.');\n\n    if (!fieldsErrors[_path]) {\n      fieldsErrors[_path] = { message: error.message, type: error.code };\n    }\n\n    errors.shift();\n  }\n\n  return fieldsErrors;\n}\n\n/**\n * Creates a resolver for react-hook-form using Arktype schema validation\n * @param {Schema} schema - The Arktype schema to validate against\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {string} [resolverOptions.mode='raw'] - Return the raw input values rather than the parsed values\n * @returns {Resolver<Schema['inferOut']>} A resolver function compatible with react-hook-form\n * @example\n * const schema = type({\n *   username: 'string>2'\n * });\n *\n * useForm({\n *   resolver: arktypeResolver(schema)\n * });\n */\nexport function arktypeResolver<Schema extends Type<any, any>>(\n  schema: Schema,\n  _schemaOptions?: never,\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Schema['inferOut']> {\n  return (values, _, options) => {\n    const out = schema(values);\n\n    if (out instanceof ArkErrors) {\n      return {\n        values: {},\n        errors: toNestErrors(parseErrorSchema(out), options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      errors: {} as FieldErrors,\n      values: resolverOptions.raw ? Object.assign({}, values) : out,\n    };\n  };\n}\n"],"names":["parseErrorSchema","arkErrors","errors","concat","fieldsErrors","length","error","_path","path","join","message","type","code","shift","schema","_schemaOptions","resolverOptions","values","_","options","out","ArkErrors","toNestErrors","shouldUseNativeValidation","validateFieldsNatively","raw","Object","assign"],"mappings":"sWAIA,SAASA,EAAiBC,GAIxB,IAHA,IAAMC,EAAMC,GAAAA,OAAOF,GACbG,EAA2C,CAAE,EAE5CF,EAAOG,QAAU,CACtB,IAAMC,EAAQJ,EAAO,GACfK,EAAQD,EAAME,KAAKC,KAAK,KAEzBL,EAAaG,KAChBH,EAAaG,GAAS,CAAEG,QAASJ,EAAMI,QAASC,KAAML,EAAMM,OAG9DV,EAAOW,OACT,CAEA,OAAOT,CACT,4BAkBEU,EACAC,EACAC,GAIA,gBAJAA,IAAAA,EAEI,CAAE,GAEEC,SAAAA,EAAQC,EAAGC,GACjB,IAAMC,EAAMN,EAAOG,GAEnB,OAAIG,aAAeC,YACV,CACLJ,OAAQ,CAAE,EACVf,OAAQoB,EAAAA,aAAatB,EAAiBoB,GAAMD,KAIhDA,EAAQI,2BAA6BC,yBAAuB,CAAA,EAAIL,GAEzD,CACLjB,OAAQ,GACRe,OAAQD,EAAgBS,IAAMC,OAAOC,OAAO,GAAIV,GAAUG,GAE9D,CACF"}
+{"version":3,"file":"arktype.umd.js","sources":["../../node_modules/@standard-schema/utils/dist/index.js","../src/arktype.ts"],"sourcesContent":["// src/getDotPath/getDotPath.ts\nfunction getDotPath(issue) {\n  if (issue.path?.length) {\n    let dotPath = \"\";\n    for (const item of issue.path) {\n      const key = typeof item === \"object\" ? item.key : item;\n      if (typeof key === \"string\" || typeof key === \"number\") {\n        if (dotPath) {\n          dotPath += `.${key}`;\n        } else {\n          dotPath += key;\n        }\n      } else {\n        return null;\n      }\n    }\n    return dotPath;\n  }\n  return null;\n}\n\n// src/SchemaError/SchemaError.ts\nvar SchemaError = class extends Error {\n  /**\n   * The schema issues.\n   */\n  issues;\n  /**\n   * Creates a schema error with useful information.\n   *\n   * @param issues The schema issues.\n   */\n  constructor(issues) {\n    super(issues[0].message);\n    this.name = \"SchemaError\";\n    this.issues = issues;\n  }\n};\nexport {\n  SchemaError,\n  getDotPath\n};\n","import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { StandardSchemaV1 } from '@standard-schema/spec';\nimport { getDotPath } from '@standard-schema/utils';\nimport { FieldError, FieldValues, Resolver } from 'react-hook-form';\n\nfunction parseErrorSchema(\n  issues: readonly StandardSchemaV1.Issue[],\n  validateAllFieldCriteria: boolean,\n) {\n  const errors: Record<string, FieldError> = {};\n\n  for (let i = 0; i < issues.length; i++) {\n    const error = issues[i];\n    const path = getDotPath(error);\n\n    if (path) {\n      if (!errors[path]) {\n        errors[path] = { message: error.message, type: '' };\n      }\n\n      if (validateAllFieldCriteria) {\n        const types = errors[path].types || {};\n\n        errors[path].types = {\n          ...types,\n          [Object.keys(types).length]: error.message,\n        };\n      }\n    }\n  }\n\n  return errors;\n}\n\nexport function arktypeResolver<Input extends FieldValues, Context, Output>(\n  schema: StandardSchemaV1<Input, Output>,\n  _schemaOptions?: never,\n  resolverOptions?: {\n    raw?: false;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function arktypeResolver<Input extends FieldValues, Context, Output>(\n  schema: StandardSchemaV1<Input, Output>,\n  _schemaOptions: never | undefined,\n  resolverOptions: {\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Arktype schema validation\n * @param {Schema} schema - The Arktype schema to validate against\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {string} [resolverOptions.mode='raw'] - Return the raw input values rather than the parsed values\n * @returns {Resolver<Schema['inferOut']>} A resolver function compatible with react-hook-form\n * @example\n * const schema = type({\n *   username: 'string>2'\n * });\n *\n * useForm({\n *   resolver: arktypeResolver(schema)\n * });\n */\nexport function arktypeResolver<Input extends FieldValues, Context, Output>(\n  schema: StandardSchemaV1<Input, Output>,\n  _schemaOptions?: never,\n  resolverOptions: {\n    raw?: boolean;\n  } = {},\n): Resolver<Input, Context, Input | Output> {\n  return async (values: Input, _, options) => {\n    let result = schema['~standard'].validate(values);\n    if (result instanceof Promise) {\n      result = await result;\n    }\n\n    if (result.issues) {\n      const errors = parseErrorSchema(\n        result.issues,\n        !options.shouldUseNativeValidation && options.criteriaMode === 'all',\n      );\n\n      return {\n        values: {},\n        errors: toNestErrors(errors, options),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      values: resolverOptions.raw ? Object.assign({}, values) : result.value,\n      errors: {},\n    };\n  };\n}\n"],"names":["getDotPath","issue","path","length","dotPath","item","key","schema","_schemaOptions","resolverOptions","values","_","options","_temp2","result","issues","errors","validateAllFieldCriteria","i","error","message","type","_extends2","types","_extends","Object","keys","parseErrorSchema","shouldUseNativeValidation","criteriaMode","toNestErrors","validateFieldsNatively","raw","assign","value","validate","_temp","Promise","resolve","then","_result","e","reject"],"mappings":"qhBACA,SAASA,EAAWC,GAClB,GAAIA,EAAMC,MAAMC,OAAQ,CACtB,IAAIC,EAAU,GACd,IAAK,MAAMC,KAAQJ,EAAMC,KAAM,CAC7B,MAAMI,EAAsB,iBAATD,EAAoBA,EAAKC,IAAMD,EAClD,GAAmB,iBAARC,GAAmC,iBAARA,EAOpC,OAAO,KALLF,GADEA,EACS,IAAIE,IAEJA,CAKhB,CACD,OAAOF,CACR,CACD,OAAO,IACT,mBC8CM,SACJG,EACAC,EACAC,GAIA,gBAJAA,IAAAA,EAEI,CAAE,GAEQC,SAAAA,EAAeC,EAAGC,GAAO,IAAIC,IAAAA,aAMzC,GAAIC,EAAOC,OAAQ,CACjB,IAAMC,EA1EZ,SACED,EACAE,GAIA,IAFA,IAAMD,EAAqC,GAElCE,EAAI,EAAGA,EAAIH,EAAOZ,OAAQe,IAAK,CACtC,IAAMC,EAAQJ,EAAOG,GACfhB,EAAOF,EAAWmB,GAExB,GAAIjB,IACGc,EAAOd,KACVc,EAAOd,GAAQ,CAAEkB,QAASD,EAAMC,QAASC,KAAM,KAG7CJ,GAA0B,CAAAK,IAAAA,EACtBC,EAAQP,EAAOd,GAAMqB,OAAS,GAEpCP,EAAOd,GAAMqB,MAAKC,KACbD,IAAKD,EAAA,CAAA,GACPG,OAAOC,KAAKH,GAAOpB,QAASgB,EAAMC,QAAOE,GAE9C,CAEJ,CAEA,OAAON,CACT,CA+CqBW,CACbb,EAAOC,QACNH,EAAQgB,2BAAsD,QAAzBhB,EAAQiB,cAGhD,MAAO,CACLnB,OAAQ,CAAA,EACRM,OAAQc,eAAad,EAAQJ,GAEjC,CAIA,OAFAA,EAAQgB,2BAA6BG,EAAAA,uBAAuB,CAAA,EAAInB,GAEzD,CACLF,OAAQD,EAAgBuB,IAAMP,OAAOQ,OAAO,CAAA,EAAIvB,GAAUI,EAAOoB,MACjElB,OAAQ,CAAA,EACR,EAtBEF,EAASP,EAAO,aAAa4B,SAASzB,GAAQ0B,gBAC9CtB,aAAkBuB,QAAO,OAAAA,QAAAC,QACZxB,GAAMyB,KAAA,SAAAC,GAArB1B,EAAM0B,CAAgB,EAAAH,IAAAA,OAAAA,QAAAC,QAAAF,GAAAA,EAAAG,KAAAH,EAAAG,KAAA1B,GAAAA,IAqB1B,CAAC,MAAA4B,GAAAJ,OAAAA,QAAAK,OAAAD,EACH,CAAA,CAAA"}

package/arktype/package.json

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

package/arktype/src/__tests__/Form.tsx

@@ -10,8 +10,6 @@ const schema = type({
   password: 'string>1',
 });
 
-type FormData = typeof schema.infer & { unusedProperty: string };
-
 function TestComponent({
   onSubmit,
 }: {
@@ -54,29 +52,3 @@ test("form's validation with arkType and TypeScript's integration", async () =>
   ).toBeInTheDocument();
   expect(handleSubmit).not.toHaveBeenCalled();
 });
-
-export function TestComponentManualType({
-  onSubmit,
-}: {
-  onSubmit: (data: FormData) => void;
-}) {
-  const {
-    register,
-    handleSubmit,
-    formState: { errors },
-  } = useForm<typeof schema.infer, undefined, FormData>({
-    resolver: arktypeResolver(schema), // Useful to check TypeScript regressions
-  });
-
-  return (
-    <form onSubmit={handleSubmit(onSubmit)}>
-      <input {...register('username')} />
-      {errors.username && <span role="alert">{errors.username.message}</span>}
-
-      <input {...register('password')} />
-      {errors.password && <span role="alert">{errors.password.message}</span>}
-
-      <button type="submit">submit</button>
-    </form>
-  );
-}

package/arktype/src/__tests__/arktype.ts

@@ -1,3 +1,6 @@
+import { type } from 'arktype';
+import { Resolver, useForm } from 'react-hook-form';
+import { SubmitHandler } from 'react-hook-form';
 import { arktypeResolver } from '..';
 import { fields, invalidData, schema, validData } from './__fixtures__/data';
 
@@ -23,4 +26,57 @@ describe('arktypeResolver', () => {
 
     expect(result).toMatchSnapshot();
   });
+
+  /**
+   * Type inference tests
+   */
+  it('should correctly infer the output type from a arktype schema', () => {
+    const resolver = arktypeResolver(type({ id: 'number' }));
+
+    expectTypeOf(resolver).toEqualTypeOf<
+      Resolver<{ id: number }, unknown, { id: number }>
+    >();
+  });
+
+  it('should correctly infer the output type from a arktype schema using a transform', () => {
+    const resolver = arktypeResolver(
+      type({ id: type('string').pipe((s) => Number.parseInt(s)) }),
+    );
+
+    expectTypeOf(resolver).toEqualTypeOf<
+      Resolver<{ id: string }, unknown, { id: number }>
+    >();
+  });
+
+  it('should correctly infer the output type from a arktype schema for the handleSubmit function in useForm', () => {
+    const schema = type({ id: 'number' });
+
+    const form = useForm({
+      resolver: arktypeResolver(schema),
+    });
+
+    expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
+
+    expectTypeOf(form.handleSubmit).parameter(0).toEqualTypeOf<
+      SubmitHandler<{
+        id: number;
+      }>
+    >();
+  });
+
+  it('should correctly infer the output type from a arktype schema with a transform for the handleSubmit function in useForm', () => {
+    const schema = type({ id: type('string').pipe((s) => Number.parseInt(s)) });
+
+    const form = useForm({
+      resolver: arktypeResolver(schema),
+    });
+
+    expectTypeOf(form.watch('id')).toEqualTypeOf<string>();
+
+    expectTypeOf(form.handleSubmit).parameter(0).toEqualTypeOf<
+      SubmitHandler<{
+        id: number;
+      }>
+    >();
+  });
 });

package/arktype/src/arktype.ts

@@ -1,25 +1,53 @@
 import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';
-import { ArkErrors, Type } from 'arktype';
-import { FieldError, FieldErrors, Resolver } from 'react-hook-form';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { getDotPath } from '@standard-schema/utils';
+import { FieldError, FieldValues, Resolver } from 'react-hook-form';
 
-function parseErrorSchema(arkErrors: ArkErrors): Record<string, FieldError> {
-  const errors = [...arkErrors];
-  const fieldsErrors: Record<string, FieldError> = {};
+function parseErrorSchema(
+  issues: readonly StandardSchemaV1.Issue[],
+  validateAllFieldCriteria: boolean,
+) {
+  const errors: Record<string, FieldError> = {};
 
-  for (; errors.length; ) {
-    const error = errors[0];
-    const _path = error.path.join('.');
+  for (let i = 0; i < issues.length; i++) {
+    const error = issues[i];
+    const path = getDotPath(error);
 
-    if (!fieldsErrors[_path]) {
-      fieldsErrors[_path] = { message: error.message, type: error.code };
-    }
+    if (path) {
+      if (!errors[path]) {
+        errors[path] = { message: error.message, type: '' };
+      }
+
+      if (validateAllFieldCriteria) {
+        const types = errors[path].types || {};
 
-    errors.shift();
+        errors[path].types = {
+          ...types,
+          [Object.keys(types).length]: error.message,
+        };
+      }
+    }
   }
 
-  return fieldsErrors;
+  return errors;
 }
 
+export function arktypeResolver<Input extends FieldValues, Context, Output>(
+  schema: StandardSchemaV1<Input, Output>,
+  _schemaOptions?: never,
+  resolverOptions?: {
+    raw?: false;
+  },
+): Resolver<Input, Context, Output>;
+
+export function arktypeResolver<Input extends FieldValues, Context, Output>(
+  schema: StandardSchemaV1<Input, Output>,
+  _schemaOptions: never | undefined,
+  resolverOptions: {
+    raw: true;
+  },
+): Resolver<Input, Context, Input>;
+
 /**
  * Creates a resolver for react-hook-form using Arktype schema validation
  * @param {Schema} schema - The Arktype schema to validate against
@@ -35,28 +63,36 @@ function parseErrorSchema(arkErrors: ArkErrors): Record<string, FieldError> {
  *   resolver: arktypeResolver(schema)
  * });
  */
-export function arktypeResolver<Schema extends Type<any, any>>(
-  schema: Schema,
+export function arktypeResolver<Input extends FieldValues, Context, Output>(
+  schema: StandardSchemaV1<Input, Output>,
   _schemaOptions?: never,
   resolverOptions: {
     raw?: boolean;
   } = {},
-): Resolver<Schema['inferOut']> {
-  return (values, _, options) => {
-    const out = schema(values);
+): Resolver<Input, Context, Input | Output> {
+  return async (values: Input, _, options) => {
+    let result = schema['~standard'].validate(values);
+    if (result instanceof Promise) {
+      result = await result;
+    }
+
+    if (result.issues) {
+      const errors = parseErrorSchema(
+        result.issues,
+        !options.shouldUseNativeValidation && options.criteriaMode === 'all',
+      );
 
-    if (out instanceof ArkErrors) {
       return {
         values: {},
-        errors: toNestErrors(parseErrorSchema(out), options),
+        errors: toNestErrors(errors, options),
       };
     }
 
     options.shouldUseNativeValidation && validateFieldsNatively({}, options);
 
     return {
-      errors: {} as FieldErrors,
-      values: resolverOptions.raw ? Object.assign({}, values) : out,
+      values: resolverOptions.raw ? Object.assign({}, values) : result.value,
+      errors: {},
     };
   };
 }

package/class-validator/src/__tests__/Form.tsx

@@ -51,29 +51,3 @@ test("form's validation with Class Validator and TypeScript's integration", asyn
   expect(screen.getByText(/password should not be empty/i)).toBeInTheDocument();
   expect(handleSubmit).not.toHaveBeenCalled();
 });
-
-export function TestComponentManualType({
-  onSubmit,
-}: {
-  onSubmit: (data: FormData) => void;
-}) {
-  const {
-    register,
-    handleSubmit,
-    formState: { errors },
-  } = useForm<Schema, undefined, FormData>({
-    resolver: classValidatorResolver(Schema), // Useful to check TypeScript regressions
-  });
-
-  return (
-    <form onSubmit={handleSubmit(onSubmit)}>
-      <input {...register('username')} />
-      {errors.username && <span role="alert">{errors.username.message}</span>}
-
-      <input {...register('password')} />
-      {errors.password && <span role="alert">{errors.password.message}</span>}
-
-      <button type="submit">submit</button>
-    </form>
-  );
-}

package/computed-types/dist/computed-types.d.ts

@@ -1,6 +1,5 @@
-import { Type } from 'computed-types';
 import FunctionType from 'computed-types/lib/schema/FunctionType';
-import type { Resolver } from 'react-hook-form';
+import type { FieldValues, Resolver } from 'react-hook-form';
 /**
  * Creates a resolver for react-hook-form using computed-types schema validation
  * @param {Schema} schema - The computed-types schema to validate against
@@ -15,4 +14,4 @@ import type { Resolver } from 'react-hook-form';
  *   resolver: computedTypesResolver(schema)
  * });
  */
-export declare function computedTypesResolver<Schema extends FunctionType<any, any>>(schema: Schema): Resolver<Type<typeof schema>>;
+export declare function computedTypesResolver<Input extends FieldValues, Context, Output>(schema: FunctionType<Output, [Input]>): Resolver<Input, Context, Output>;

package/computed-types/dist/computed-types.js.map

@@ -1 +1 @@
-{"version":3,"file":"computed-types.js","sources":["../src/computed-types.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { Type, ValidationError } from 'computed-types';\nimport FunctionType from 'computed-types/lib/schema/FunctionType';\nimport type { FieldErrors, Resolver } from 'react-hook-form';\n\nconst isValidationError = (error: any): error is ValidationError =>\n  error.errors != null;\n\nfunction parseErrorSchema(computedTypesError: ValidationError) {\n  const parsedErrors: FieldErrors = {};\n  return (computedTypesError.errors || []).reduce((acc, error) => {\n    acc[error.path.join('.')] = {\n      type: error.error.name,\n      message: error.error.message,\n    };\n\n    return acc;\n  }, parsedErrors);\n}\n\n/**\n * Creates a resolver for react-hook-form using computed-types schema validation\n * @param {Schema} schema - The computed-types schema to validate against\n * @returns {Resolver<Type<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Schema({\n *   name: string,\n *   age: number\n * });\n *\n * useForm({\n *   resolver: computedTypesResolver(schema)\n * });\n */\nexport function computedTypesResolver<Schema extends FunctionType<any, any>>(\n  schema: Schema,\n): Resolver<Type<typeof schema>> {\n  return async (values, _, options) => {\n    try {\n      const data = await schema(values);\n\n      options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n      return {\n        errors: {},\n        values: data,\n      };\n    } catch (error: any) {\n      if (isValidationError(error)) {\n        return {\n          values: {},\n          errors: toNestErrors(parseErrorSchema(error), options),\n        };\n      }\n\n      throw error;\n    }\n  };\n}\n"],"names":["schema","values","_","options","Promise","resolve","then","data","shouldUseNativeValidation","validateFieldsNatively","errors","_catch","error","isValidationError","toNestErrors","computedTypesError","reduce","acc","path","join","type","name","message","e","reject"],"mappings":"mEAkCM,SACJA,GAEA,OAAcC,SAAAA,EAAQC,EAAGC,GAAW,IAAA,OAAAC,QAAAC,gCAC9BD,QAAAC,QACiBL,EAAOC,IAAOK,KAAA,SAA3BC,GAIN,OAFAJ,EAAQK,2BAA6BC,EAAAA,uBAAuB,CAAA,EAAIN,GAEzD,CACLO,OAAQ,CAAA,EACRT,OAAQM,EACR,4DAT8BI,CAAA,EAUjC,SAAQC,GACP,GA3CoB,SAACA,GACzB,OAAgB,MAAhBA,EAAMF,MAAc,CA0CZG,CAAkBD,GACpB,MAAO,CACLX,OAAQ,CAAE,EACVS,OAAQI,gBA3CQC,EA2CsBH,GAzCtCG,EAAmBL,QAAU,IAAIM,OAAO,SAACC,EAAKL,GAMpD,OALAK,EAAIL,EAAMM,KAAKC,KAAK,MAAQ,CAC1BC,KAAMR,EAAMA,MAAMS,KAClBC,QAASV,EAAMA,MAAMU,SAGhBL,CACT,EARkC,CAAE,IA0CkBd,IA3CxD,IAA0BY,EA+CpB,MAAMH,CACR,GACF,CAAC,MAAAW,GAAAnB,OAAAA,QAAAoB,OAAAD,EACH,CAAA,CAAA"}
+{"version":3,"file":"computed-types.js","sources":["../src/computed-types.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { ValidationError } from 'computed-types';\nimport FunctionType from 'computed-types/lib/schema/FunctionType';\nimport type { FieldErrors, FieldValues, Resolver } from 'react-hook-form';\n\nconst isValidationError = (error: any): error is ValidationError =>\n  error.errors != null;\n\nfunction parseErrorSchema(computedTypesError: ValidationError) {\n  const parsedErrors: FieldErrors = {};\n  return (computedTypesError.errors || []).reduce((acc, error) => {\n    acc[error.path.join('.')] = {\n      type: error.error.name,\n      message: error.error.message,\n    };\n\n    return acc;\n  }, parsedErrors);\n}\n\n/**\n * Creates a resolver for react-hook-form using computed-types schema validation\n * @param {Schema} schema - The computed-types schema to validate against\n * @returns {Resolver<Type<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Schema({\n *   name: string,\n *   age: number\n * });\n *\n * useForm({\n *   resolver: computedTypesResolver(schema)\n * });\n */\nexport function computedTypesResolver<\n  Input extends FieldValues,\n  Context,\n  Output,\n>(schema: FunctionType<Output, [Input]>): Resolver<Input, Context, Output> {\n  return async (values, _, options) => {\n    try {\n      const data = await schema(values);\n\n      options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n      return {\n        errors: {},\n        values: data,\n      };\n    } catch (error: any) {\n      if (isValidationError(error)) {\n        return {\n          values: {},\n          errors: toNestErrors(parseErrorSchema(error), options),\n        };\n      }\n\n      throw error;\n    }\n  };\n}\n"],"names":["schema","values","_","options","Promise","resolve","then","data","shouldUseNativeValidation","validateFieldsNatively","errors","_catch","error","isValidationError","toNestErrors","computedTypesError","reduce","acc","path","join","type","name","message","e","reject"],"mappings":"mEAkCM,SAIJA,GACA,OAAcC,SAAAA,EAAQC,EAAGC,GAAW,IAAA,OAAAC,QAAAC,gCAC9BD,QAAAC,QACiBL,EAAOC,IAAOK,KAAA,SAA3BC,GAIN,OAFAJ,EAAQK,2BAA6BC,EAAAA,uBAAuB,CAAA,EAAIN,GAEzD,CACLO,OAAQ,CAAA,EACRT,OAAQM,EACR,4DAT8BI,CAAA,EAUjC,SAAQC,GACP,GA7CoB,SAACA,GACzB,OAAgB,MAAhBA,EAAMF,MAAc,CA4CZG,CAAkBD,GACpB,MAAO,CACLX,OAAQ,CAAE,EACVS,OAAQI,gBA7CQC,EA6CsBH,GA3CtCG,EAAmBL,QAAU,IAAIM,OAAO,SAACC,EAAKL,GAMpD,OALAK,EAAIL,EAAMM,KAAKC,KAAK,MAAQ,CAC1BC,KAAMR,EAAMA,MAAMS,KAClBC,QAASV,EAAMA,MAAMU,SAGhBL,CACT,EARkC,CAAE,IA4CkBd,IA7CxD,IAA0BY,EAiDpB,MAAMH,CACR,GACF,CAAC,MAAAW,GAAAnB,OAAAA,QAAAoB,OAAAD,EACH,CAAA,CAAA"}

package/computed-types/dist/computed-types.modern.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"computed-types.modern.mjs","sources":["../src/computed-types.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { Type, ValidationError } from 'computed-types';\nimport FunctionType from 'computed-types/lib/schema/FunctionType';\nimport type { FieldErrors, Resolver } from 'react-hook-form';\n\nconst isValidationError = (error: any): error is ValidationError =>\n  error.errors != null;\n\nfunction parseErrorSchema(computedTypesError: ValidationError) {\n  const parsedErrors: FieldErrors = {};\n  return (computedTypesError.errors || []).reduce((acc, error) => {\n    acc[error.path.join('.')] = {\n      type: error.error.name,\n      message: error.error.message,\n    };\n\n    return acc;\n  }, parsedErrors);\n}\n\n/**\n * Creates a resolver for react-hook-form using computed-types schema validation\n * @param {Schema} schema - The computed-types schema to validate against\n * @returns {Resolver<Type<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Schema({\n *   name: string,\n *   age: number\n * });\n *\n * useForm({\n *   resolver: computedTypesResolver(schema)\n * });\n */\nexport function computedTypesResolver<Schema extends FunctionType<any, any>>(\n  schema: Schema,\n): Resolver<Type<typeof schema>> {\n  return async (values, _, options) => {\n    try {\n      const data = await schema(values);\n\n      options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n      return {\n        errors: {},\n        values: data,\n      };\n    } catch (error: any) {\n      if (isValidationError(error)) {\n        return {\n          values: {},\n          errors: toNestErrors(parseErrorSchema(error), options),\n        };\n      }\n\n      throw error;\n    }\n  };\n}\n"],"names":["computedTypesResolver","schema","values","_","options","data","shouldUseNativeValidation","validateFieldsNatively","errors","error","isValidationError","toNestErrors","computedTypesError","reduce","acc","path","join","type","name","message"],"mappings":"+EAkCgB,SAAAA,EACdC,GAEA,aAAcC,EAAQC,EAAGC,KACvB,IACE,MAAMC,QAAaJ,EAAOC,GAI1B,OAFAE,EAAQE,2BAA6BC,EAAuB,CAAA,EAAIH,GAEzD,CACLI,OAAQ,CAAE,EACVN,OAAQG,EAEZ,CAAE,MAAOI,GACP,GA3CqBA,IACT,MAAhBA,EAAMD,OA0CEE,CAAkBD,GACpB,MAAO,CACLP,OAAQ,CAAE,EACVM,OAAQG,GA3CQC,EA2CsBH,GAzCtCG,EAAmBJ,QAAU,IAAIK,OAAO,CAACC,EAAKL,KACpDK,EAAIL,EAAMM,KAAKC,KAAK,MAAQ,CAC1BC,KAAMR,EAAMA,MAAMS,KAClBC,QAASV,EAAMA,MAAMU,SAGhBL,GAPyB,KA0CoBV,IAIlD,MAAMK,CACR,CAhDJ,IAA0BG,CAgDtB,CAEJ"}
+{"version":3,"file":"computed-types.modern.mjs","sources":["../src/computed-types.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { ValidationError } from 'computed-types';\nimport FunctionType from 'computed-types/lib/schema/FunctionType';\nimport type { FieldErrors, FieldValues, Resolver } from 'react-hook-form';\n\nconst isValidationError = (error: any): error is ValidationError =>\n  error.errors != null;\n\nfunction parseErrorSchema(computedTypesError: ValidationError) {\n  const parsedErrors: FieldErrors = {};\n  return (computedTypesError.errors || []).reduce((acc, error) => {\n    acc[error.path.join('.')] = {\n      type: error.error.name,\n      message: error.error.message,\n    };\n\n    return acc;\n  }, parsedErrors);\n}\n\n/**\n * Creates a resolver for react-hook-form using computed-types schema validation\n * @param {Schema} schema - The computed-types schema to validate against\n * @returns {Resolver<Type<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Schema({\n *   name: string,\n *   age: number\n * });\n *\n * useForm({\n *   resolver: computedTypesResolver(schema)\n * });\n */\nexport function computedTypesResolver<\n  Input extends FieldValues,\n  Context,\n  Output,\n>(schema: FunctionType<Output, [Input]>): Resolver<Input, Context, Output> {\n  return async (values, _, options) => {\n    try {\n      const data = await schema(values);\n\n      options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n      return {\n        errors: {},\n        values: data,\n      };\n    } catch (error: any) {\n      if (isValidationError(error)) {\n        return {\n          values: {},\n          errors: toNestErrors(parseErrorSchema(error), options),\n        };\n      }\n\n      throw error;\n    }\n  };\n}\n"],"names":["computedTypesResolver","schema","values","_","options","data","shouldUseNativeValidation","validateFieldsNatively","errors","error","isValidationError","toNestErrors","computedTypesError","reduce","acc","path","join","type","name","message"],"mappings":"+EAkCgB,SAAAA,EAIdC,GACA,aAAcC,EAAQC,EAAGC,KACvB,IACE,MAAMC,QAAaJ,EAAOC,GAI1B,OAFAE,EAAQE,2BAA6BC,EAAuB,CAAA,EAAIH,GAEzD,CACLI,OAAQ,CAAE,EACVN,OAAQG,EAEZ,CAAE,MAAOI,GACP,GA7CqBA,IACT,MAAhBA,EAAMD,OA4CEE,CAAkBD,GACpB,MAAO,CACLP,OAAQ,CAAE,EACVM,OAAQG,GA7CQC,EA6CsBH,GA3CtCG,EAAmBJ,QAAU,IAAIK,OAAO,CAACC,EAAKL,KACpDK,EAAIL,EAAMM,KAAKC,KAAK,MAAQ,CAC1BC,KAAMR,EAAMA,MAAMS,KAClBC,QAASV,EAAMA,MAAMU,SAGhBL,GAPyB,KA4CoBV,IAIlD,MAAMK,CACR,CAlDJ,IAA0BG,CAkDtB,CAEJ"}

package/computed-types/dist/computed-types.module.js.map

@@ -1 +1 @@
-{"version":3,"file":"computed-types.module.js","sources":["../src/computed-types.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { Type, ValidationError } from 'computed-types';\nimport FunctionType from 'computed-types/lib/schema/FunctionType';\nimport type { FieldErrors, Resolver } from 'react-hook-form';\n\nconst isValidationError = (error: any): error is ValidationError =>\n  error.errors != null;\n\nfunction parseErrorSchema(computedTypesError: ValidationError) {\n  const parsedErrors: FieldErrors = {};\n  return (computedTypesError.errors || []).reduce((acc, error) => {\n    acc[error.path.join('.')] = {\n      type: error.error.name,\n      message: error.error.message,\n    };\n\n    return acc;\n  }, parsedErrors);\n}\n\n/**\n * Creates a resolver for react-hook-form using computed-types schema validation\n * @param {Schema} schema - The computed-types schema to validate against\n * @returns {Resolver<Type<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Schema({\n *   name: string,\n *   age: number\n * });\n *\n * useForm({\n *   resolver: computedTypesResolver(schema)\n * });\n */\nexport function computedTypesResolver<Schema extends FunctionType<any, any>>(\n  schema: Schema,\n): Resolver<Type<typeof schema>> {\n  return async (values, _, options) => {\n    try {\n      const data = await schema(values);\n\n      options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n      return {\n        errors: {},\n        values: data,\n      };\n    } catch (error: any) {\n      if (isValidationError(error)) {\n        return {\n          values: {},\n          errors: toNestErrors(parseErrorSchema(error), options),\n        };\n      }\n\n      throw error;\n    }\n  };\n}\n"],"names":["computedTypesResolver","schema","values","_","options","Promise","resolve","then","data","shouldUseNativeValidation","validateFieldsNatively","errors","_catch","error","isValidationError","toNestErrors","computedTypesError","reduce","acc","path","join","type","name","message","e","reject"],"mappings":"+EAkCM,SAAUA,EACdC,GAEA,OAAcC,SAAAA,EAAQC,EAAGC,GAAW,IAAA,OAAAC,QAAAC,gCAC9BD,QAAAC,QACiBL,EAAOC,IAAOK,KAAA,SAA3BC,GAIN,OAFAJ,EAAQK,2BAA6BC,EAAuB,CAAA,EAAIN,GAEzD,CACLO,OAAQ,CAAA,EACRT,OAAQM,EACR,4DAT8BI,CAAA,EAUjC,SAAQC,GACP,GA3CoB,SAACA,GACzB,OAAgB,MAAhBA,EAAMF,MAAc,CA0CZG,CAAkBD,GACpB,MAAO,CACLX,OAAQ,CAAE,EACVS,OAAQI,GA3CQC,EA2CsBH,GAzCtCG,EAAmBL,QAAU,IAAIM,OAAO,SAACC,EAAKL,GAMpD,OALAK,EAAIL,EAAMM,KAAKC,KAAK,MAAQ,CAC1BC,KAAMR,EAAMA,MAAMS,KAClBC,QAASV,EAAMA,MAAMU,SAGhBL,CACT,EARkC,CAAE,IA0CkBd,IA3CxD,IAA0BY,EA+CpB,MAAMH,CACR,GACF,CAAC,MAAAW,GAAAnB,OAAAA,QAAAoB,OAAAD,EACH,CAAA,CAAA"}
+{"version":3,"file":"computed-types.module.js","sources":["../src/computed-types.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { ValidationError } from 'computed-types';\nimport FunctionType from 'computed-types/lib/schema/FunctionType';\nimport type { FieldErrors, FieldValues, Resolver } from 'react-hook-form';\n\nconst isValidationError = (error: any): error is ValidationError =>\n  error.errors != null;\n\nfunction parseErrorSchema(computedTypesError: ValidationError) {\n  const parsedErrors: FieldErrors = {};\n  return (computedTypesError.errors || []).reduce((acc, error) => {\n    acc[error.path.join('.')] = {\n      type: error.error.name,\n      message: error.error.message,\n    };\n\n    return acc;\n  }, parsedErrors);\n}\n\n/**\n * Creates a resolver for react-hook-form using computed-types schema validation\n * @param {Schema} schema - The computed-types schema to validate against\n * @returns {Resolver<Type<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Schema({\n *   name: string,\n *   age: number\n * });\n *\n * useForm({\n *   resolver: computedTypesResolver(schema)\n * });\n */\nexport function computedTypesResolver<\n  Input extends FieldValues,\n  Context,\n  Output,\n>(schema: FunctionType<Output, [Input]>): Resolver<Input, Context, Output> {\n  return async (values, _, options) => {\n    try {\n      const data = await schema(values);\n\n      options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n      return {\n        errors: {},\n        values: data,\n      };\n    } catch (error: any) {\n      if (isValidationError(error)) {\n        return {\n          values: {},\n          errors: toNestErrors(parseErrorSchema(error), options),\n        };\n      }\n\n      throw error;\n    }\n  };\n}\n"],"names":["computedTypesResolver","schema","values","_","options","Promise","resolve","then","data","shouldUseNativeValidation","validateFieldsNatively","errors","_catch","error","isValidationError","toNestErrors","computedTypesError","reduce","acc","path","join","type","name","message","e","reject"],"mappings":"+EAkCM,SAAUA,EAIdC,GACA,OAAcC,SAAAA,EAAQC,EAAGC,GAAW,IAAA,OAAAC,QAAAC,gCAC9BD,QAAAC,QACiBL,EAAOC,IAAOK,KAAA,SAA3BC,GAIN,OAFAJ,EAAQK,2BAA6BC,EAAuB,CAAA,EAAIN,GAEzD,CACLO,OAAQ,CAAA,EACRT,OAAQM,EACR,4DAT8BI,CAAA,EAUjC,SAAQC,GACP,GA7CoB,SAACA,GACzB,OAAgB,MAAhBA,EAAMF,MAAc,CA4CZG,CAAkBD,GACpB,MAAO,CACLX,OAAQ,CAAE,EACVS,OAAQI,GA7CQC,EA6CsBH,GA3CtCG,EAAmBL,QAAU,IAAIM,OAAO,SAACC,EAAKL,GAMpD,OALAK,EAAIL,EAAMM,KAAKC,KAAK,MAAQ,CAC1BC,KAAMR,EAAMA,MAAMS,KAClBC,QAASV,EAAMA,MAAMU,SAGhBL,CACT,EARkC,CAAE,IA4CkBd,IA7CxD,IAA0BY,EAiDpB,MAAMH,CACR,GACF,CAAC,MAAAW,GAAAnB,OAAAA,QAAAoB,OAAAD,EACH,CAAA,CAAA"}

package/computed-types/dist/computed-types.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"computed-types.umd.js","sources":["../src/computed-types.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { Type, ValidationError } from 'computed-types';\nimport FunctionType from 'computed-types/lib/schema/FunctionType';\nimport type { FieldErrors, Resolver } from 'react-hook-form';\n\nconst isValidationError = (error: any): error is ValidationError =>\n  error.errors != null;\n\nfunction parseErrorSchema(computedTypesError: ValidationError) {\n  const parsedErrors: FieldErrors = {};\n  return (computedTypesError.errors || []).reduce((acc, error) => {\n    acc[error.path.join('.')] = {\n      type: error.error.name,\n      message: error.error.message,\n    };\n\n    return acc;\n  }, parsedErrors);\n}\n\n/**\n * Creates a resolver for react-hook-form using computed-types schema validation\n * @param {Schema} schema - The computed-types schema to validate against\n * @returns {Resolver<Type<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Schema({\n *   name: string,\n *   age: number\n * });\n *\n * useForm({\n *   resolver: computedTypesResolver(schema)\n * });\n */\nexport function computedTypesResolver<Schema extends FunctionType<any, any>>(\n  schema: Schema,\n): Resolver<Type<typeof schema>> {\n  return async (values, _, options) => {\n    try {\n      const data = await schema(values);\n\n      options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n      return {\n        errors: {},\n        values: data,\n      };\n    } catch (error: any) {\n      if (isValidationError(error)) {\n        return {\n          values: {},\n          errors: toNestErrors(parseErrorSchema(error), options),\n        };\n      }\n\n      throw error;\n    }\n  };\n}\n"],"names":["schema","values","_","options","Promise","resolve","then","data","shouldUseNativeValidation","validateFieldsNatively","errors","_catch","error","isValidationError","toNestErrors","computedTypesError","reduce","acc","path","join","type","name","message","e","reject"],"mappings":"2VAkCM,SACJA,GAEA,OAAcC,SAAAA,EAAQC,EAAGC,GAAW,IAAA,OAAAC,QAAAC,gCAC9BD,QAAAC,QACiBL,EAAOC,IAAOK,KAAA,SAA3BC,GAIN,OAFAJ,EAAQK,2BAA6BC,EAAAA,uBAAuB,CAAA,EAAIN,GAEzD,CACLO,OAAQ,CAAA,EACRT,OAAQM,EACR,4DAT8BI,CAAA,EAUjC,SAAQC,GACP,GA3CoB,SAACA,GACzB,OAAgB,MAAhBA,EAAMF,MAAc,CA0CZG,CAAkBD,GACpB,MAAO,CACLX,OAAQ,CAAE,EACVS,OAAQI,gBA3CQC,EA2CsBH,GAzCtCG,EAAmBL,QAAU,IAAIM,OAAO,SAACC,EAAKL,GAMpD,OALAK,EAAIL,EAAMM,KAAKC,KAAK,MAAQ,CAC1BC,KAAMR,EAAMA,MAAMS,KAClBC,QAASV,EAAMA,MAAMU,SAGhBL,CACT,EARkC,CAAE,IA0CkBd,IA3CxD,IAA0BY,EA+CpB,MAAMH,CACR,GACF,CAAC,MAAAW,GAAAnB,OAAAA,QAAAoB,OAAAD,EACH,CAAA,CAAA"}
+{"version":3,"file":"computed-types.umd.js","sources":["../src/computed-types.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { ValidationError } from 'computed-types';\nimport FunctionType from 'computed-types/lib/schema/FunctionType';\nimport type { FieldErrors, FieldValues, Resolver } from 'react-hook-form';\n\nconst isValidationError = (error: any): error is ValidationError =>\n  error.errors != null;\n\nfunction parseErrorSchema(computedTypesError: ValidationError) {\n  const parsedErrors: FieldErrors = {};\n  return (computedTypesError.errors || []).reduce((acc, error) => {\n    acc[error.path.join('.')] = {\n      type: error.error.name,\n      message: error.error.message,\n    };\n\n    return acc;\n  }, parsedErrors);\n}\n\n/**\n * Creates a resolver for react-hook-form using computed-types schema validation\n * @param {Schema} schema - The computed-types schema to validate against\n * @returns {Resolver<Type<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Schema({\n *   name: string,\n *   age: number\n * });\n *\n * useForm({\n *   resolver: computedTypesResolver(schema)\n * });\n */\nexport function computedTypesResolver<\n  Input extends FieldValues,\n  Context,\n  Output,\n>(schema: FunctionType<Output, [Input]>): Resolver<Input, Context, Output> {\n  return async (values, _, options) => {\n    try {\n      const data = await schema(values);\n\n      options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n      return {\n        errors: {},\n        values: data,\n      };\n    } catch (error: any) {\n      if (isValidationError(error)) {\n        return {\n          values: {},\n          errors: toNestErrors(parseErrorSchema(error), options),\n        };\n      }\n\n      throw error;\n    }\n  };\n}\n"],"names":["schema","values","_","options","Promise","resolve","then","data","shouldUseNativeValidation","validateFieldsNatively","errors","_catch","error","isValidationError","toNestErrors","computedTypesError","reduce","acc","path","join","type","name","message","e","reject"],"mappings":"2VAkCM,SAIJA,GACA,OAAcC,SAAAA,EAAQC,EAAGC,GAAW,IAAA,OAAAC,QAAAC,gCAC9BD,QAAAC,QACiBL,EAAOC,IAAOK,KAAA,SAA3BC,GAIN,OAFAJ,EAAQK,2BAA6BC,EAAAA,uBAAuB,CAAA,EAAIN,GAEzD,CACLO,OAAQ,CAAA,EACRT,OAAQM,EACR,4DAT8BI,CAAA,EAUjC,SAAQC,GACP,GA7CoB,SAACA,GACzB,OAAgB,MAAhBA,EAAMF,MAAc,CA4CZG,CAAkBD,GACpB,MAAO,CACLX,OAAQ,CAAE,EACVS,OAAQI,gBA7CQC,EA6CsBH,GA3CtCG,EAAmBL,QAAU,IAAIM,OAAO,SAACC,EAAKL,GAMpD,OALAK,EAAIL,EAAMM,KAAKC,KAAK,MAAQ,CAC1BC,KAAMR,EAAMA,MAAMS,KAClBC,QAASV,EAAMA,MAAMU,SAGhBL,CACT,EARkC,CAAE,IA4CkBd,IA7CxD,IAA0BY,EAiDpB,MAAMH,CACR,GACF,CAAC,MAAAW,GAAAnB,OAAAA,QAAAoB,OAAAD,EACH,CAAA,CAAA"}

package/computed-types/package.json

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