@hookform/resolvers 3.10.0 → 4.1.0

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

@@ -3,463 +3,70 @@
 exports[`arktypeResolver > should return a single error from arktypeResolver when validation fails 1`] = `
 {
   "errors": {
-    "accessToken": ArkError {
-      "code": "required",
-      "data": {
-        "birthYear": "birthYear",
-        "email": "",
-        "like": [
-          {
-            "id": "z",
-          },
-        ],
-        "password": "___",
-        "url": "abc",
-      },
-      "input": {
-        "code": "required",
-        "missingValueDescription": "a number or a string",
-        "relativePath": [
-          "accessToken",
-        ],
-      },
-      "missingValueDescription": "a number or a string",
-      "nodeConfig": {
-        "actual": [Function],
-        "description": [Function],
-        "expected": [Function],
-        "message": [Function],
-        "problem": [Function],
-      },
-      "path": [
-        "accessToken",
-      ],
+    "accessToken": {
+      "message": "accessToken must be a number or a string (was missing)",
       "ref": undefined,
-      "relativePath": [
-        "accessToken",
-      ],
       "type": "required",
-      Symbol(ArkTypeInternalKind): "error",
     },
-    "birthYear": ArkError {
-      "code": "domain",
-      "data": "birthYear",
-      "description": "a number",
-      "domain": "number",
-      "input": {
-        "code": "domain",
-        "description": "a number",
-        "domain": "number",
-      },
-      "nodeConfig": {
-        "actual": [Function],
-        "description": [Function],
-        "expected": [Function],
-        "message": [Function],
-        "problem": [Function],
-      },
-      "path": [
-        "birthYear",
-      ],
+    "birthYear": {
+      "message": "birthYear must be a number (was a string)",
       "ref": undefined,
       "type": "domain",
-      Symbol(ArkTypeInternalKind): "error",
     },
-    "dateStr": ArkError {
-      "code": "required",
-      "data": {
-        "birthYear": "birthYear",
-        "email": "",
-        "like": [
-          {
-            "id": "z",
-          },
-        ],
-        "password": "___",
-        "url": "abc",
-      },
-      "input": {
-        "code": "required",
-        "missingValueDescription": "a Date",
-        "relativePath": [
-          "dateStr",
-        ],
-      },
-      "missingValueDescription": "a Date",
-      "nodeConfig": {
-        "actual": [Function],
-        "description": [Function],
-        "expected": [Function],
-        "message": [Function],
-        "problem": [Function],
-      },
-      "path": [
-        "dateStr",
-      ],
+    "dateStr": {
+      "message": "dateStr must be a Date (was missing)",
       "ref": undefined,
-      "relativePath": [
-        "dateStr",
-      ],
       "type": "required",
-      Symbol(ArkTypeInternalKind): "error",
     },
-    "email": ArkError {
-      "code": "pattern",
-      "data": "",
-      "description": "a valid email",
-      "flags": "",
-      "input": {
-        "code": "pattern",
-        "description": "a valid email",
-        "flags": "",
-        "rule": "^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}$",
-      },
-      "nodeConfig": {
-        "actual": [Function],
-        "description": [Function],
-        "expected": [Function],
-        "message": [Function],
-        "problem": [Function],
-      },
-      "path": [
-        "email",
-      ],
+    "email": {
+      "message": "email must be an email address (was "")",
       "ref": {
         "name": "email",
       },
-      "rule": "^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}$",
       "type": "pattern",
-      Symbol(ArkTypeInternalKind): "error",
     },
-    "enabled": ArkError {
-      "code": "required",
-      "data": {
-        "birthYear": "birthYear",
-        "email": "",
-        "like": [
-          {
-            "id": "z",
-          },
-        ],
-        "password": "___",
-        "url": "abc",
-      },
-      "input": {
-        "code": "required",
-        "missingValueDescription": "boolean",
-        "relativePath": [
-          "enabled",
-        ],
-      },
-      "missingValueDescription": "boolean",
-      "nodeConfig": {
-        "actual": [Function],
-        "description": [Function],
-        "expected": [Function],
-        "message": [Function],
-        "problem": [Function],
-      },
-      "path": [
-        "enabled",
-      ],
+    "enabled": {
+      "message": "enabled must be boolean (was missing)",
       "ref": undefined,
-      "relativePath": [
-        "enabled",
-      ],
       "type": "required",
-      Symbol(ArkTypeInternalKind): "error",
     },
     "like": [
       {
-        "id": ArkError {
-          "code": "domain",
-          "data": "z",
-          "description": "a number",
-          "domain": "number",
-          "input": {
-            "code": "domain",
-            "description": "a number",
-            "domain": "number",
-          },
-          "nodeConfig": {
-            "actual": [Function],
-            "description": [Function],
-            "expected": [Function],
-            "message": [Function],
-            "problem": [Function],
-          },
-          "path": [
-            "like",
-            0,
-            "id",
-          ],
+        "id": {
+          "message": "like[0].id must be a number (was a string)",
           "ref": undefined,
           "type": "domain",
-          Symbol(ArkTypeInternalKind): "error",
         },
-        "name": ArkError {
-          "code": "required",
-          "data": {
-            "id": "z",
-          },
-          "input": {
-            "code": "required",
-            "missingValueDescription": "a string",
-            "relativePath": [
-              "name",
-            ],
-          },
-          "missingValueDescription": "a string",
-          "nodeConfig": {
-            "actual": [Function],
-            "description": [Function],
-            "expected": [Function],
-            "message": [Function],
-            "problem": [Function],
-          },
-          "path": [
-            "like",
-            0,
-            "name",
-          ],
+        "name": {
+          "message": "like[0].name must be a string (was missing)",
           "ref": undefined,
-          "relativePath": [
-            "name",
-          ],
           "type": "required",
-          Symbol(ArkTypeInternalKind): "error",
         },
       },
     ],
-    "password": ArkError {
-      "code": "union",
-      "data": "___",
-      "errors": [
-        ArkError {
-          "code": "pattern",
-          "data": "___",
-          "description": "matched by .*[A-Za-z].*",
-          "input": {
-            "code": "pattern",
-            "description": "matched by .*[A-Za-z].*",
-            "rule": ".*[A-Za-z].*",
-          },
-          "nodeConfig": {
-            "actual": [Function],
-            "description": [Function],
-            "expected": [Function],
-            "message": [Function],
-            "problem": [Function],
-          },
-          "path": [
-            "password",
-          ],
-          "rule": ".*[A-Za-z].*",
-          Symbol(ArkTypeInternalKind): "error",
-        },
-        ArkError {
-          "code": "pattern",
-          "data": "___",
-          "description": "matched by .*\\d.*",
-          "input": {
-            "code": "pattern",
-            "description": "matched by .*\\d.*",
-            "rule": ".*\\d.*",
-          },
-          "nodeConfig": {
-            "actual": [Function],
-            "description": [Function],
-            "expected": [Function],
-            "message": [Function],
-            "problem": [Function],
-          },
-          "path": [
-            "password",
-          ],
-          "rule": ".*\\d.*",
-          Symbol(ArkTypeInternalKind): "error",
-        },
-      ],
-      "input": {
-        "code": "union",
-        "errors": [
-          ArkError {
-            "code": "pattern",
-            "data": "___",
-            "description": "matched by .*[A-Za-z].*",
-            "input": {
-              "code": "pattern",
-              "description": "matched by .*[A-Za-z].*",
-              "rule": ".*[A-Za-z].*",
-            },
-            "nodeConfig": {
-              "actual": [Function],
-              "description": [Function],
-              "expected": [Function],
-              "message": [Function],
-              "problem": [Function],
-            },
-            "path": [
-              "password",
-            ],
-            "rule": ".*[A-Za-z].*",
-            Symbol(ArkTypeInternalKind): "error",
-          },
-          ArkError {
-            "code": "pattern",
-            "data": "___",
-            "description": "matched by .*\\d.*",
-            "input": {
-              "code": "pattern",
-              "description": "matched by .*\\d.*",
-              "rule": ".*\\d.*",
-            },
-            "nodeConfig": {
-              "actual": [Function],
-              "description": [Function],
-              "expected": [Function],
-              "message": [Function],
-              "problem": [Function],
-            },
-            "path": [
-              "password",
-            ],
-            "rule": ".*\\d.*",
-            Symbol(ArkTypeInternalKind): "error",
-          },
-        ],
-      },
-      "nodeConfig": {
-        "actual": [Function],
-        "description": [Function],
-        "expected": [Function],
-        "message": [Function],
-        "problem": [Function],
-      },
-      "path": [
-        "password",
-      ],
+    "password": {
+      "message": "password must be matched by .*[A-Za-z].* or matched by .*\\d.* (was "___")",
       "ref": {
         "name": "password",
       },
       "type": "union",
-      Symbol(ArkTypeInternalKind): "error",
     },
-    "repeatPassword": ArkError {
-      "code": "required",
-      "data": {
-        "birthYear": "birthYear",
-        "email": "",
-        "like": [
-          {
-            "id": "z",
-          },
-        ],
-        "password": "___",
-        "url": "abc",
-      },
-      "input": {
-        "code": "required",
-        "missingValueDescription": "a string",
-        "relativePath": [
-          "repeatPassword",
-        ],
-      },
-      "missingValueDescription": "a string",
-      "nodeConfig": {
-        "actual": [Function],
-        "description": [Function],
-        "expected": [Function],
-        "message": [Function],
-        "problem": [Function],
-      },
-      "path": [
-        "repeatPassword",
-      ],
+    "repeatPassword": {
+      "message": "repeatPassword must be a string (was missing)",
       "ref": undefined,
-      "relativePath": [
-        "repeatPassword",
-      ],
       "type": "required",
-      Symbol(ArkTypeInternalKind): "error",
     },
-    "tags": ArkError {
-      "code": "required",
-      "data": {
-        "birthYear": "birthYear",
-        "email": "",
-        "like": [
-          {
-            "id": "z",
-          },
-        ],
-        "password": "___",
-        "url": "abc",
-      },
-      "input": {
-        "code": "required",
-        "missingValueDescription": "an array",
-        "relativePath": [
-          "tags",
-        ],
-      },
-      "missingValueDescription": "an array",
-      "nodeConfig": {
-        "actual": [Function],
-        "description": [Function],
-        "expected": [Function],
-        "message": [Function],
-        "problem": [Function],
-      },
-      "path": [
-        "tags",
-      ],
+    "tags": {
+      "message": "tags must be an array (was missing)",
       "ref": undefined,
-      "relativePath": [
-        "tags",
-      ],
       "type": "required",
-      Symbol(ArkTypeInternalKind): "error",
     },
-    "username": ArkError {
-      "code": "required",
-      "data": {
-        "birthYear": "birthYear",
-        "email": "",
-        "like": [
-          {
-            "id": "z",
-          },
-        ],
-        "password": "___",
-        "url": "abc",
-      },
-      "input": {
-        "code": "required",
-        "missingValueDescription": "a string",
-        "relativePath": [
-          "username",
-        ],
-      },
-      "missingValueDescription": "a string",
-      "nodeConfig": {
-        "actual": [Function],
-        "description": [Function],
-        "expected": [Function],
-        "message": [Function],
-        "problem": [Function],
-      },
-      "path": [
-        "username",
-      ],
+    "username": {
+      "message": "username must be a string (was missing)",
       "ref": {
         "name": "username",
       },
-      "relativePath": [
-        "username",
-      ],
       "type": "required",
-      Symbol(ArkTypeInternalKind): "error",
     },
   },
   "values": {},

package/arktype/src/arktype.ts

@@ -1,18 +1,48 @@
 import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';
-import { ArkErrors } from 'arktype';
-import { FieldError, FieldErrors } from 'react-hook-form';
-import type { Resolver } from './types';
-
-const parseErrorSchema = (e: ArkErrors): Record<string, FieldError> => {
-  // copy code to type to match FieldError shape
-  e.forEach((e) => Object.assign(e, { type: e.code }));
-  // need to cast here because TS doesn't understand we added the type field
-  return e.byPath as never;
-};
-
-export const arktypeResolver: Resolver =
-  (schema, _schemaOptions, resolverOptions = {}) =>
-  (values, _, options) => {
+import { ArkErrors, Type } from 'arktype';
+import { FieldError, FieldErrors, Resolver } from 'react-hook-form';
+
+function parseErrorSchema(arkErrors: ArkErrors): Record<string, FieldError> {
+  const errors = [...arkErrors];
+  const fieldsErrors: Record<string, FieldError> = {};
+
+  for (; errors.length; ) {
+    const error = errors[0];
+    const _path = error.path.join('.');
+
+    if (!fieldsErrors[_path]) {
+      fieldsErrors[_path] = { message: error.message, type: error.code };
+    }
+
+    errors.shift();
+  }
+
+  return fieldsErrors;
+}
+
+/**
+ * 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 function arktypeResolver<Schema extends Type<any, any>>(
+  schema: Schema,
+  _schemaOptions?: never,
+  resolverOptions: {
+    raw?: boolean;
+  } = {},
+): Resolver<Schema['inferOut']> {
+  return (values, _, options) => {
     const out = schema(values);
 
     if (out instanceof ArkErrors) {
@@ -26,6 +56,7 @@ export const arktypeResolver: Resolver =
 
     return {
       errors: {} as FieldErrors,
-      values: resolverOptions.raw ? values : out,
+      values: resolverOptions.raw ? Object.assign({}, values) : out,
     };
   };
+}

package/arktype/src/index.ts

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

package/class-validator/dist/class-validator.d.ts

@@ -1,2 +1,29 @@
-import type { Resolver } from './types';
-export declare const classValidatorResolver: Resolver;
+import { ClassConstructor, ClassTransformOptions } from 'class-transformer';
+import { ValidatorOptions } from 'class-validator';
+import { Resolver } from 'react-hook-form';
+/**
+ * Creates a resolver for react-hook-form using class-validator schema validation
+ * @param {ClassConstructor<Schema>} schema - The class-validator schema to validate against
+ * @param {Object} schemaOptions - Additional schema validation options
+ * @param {Object} resolverOptions - Additional resolver configuration
+ * @param {string} [resolverOptions.mode='async'] - Validation mode
+ * @returns {Resolver<Schema>} A resolver function compatible with react-hook-form
+ * @example
+ * class Schema {
+ *   @Matches(/^\w+$/)
+ *   @Length(3, 30)
+ *   username: string;
+ *   age: number
+ * }
+ *
+ * useForm({
+ *   resolver: classValidatorResolver(Schema)
+ * });
+ */
+export declare function classValidatorResolver<Schema extends Record<string, any>>(schema: ClassConstructor<Schema>, schemaOptions?: {
+    validator?: ValidatorOptions;
+    transformer?: ClassTransformOptions;
+}, resolverOptions?: {
+    mode?: 'async' | 'sync';
+    raw?: boolean;
+}): Resolver<Schema>;

package/class-validator/dist/class-validator.js

@@ -1,2 +1,2 @@
-var r=require("@hookform/resolvers"),e=require("class-transformer"),t=require("class-validator"),a=function r(e,t,a,s){return void 0===a&&(a={}),void 0===s&&(s=""),e.reduce(function(e,a){var i=s?s+"."+a.property:a.property;if(a.constraints){var o=Object.keys(a.constraints)[0];e[i]={type:o,message:a.constraints[o]};var n=e[i];t&&n&&Object.assign(n,{types:a.constraints})}return a.children&&a.children.length&&r(a.children,t,e,i),e},a)};exports.classValidatorResolver=function(s,i,o){return void 0===i&&(i={}),void 0===o&&(o={}),function(n,l,c){try{var v=i.validator,d=e.plainToClass(s,n,i.transformer);return Promise.resolve(("sync"===o.mode?t.validateSync:t.validate)(d,v)).then(function(e){return e.length?{values:{},errors:r.toNestErrors(a(e,!c.shouldUseNativeValidation&&"all"===c.criteriaMode),c)}:(c.shouldUseNativeValidation&&r.validateFieldsNatively({},c),{values:o.rawValues?n:d,errors:{}})})}catch(r){return Promise.reject(r)}}};
+var r=require("@hookform/resolvers"),e=require("class-transformer"),t=require("class-validator");function s(r,e,t,a){return void 0===t&&(t={}),void 0===a&&(a=""),r.reduce(function(r,t){var i=a?a+"."+t.property:t.property;if(t.constraints){var o=Object.keys(t.constraints)[0];r[i]={type:o,message:t.constraints[o]};var n=r[i];e&&n&&Object.assign(n,{types:t.constraints})}return t.children&&t.children.length&&s(t.children,e,r,i),r},t)}exports.classValidatorResolver=function(a,i,o){return void 0===i&&(i={}),void 0===o&&(o={}),function(n,l,c){try{var v=i.validator,d=e.plainToClass(a,n,i.transformer);return Promise.resolve(("sync"===o.mode?t.validateSync:t.validate)(d,v)).then(function(e){return e.length?{values:{},errors:r.toNestErrors(s(e,!c.shouldUseNativeValidation&&"all"===c.criteriaMode),c)}:(c.shouldUseNativeValidation&&r.validateFieldsNatively({},c),{values:o.raw?Object.assign({},n):d,errors:{}})})}catch(r){return Promise.reject(r)}}};
 //# sourceMappingURL=class-validator.js.map

package/class-validator/dist/class-validator.js.map

@@ -1 +1 @@
-{"version":3,"file":"class-validator.js","sources":["../src/class-validator.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { plainToClass } from 'class-transformer';\nimport { ValidationError, validate, validateSync } from 'class-validator';\nimport { FieldErrors } from 'react-hook-form';\nimport type { Resolver } from './types';\n\nconst parseErrors = (\n  errors: ValidationError[],\n  validateAllFieldCriteria: boolean,\n  parsedErrors: FieldErrors = {},\n  path = '',\n) => {\n  return errors.reduce((acc, error) => {\n    const _path = path ? `${path}.${error.property}` : error.property;\n\n    if (error.constraints) {\n      const key = Object.keys(error.constraints)[0];\n      acc[_path] = {\n        type: key,\n        message: error.constraints[key],\n      };\n\n      const _e = acc[_path];\n      if (validateAllFieldCriteria && _e) {\n        Object.assign(_e, { types: error.constraints });\n      }\n    }\n\n    if (error.children && error.children.length) {\n      parseErrors(error.children, validateAllFieldCriteria, acc, _path);\n    }\n\n    return acc;\n  }, parsedErrors);\n};\n\nexport const classValidatorResolver: Resolver =\n  (schema, schemaOptions = {}, resolverOptions = {}) =>\n  async (values, _, options) => {\n    const { transformer, validator } = schemaOptions;\n    const data = plainToClass(schema, values, transformer);\n\n    const rawErrors = await (resolverOptions.mode === 'sync'\n      ? validateSync\n      : validate)(data, validator);\n\n    if (rawErrors.length) {\n      return {\n        values: {},\n        errors: toNestErrors(\n          parseErrors(\n            rawErrors,\n            !options.shouldUseNativeValidation &&\n              options.criteriaMode === 'all',\n          ),\n          options,\n        ),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      values: resolverOptions.rawValues ? values : data,\n      errors: {},\n    };\n  };\n"],"names":["parseErrors","errors","validateAllFieldCriteria","parsedErrors","path","reduce","acc","error","_path","property","constraints","key","Object","keys","type","message","_e","assign","types","children","length","schema","schemaOptions","resolverOptions","values","_","options","validator","data","plainToClass","transformer","Promise","resolve","mode","validateSync","validate","then","rawErrors","toNestErrors","shouldUseNativeValidation","criteriaMode","validateFieldsNatively","rawValues","e","reject"],"mappings":"iGAMMA,EAAc,SAAdA,EACJC,EACAC,EACAC,EACAC,GAEA,gBAHAD,IAAAA,EAA4B,CAAE,QAC1B,IAAJC,IAAAA,EAAO,IAEAH,EAAOI,OAAO,SAACC,EAAKC,GACzB,IAAMC,EAAQJ,EAAUA,EAAQG,IAAAA,EAAME,SAAaF,EAAME,SAEzD,GAAIF,EAAMG,YAAa,CACrB,IAAMC,EAAMC,OAAOC,KAAKN,EAAMG,aAAa,GAC3CJ,EAAIE,GAAS,CACXM,KAAMH,EACNI,QAASR,EAAMG,YAAYC,IAG7B,IAAMK,EAAKV,EAAIE,GACXN,GAA4Bc,GAC9BJ,OAAOK,OAAOD,EAAI,CAAEE,MAAOX,EAAMG,aAErC,CAMA,OAJIH,EAAMY,UAAYZ,EAAMY,SAASC,QACnCpB,EAAYO,EAAMY,SAAUjB,EAA0BI,EAAKE,GAGtDF,CACT,EAAGH,EACL,iCAGE,SAACkB,EAAQC,EAAoBC,GAAoB,YAAxCD,IAAAA,IAAAA,EAAgB,SAAmB,IAAfC,IAAAA,EAAkB,IAAE,SAC1CC,EAAQC,EAAGC,GAAO,IACvB,IAAqBC,EAAcL,EAAdK,UACfC,EAAOC,eAAaR,EAAQG,EADCF,EAA3BQ,aAC+C,OAAAC,QAAAC,SAEL,SAAzBT,EAAgBU,KACrCC,EAAAA,aACAC,EAAQA,UAAEP,EAAMD,IAAUS,KAFxBC,SAAAA,GAIN,OAAIA,EAAUjB,OACL,CACLI,OAAQ,GACRvB,OAAQqC,EAAAA,aACNtC,EACEqC,GACCX,EAAQa,2BACkB,QAAzBb,EAAQc,cAEZd,KAKNA,EAAQa,2BAA6BE,yBAAuB,CAAA,EAAIf,GAEzD,CACLF,OAAQD,EAAgBmB,UAAYlB,EAASI,EAC7C3B,OAAQ,CAAA,GACR,EACJ,CAAC,MAAA0C,GAAA,OAAAZ,QAAAa,OAAAD,EAAA,CAAA,CAAA"}
+{"version":3,"file":"class-validator.js","sources":["../src/class-validator.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport {\n  ClassConstructor,\n  ClassTransformOptions,\n  plainToClass,\n} from 'class-transformer';\nimport {\n  ValidationError,\n  ValidatorOptions,\n  validate,\n  validateSync,\n} from 'class-validator';\nimport { FieldErrors, Resolver } from 'react-hook-form';\n\nfunction parseErrorSchema(\n  errors: ValidationError[],\n  validateAllFieldCriteria: boolean,\n  parsedErrors: FieldErrors = {},\n  path = '',\n) {\n  return errors.reduce((acc, error) => {\n    const _path = path ? `${path}.${error.property}` : error.property;\n\n    if (error.constraints) {\n      const key = Object.keys(error.constraints)[0];\n      acc[_path] = {\n        type: key,\n        message: error.constraints[key],\n      };\n\n      const _e = acc[_path];\n      if (validateAllFieldCriteria && _e) {\n        Object.assign(_e, { types: error.constraints });\n      }\n    }\n\n    if (error.children && error.children.length) {\n      parseErrorSchema(error.children, validateAllFieldCriteria, acc, _path);\n    }\n\n    return acc;\n  }, parsedErrors);\n}\n\n/**\n * Creates a resolver for react-hook-form using class-validator schema validation\n * @param {ClassConstructor<Schema>} schema - The class-validator schema to validate against\n * @param {Object} schemaOptions - Additional schema validation options\n * @param {Object} resolverOptions - Additional resolver configuration\n * @param {string} [resolverOptions.mode='async'] - Validation mode\n * @returns {Resolver<Schema>} A resolver function compatible with react-hook-form\n * @example\n * class Schema {\n *   @Matches(/^\\w+$/)\n *   @Length(3, 30)\n *   username: string;\n *   age: number\n * }\n *\n * useForm({\n *   resolver: classValidatorResolver(Schema)\n * });\n */\nexport function classValidatorResolver<Schema extends Record<string, any>>(\n  schema: ClassConstructor<Schema>,\n  schemaOptions: {\n    validator?: ValidatorOptions;\n    transformer?: ClassTransformOptions;\n  } = {},\n  resolverOptions: { mode?: 'async' | 'sync'; raw?: boolean } = {},\n): Resolver<Schema> {\n  return async (values, _, options) => {\n    const { transformer, validator } = schemaOptions;\n    const data = plainToClass(schema, values, transformer);\n\n    const rawErrors = await (resolverOptions.mode === 'sync'\n      ? validateSync\n      : validate)(data, validator);\n\n    if (rawErrors.length) {\n      return {\n        values: {},\n        errors: toNestErrors(\n          parseErrorSchema(\n            rawErrors,\n            !options.shouldUseNativeValidation &&\n              options.criteriaMode === 'all',\n          ),\n          options,\n        ),\n      };\n    }\n\n    options.shouldUseNativeValidation && validateFieldsNatively({}, options);\n\n    return {\n      values: resolverOptions.raw ? Object.assign({}, values) : data,\n      errors: {},\n    };\n  };\n}\n"],"names":["parseErrorSchema","errors","validateAllFieldCriteria","parsedErrors","path","reduce","acc","error","_path","property","constraints","key","Object","keys","type","message","_e","assign","types","children","length","schema","schemaOptions","resolverOptions","values","_","options","validator","data","plainToClass","transformer","Promise","resolve","mode","validateSync","validate","then","rawErrors","toNestErrors","shouldUseNativeValidation","criteriaMode","validateFieldsNatively","raw","e","reject"],"mappings":"iGAcA,SAASA,EACPC,EACAC,EACAC,EACAC,GAEA,YAHA,IAAAD,IAAAA,EAA4B,CAAE,YAC9BC,IAAAA,EAAO,IAEAH,EAAOI,OAAO,SAACC,EAAKC,GACzB,IAAMC,EAAQJ,EAAUA,EAAI,IAAIG,EAAME,SAAaF,EAAME,SAEzD,GAAIF,EAAMG,YAAa,CACrB,IAAMC,EAAMC,OAAOC,KAAKN,EAAMG,aAAa,GAC3CJ,EAAIE,GAAS,CACXM,KAAMH,EACNI,QAASR,EAAMG,YAAYC,IAG7B,IAAMK,EAAKV,EAAIE,GACXN,GAA4Bc,GAC9BJ,OAAOK,OAAOD,EAAI,CAAEE,MAAOX,EAAMG,aAErC,CAMA,OAJIH,EAAMY,UAAYZ,EAAMY,SAASC,QACnCpB,EAAiBO,EAAMY,SAAUjB,EAA0BI,EAAKE,GAG3DF,CACT,EAAGH,EACL,gCAqBM,SACJkB,EACAC,EAIAC,GAEA,gBANAD,IAAAA,EAGI,CAAE,QACN,IAAAC,IAAAA,EAA8D,CAAE,GAEhE,SAAcC,EAAQC,EAAGC,OACvB,IAAqBC,EAAcL,EAAdK,UACfC,EAAOC,EAAYA,aAACR,EAAQG,EADCF,EAA3BQ,aAC+C,OAAAC,QAAAC,SAEL,SAAzBT,EAAgBU,KACrCC,eACAC,EAAAA,UAAUP,EAAMD,IAAUS,KAFxBC,SAAAA,GAIN,OAAIA,EAAUjB,OACL,CACLI,OAAQ,CAAA,EACRvB,OAAQqC,eACNtC,EACEqC,GACCX,EAAQa,2BACkB,QAAzBb,EAAQc,cAEZd,KAKNA,EAAQa,2BAA6BE,EAAsBA,uBAAC,CAAE,EAAEf,GAEzD,CACLF,OAAQD,EAAgBmB,IAAM9B,OAAOK,OAAO,CAAE,EAAEO,GAAUI,EAC1D3B,OAAQ,CAAA,GACR,EACJ,CAAC,MAAA0C,GAAAZ,OAAAA,QAAAa,OAAAD,EACH,CAAA,CAAA"}

package/class-validator/dist/class-validator.mjs

@@ -1,2 +1,2 @@
-import{toNestErrors as r,validateFieldsNatively as e}from"@hookform/resolvers";import{plainToClass as t}from"class-transformer";import{validateSync as o,validate as n}from"class-validator";var s=function r(e,t,o,n){return void 0===o&&(o={}),void 0===n&&(n=""),e.reduce(function(e,o){var s=n?n+"."+o.property:o.property;if(o.constraints){var i=Object.keys(o.constraints)[0];e[s]={type:i,message:o.constraints[i]};var a=e[s];t&&a&&Object.assign(a,{types:o.constraints})}return o.children&&o.children.length&&r(o.children,t,e,s),e},o)},i=function(i,a,c){return void 0===a&&(a={}),void 0===c&&(c={}),function(l,u,v){try{var d=a.validator,m=t(i,l,a.transformer);return Promise.resolve(("sync"===c.mode?o:n)(m,d)).then(function(t){return t.length?{values:{},errors:r(s(t,!v.shouldUseNativeValidation&&"all"===v.criteriaMode),v)}:(v.shouldUseNativeValidation&&e({},v),{values:c.rawValues?l:m,errors:{}})})}catch(r){return Promise.reject(r)}}};export{i as classValidatorResolver};
+import{toNestErrors as r,validateFieldsNatively as e}from"@hookform/resolvers";import{plainToClass as t}from"class-transformer";import{validateSync as o,validate as n}from"class-validator";function s(r,e,t,o){return void 0===t&&(t={}),void 0===o&&(o=""),r.reduce(function(r,t){var n=o?o+"."+t.property:t.property;if(t.constraints){var i=Object.keys(t.constraints)[0];r[n]={type:i,message:t.constraints[i]};var a=r[n];e&&a&&Object.assign(a,{types:t.constraints})}return t.children&&t.children.length&&s(t.children,e,r,n),r},t)}function i(i,a,c){return void 0===a&&(a={}),void 0===c&&(c={}),function(l,d,u){try{var v=a.validator,m=t(i,l,a.transformer);return Promise.resolve(("sync"===c.mode?o:n)(m,v)).then(function(t){return t.length?{values:{},errors:r(s(t,!u.shouldUseNativeValidation&&"all"===u.criteriaMode),u)}:(u.shouldUseNativeValidation&&e({},u),{values:c.raw?Object.assign({},l):m,errors:{}})})}catch(r){return Promise.reject(r)}}}export{i as classValidatorResolver};
 //# sourceMappingURL=class-validator.module.js.map

package/class-validator/dist/class-validator.modern.mjs

@@ -1,2 +1,2 @@
-import{toNestErrors as r,validateFieldsNatively as s}from"@hookform/resolvers";import{plainToClass as t}from"class-transformer";import{validateSync as e,validate as o}from"class-validator";const a=(r,s,t={},e="")=>r.reduce((r,t)=>{const o=e?`${e}.${t.property}`:t.property;if(t.constraints){const e=Object.keys(t.constraints)[0];r[o]={type:e,message:t.constraints[e]};const a=r[o];s&&a&&Object.assign(a,{types:t.constraints})}return t.children&&t.children.length&&a(t.children,s,r,o),r},t),n=(n,i={},c={})=>async(l,d,m)=>{const{transformer:p,validator:h}=i,u=t(n,l,p),f=await("sync"===c.mode?e:o)(u,h);return f.length?{values:{},errors:r(a(f,!m.shouldUseNativeValidation&&"all"===m.criteriaMode),m)}:(m.shouldUseNativeValidation&&s({},m),{values:c.rawValues?l:u,errors:{}})};export{n as classValidatorResolver};
+import{toNestErrors as r,validateFieldsNatively as t}from"@hookform/resolvers";import{plainToClass as s}from"class-transformer";import{validateSync as e,validate as o}from"class-validator";function n(r,t,s={},e=""){return r.reduce((r,s)=>{const o=e?`${e}.${s.property}`:s.property;if(s.constraints){const e=Object.keys(s.constraints)[0];r[o]={type:e,message:s.constraints[e]};const n=r[o];t&&n&&Object.assign(n,{types:s.constraints})}return s.children&&s.children.length&&n(s.children,t,r,o),r},s)}function a(a,i={},c={}){return async(l,d,m)=>{const{transformer:u,validator:p}=i,f=s(a,l,u),h=await("sync"===c.mode?e:o)(f,p);return h.length?{values:{},errors:r(n(h,!m.shouldUseNativeValidation&&"all"===m.criteriaMode),m)}:(m.shouldUseNativeValidation&&t({},m),{values:c.raw?Object.assign({},l):f,errors:{}})}}export{a as classValidatorResolver};
 //# sourceMappingURL=class-validator.modern.mjs.map