phecda-core 5.2.0 → 5.3.0

package/dist/index.d.mts

@@ -144,6 +144,15 @@ declare abstract class Base {
 }
 
 declare const _createErrorMessage: (type: string, { property, meta }: RuleArgs) => string;
-declare function validate(model: Construct, data: any, collectErrors?: boolean, createErrMsg?: (type: string, { property, meta }: RuleArgs) => string, equalFn?: (a: any, b: any) => boolean): Promise<any[]>;
+interface ExtractedRule {
+    property: string;
+    designType: any;
+    mergedMeta: any;
+    validate: (value: any) => Promise<string | undefined>;
+}
+declare function extractRules(model: Construct, createErrMsg?: (type: string, { property, meta }: RuleArgs) => string, equalFn?: (a: any, b: any) => boolean, parentPath?: string): ExtractedRule[];
+declare function extractDataByRules(data: any, rules: ExtractedRule[]): any;
+declare function validateWithRules(data: any, rules: ExtractedRule[], collectErrors?: boolean): Promise<string[]>;
+declare function validate(model: Construct, data: any, collectErrors?: boolean, createErrMsg?: (type: string, { property, meta }: RuleArgs) => string, equalFn?: (a: any, b: any) => boolean): Promise<string[]>;
 
-export { type AbConstruct, Assign, Base, CLEAR_KEY, type ClassValue, Clear, Const, type Construct, DataMap, Doc, Effect, Empty, Enum, Err, type Events, Expose, Global, If, Init, Inject, type InjectData, Injectable, Isolate, Max, Min, type NameSpace, Nested, OneOf, Optional, PHECDA_KEY, type Phecda, Pipeline, Provide, Required, Rule, type RuleArgs, SHARE_KEY, Storage, type StorageParam, Tag, Unique, Unmount, Watcher, type WatcherParam, _createErrorMessage, activeInstance, addDecoToClass, functionToClass, get, getInject, getMergedMeta, getMeta, getMetaKey, getMetaParams, getOwnMeta, getOwnMetaKey, getOwnMetaParams, getPhecdaFromTarget, getTag, init, invoke, invokeInit, invokeUnmount, isAsyncFunc, isPhecda, objectToClass, omit, override, partial, pick, set, setInject, setMeta, validate, wait };
+export { type AbConstruct, Assign, Base, CLEAR_KEY, type ClassValue, Clear, Const, type Construct, DataMap, Doc, Effect, Empty, Enum, Err, type Events, Expose, type ExtractedRule, Global, If, Init, Inject, type InjectData, Injectable, Isolate, Max, Min, type NameSpace, Nested, OneOf, Optional, PHECDA_KEY, type Phecda, Pipeline, Provide, Required, Rule, type RuleArgs, SHARE_KEY, Storage, type StorageParam, Tag, Unique, Unmount, Watcher, type WatcherParam, _createErrorMessage, activeInstance, addDecoToClass, extractDataByRules, extractRules, functionToClass, get, getInject, getMergedMeta, getMeta, getMetaKey, getMetaParams, getOwnMeta, getOwnMetaKey, getOwnMetaParams, getPhecdaFromTarget, getTag, init, invoke, invokeInit, invokeUnmount, isAsyncFunc, isPhecda, objectToClass, omit, override, partial, pick, set, setInject, setMeta, validate, validateWithRules, wait };

package/dist/index.d.ts

@@ -144,6 +144,15 @@ declare abstract class Base {
 }
 
 declare const _createErrorMessage: (type: string, { property, meta }: RuleArgs) => string;
-declare function validate(model: Construct, data: any, collectErrors?: boolean, createErrMsg?: (type: string, { property, meta }: RuleArgs) => string, equalFn?: (a: any, b: any) => boolean): Promise<any[]>;
+interface ExtractedRule {
+    property: string;
+    designType: any;
+    mergedMeta: any;
+    validate: (value: any) => Promise<string | undefined>;
+}
+declare function extractRules(model: Construct, createErrMsg?: (type: string, { property, meta }: RuleArgs) => string, equalFn?: (a: any, b: any) => boolean, parentPath?: string): ExtractedRule[];
+declare function extractDataByRules(data: any, rules: ExtractedRule[]): any;
+declare function validateWithRules(data: any, rules: ExtractedRule[], collectErrors?: boolean): Promise<string[]>;
+declare function validate(model: Construct, data: any, collectErrors?: boolean, createErrMsg?: (type: string, { property, meta }: RuleArgs) => string, equalFn?: (a: any, b: any) => boolean): Promise<string[]>;
 
-export { type AbConstruct, Assign, Base, CLEAR_KEY, type ClassValue, Clear, Const, type Construct, DataMap, Doc, Effect, Empty, Enum, Err, type Events, Expose, Global, If, Init, Inject, type InjectData, Injectable, Isolate, Max, Min, type NameSpace, Nested, OneOf, Optional, PHECDA_KEY, type Phecda, Pipeline, Provide, Required, Rule, type RuleArgs, SHARE_KEY, Storage, type StorageParam, Tag, Unique, Unmount, Watcher, type WatcherParam, _createErrorMessage, activeInstance, addDecoToClass, functionToClass, get, getInject, getMergedMeta, getMeta, getMetaKey, getMetaParams, getOwnMeta, getOwnMetaKey, getOwnMetaParams, getPhecdaFromTarget, getTag, init, invoke, invokeInit, invokeUnmount, isAsyncFunc, isPhecda, objectToClass, omit, override, partial, pick, set, setInject, setMeta, validate, wait };
+export { type AbConstruct, Assign, Base, CLEAR_KEY, type ClassValue, Clear, Const, type Construct, DataMap, Doc, Effect, Empty, Enum, Err, type Events, Expose, type ExtractedRule, Global, If, Init, Inject, type InjectData, Injectable, Isolate, Max, Min, type NameSpace, Nested, OneOf, Optional, PHECDA_KEY, type Phecda, Pipeline, Provide, Required, Rule, type RuleArgs, SHARE_KEY, Storage, type StorageParam, Tag, Unique, Unmount, Watcher, type WatcherParam, _createErrorMessage, activeInstance, addDecoToClass, extractDataByRules, extractRules, functionToClass, get, getInject, getMergedMeta, getMeta, getMetaKey, getMetaParams, getOwnMeta, getOwnMetaKey, getOwnMetaParams, getPhecdaFromTarget, getTag, init, invoke, invokeInit, invokeUnmount, isAsyncFunc, isPhecda, objectToClass, omit, override, partial, pick, set, setInject, setMeta, validate, validateWithRules, wait };

package/dist/index.js

@@ -59,6 +59,8 @@ __export(index_exports, {
   _createErrorMessage: () => _createErrorMessage,
   activeInstance: () => activeInstance,
   addDecoToClass: () => addDecoToClass,
+  extractDataByRules: () => extractDataByRules,
+  extractRules: () => extractRules,
   functionToClass: () => functionToClass,
   get: () => get,
   getInject: () => getInject,
@@ -86,6 +88,7 @@ __export(index_exports, {
   setInject: () => setInject,
   setMeta: () => setMeta,
   validate: () => validate,
+  validateWithRules: () => validateWithRules,
   wait: () => wait
 });
 module.exports = __toCommonJS(index_exports);
@@ -288,23 +291,21 @@ function isAsyncFunc(fn) {
 __name(isAsyncFunc, "isAsyncFunc");
 function invoke(instance, key, ...params) {
   const metaKeys = getMetaKey(instance);
-  const names = [];
   return Promise.allSettled(metaKeys.map((k) => {
-    return getMeta(instance, k);
-  }).flat().filter((item) => {
-    if (typeof item[key] === "function") {
+    const names = [];
+    const meta = getMeta(instance, k);
+    return meta.filter((item) => {
       if (item.__NAME__) {
-        if (names.includes(item.__NAME__)) {
-          return false;
-        }
+        if (names.includes(item.__NAME__)) return false;
         names.push(item.__NAME__);
         return true;
       } else {
         return true;
       }
-    } else {
-      return false;
-    }
+    });
+  }).flat().filter((item) => {
+    if (typeof item[key] === "function") return true;
+    else return false;
   }).map((item) => item[key](instance, ...params))).then((res) => {
     res.filter((item) => item.status === "rejected").forEach((item) => {
       console.error(item.reason);
@@ -752,6 +753,70 @@ Base = _ts_decorate([
 ], Base);
 
 // src/validate.ts
+function parsePath(path) {
+  if (!path) return [];
+  return path.split(".").flatMap((token) => {
+    if (!token) return [];
+    if (token.endsWith("[]")) return [
+      token.slice(0, -2),
+      "[]"
+    ];
+    return [
+      token
+    ];
+  });
+}
+__name(parsePath, "parsePath");
+function collectConcretePathsByTokens(data, tokens) {
+  if (!tokens.length) return [
+    {
+      keys: [],
+      value: data
+    }
+  ];
+  const walk = /* @__PURE__ */ __name((node, tokenIndex, keys) => {
+    if (tokenIndex >= tokens.length) return [
+      {
+        keys,
+        value: node
+      }
+    ];
+    const token = tokens[tokenIndex];
+    if (token === "[]") {
+      if (!Array.isArray(node)) return [];
+      return node.flatMap((item, idx) => walk(item, tokenIndex + 1, [
+        ...keys,
+        idx
+      ]));
+    }
+    if (node === null || node === void 0) return [];
+    const nodeType = typeof node;
+    if (nodeType !== "object" && nodeType !== "function") return [];
+    return walk(node[token], tokenIndex + 1, [
+      ...keys,
+      token
+    ]);
+  }, "walk");
+  return walk(data, 0, []);
+}
+__name(collectConcretePathsByTokens, "collectConcretePathsByTokens");
+function setByConcreteKeys(target, keys, value) {
+  if (!keys.length) return value;
+  let node = target;
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const isLast = i === keys.length - 1;
+    if (isLast) {
+      node[key] = value;
+      break;
+    }
+    const nextKey = keys[i + 1];
+    if (node[key] === void 0) node[key] = typeof nextKey === "number" ? [] : {};
+    node = node[key];
+  }
+  return target;
+}
+__name(setByConcreteKeys, "setByConcreteKeys");
 var _createErrorMessage = /* @__PURE__ */ __name((type, { property, meta }) => {
   switch (type) {
     case "const":
@@ -789,128 +854,197 @@ function isObject(value) {
   return Object.prototype.toString.call(value) === "[object Object]";
 }
 __name(isObject, "isObject");
-async function validate(model, data, collectErrors = false, createErrMsg = _createErrorMessage, equalFn = (a, b) => a === b) {
-  async function parse(model2, data2) {
-    const errors = [];
-    if (!isObject(data2)) {
-      errors.push("data must be an object");
-      return errors;
-    }
-    for (const key of getMetaKey(model2)) {
-      const meta = getMergedMeta(model2, key);
-      const property = key === SHARE_KEY ? "" : key;
-      const type = property === "" ? model2 : Reflect.getMetadata("design:type", model2.prototype, key);
-      const { rules = [], nested, oneOf, min, max, enum: enumMap, required } = meta;
-      const value = property === "" ? data2 : data2?.[key];
-      const allRules = [
-        async (args2) => {
-          const { value: value2 } = args2;
-          if ("const" in meta) {
-            if (!equalFn(value2, meta.const)) return createErrMsg("const", args2);
-          }
-          if (required === false && value2 === void 0) return true;
-          if (required !== false && value2 === void 0) return createErrMsg("required", args2);
-          if (type === String && typeof value2 !== "string") return createErrMsg("string", args2);
-          if (type === Number && typeof value2 !== "number") return createErrMsg("number", args2);
-          if (type === Boolean && typeof value2 !== "boolean") return createErrMsg("boolean", args2);
-          if (type === Array) {
-            if (!Array.isArray(value2)) return createErrMsg("array", args2);
-            if (!nested) return;
-            for (const i in value2) {
-              if (nested === String && typeof value2[i] !== "string") return createErrMsg("stringArray", args2);
-              if (nested === Number && typeof value2[i] !== "number") return createErrMsg("numberArray", args2);
-              if (nested === Boolean && typeof value2[i] !== "boolean") return createErrMsg("booleanArray", args2);
-              if (isPhecda(nested)) {
-                if (!isObject(value2[i])) return createErrMsg("object", {
-                  ...args2,
-                  arrayIndex: i
-                });
-                const errs = await parse(nested, value2[i]);
-                if (errs.length) {
-                  errors.push(errs[0]);
-                  break;
+function extractRules(model, createErrMsg = _createErrorMessage, equalFn = (a, b) => a === b, parentPath = "") {
+  const mergedRuleMap = /* @__PURE__ */ new Map();
+  const collect = /* @__PURE__ */ __name((currentModel, currentPath) => {
+    for (const key of getMetaKey(currentModel)) {
+      const mergedMeta = getMergedMeta(currentModel, key);
+      const baseProperty = key === SHARE_KEY ? "" : key;
+      const property = baseProperty && currentPath ? `${currentPath}.${baseProperty}` : baseProperty || currentPath;
+      const designType = baseProperty === "" ? currentModel : Reflect.getMetadata("design:type", currentModel.prototype, key);
+      const ruleRunner = /* @__PURE__ */ __name(async (value) => {
+        const { rules = [], nested, oneOf, min, max, enum: enumMap, required } = mergedMeta;
+        const args = {
+          value,
+          property,
+          meta: mergedMeta,
+          model: currentModel
+        };
+        const allRules = [
+          async (localArgs) => {
+            const { value: value2 } = localArgs;
+            if ("const" in mergedMeta) {
+              if (!equalFn(value2, mergedMeta.const)) return createErrMsg("const", localArgs);
+            }
+            if (required === false && value2 === void 0) return true;
+            if (required !== false && value2 === void 0) return createErrMsg("required", localArgs);
+            if (designType === String && typeof value2 !== "string") return createErrMsg("string", localArgs);
+            if (designType === Number && typeof value2 !== "number") return createErrMsg("number", localArgs);
+            if (designType === Boolean && typeof value2 !== "boolean") return createErrMsg("boolean", localArgs);
+            if (designType === Array) {
+              if (!Array.isArray(value2)) return createErrMsg("array", localArgs);
+              if (!nested) return;
+              for (const i in value2) {
+                if (nested === String && typeof value2[i] !== "string") return createErrMsg("stringArray", localArgs);
+                if (nested === Number && typeof value2[i] !== "number") return createErrMsg("numberArray", localArgs);
+                if (nested === Boolean && typeof value2[i] !== "boolean") return createErrMsg("booleanArray", localArgs);
+                if (isPhecda(nested)) {
+                  if (!isObject(value2[i])) return createErrMsg("object", {
+                    ...localArgs,
+                    arrayIndex: i
+                  });
                 }
               }
+            } else if (nested && isPhecda(nested)) {
+              if (!isObject(value2)) return createErrMsg("object", localArgs);
             }
-          } else {
-            if (nested && isPhecda(nested)) {
-              if (!isObject(value2)) return createErrMsg("object", args2);
-              const errs = await parse(nested, value2);
-              if (errs.length) errors.push(errs[0]);
+            if (min) {
+              if (typeof value2 === "number" && value2 < min) return createErrMsg("min", localArgs);
+              if (typeof value2 === "string" && value2.length < min) return createErrMsg("min", localArgs);
+              if (Array.isArray(value2) && value2.length < min) return createErrMsg("min", localArgs);
             }
-          }
-          if (min) {
-            if (typeof value2 === "number" && value2 < min) return createErrMsg("min", args2);
-            if (typeof value2 === "string" && value2.length < min) return createErrMsg("min", args2);
-            if (Array.isArray(value2) && value2.length < min) return createErrMsg("min", args2);
-          }
-          if (max) {
-            if (typeof value2 === "number" && value2 > max) return createErrMsg("max", args2);
-            if (typeof value2 === "string" && value2.length > max) return createErrMsg("max", args2);
-            if (Array.isArray(value2) && value2.length > max) return createErrMsg("max", args2);
-          }
-          if (enumMap) {
-            if (!Object.values(enumMap).includes(value2)) return createErrMsg("enum", args2);
-          }
-          if (oneOf) {
-            let isCorrect = false;
-            for (const item of oneOf) {
-              switch (item) {
-                case String:
-                  if (typeof value2 === "string") isCorrect = true;
-                  break;
-                case Number:
-                  if (typeof value2 === "number") isCorrect = true;
-                  break;
-                case Boolean:
-                  if (typeof value2 === "boolean") isCorrect = true;
-                  break;
-                default:
-                  if (isPhecda(item)) {
-                    const errs = await validate(item, value2);
-                    if (!errs.length) {
-                      isCorrect = true;
-                      break;
-                    }
-                  } else if (typeof item === "function") {
-                    const ret = await item(args2);
-                    if (ret) {
-                      isCorrect = true;
-                      break;
-                    }
-                  } else {
-                    if (equalFn(value2, item)) {
+            if (max) {
+              if (typeof value2 === "number" && value2 > max) return createErrMsg("max", localArgs);
+              if (typeof value2 === "string" && value2.length > max) return createErrMsg("max", localArgs);
+              if (Array.isArray(value2) && value2.length > max) return createErrMsg("max", localArgs);
+            }
+            if (enumMap) {
+              if (!Object.values(enumMap).includes(value2)) return createErrMsg("enum", localArgs);
+            }
+            if (oneOf) {
+              let isCorrect = false;
+              for (const item of oneOf) {
+                switch (item) {
+                  case String:
+                    if (typeof value2 === "string") isCorrect = true;
+                    break;
+                  case Number:
+                    if (typeof value2 === "number") isCorrect = true;
+                    break;
+                  case Boolean:
+                    if (typeof value2 === "boolean") isCorrect = true;
+                    break;
+                  default:
+                    if (isPhecda(item)) {
+                      const errs = await validate(item, value2);
+                      if (!errs.length) {
+                        isCorrect = true;
+                        break;
+                      }
+                    } else if (typeof item === "function") {
+                      const ret = await item(localArgs);
+                      if (ret) {
+                        isCorrect = true;
+                        break;
+                      }
+                    } else if (equalFn(value2, item)) {
                       isCorrect = true;
                       break;
                     }
-                  }
+                }
               }
+              if (!isCorrect) return createErrMsg("oneOf", localArgs);
             }
-            if (!isCorrect) return createErrMsg("oneOf", args2);
-          }
-        },
-        ...rules
-      ];
-      const args = {
-        value,
-        property,
-        meta,
-        model: model2
-      };
-      for (const rule of allRules) {
-        const errMsg = await rule(args);
-        if (errMsg === true) break;
-        if (errMsg) {
-          errors.push(errMsg);
-          break;
+          },
+          ...rules
+        ];
+        for (const rule of allRules) {
+          const errMsg = await rule(args);
+          if (errMsg === true) return;
+          if (errMsg) return errMsg;
         }
+      }, "ruleRunner");
+      const current = mergedRuleMap.get(property);
+      if (!current) {
+        mergedRuleMap.set(property, {
+          property,
+          designType,
+          mergedMeta,
+          validators: [
+            ruleRunner
+          ]
+        });
+      } else {
+        current.validators.push(ruleRunner);
+      }
+      if (mergedMeta.nested && isPhecda(mergedMeta.nested)) {
+        const nestedPath = designType === Array ? `${property}[]` : property;
+        collect(mergedMeta.nested, nestedPath);
       }
-      if (errors.length !== 0 && !collectErrors) break;
     }
+  }, "collect");
+  collect(model, parentPath);
+  return [
+    ...mergedRuleMap.values()
+  ].map((item) => ({
+    property: item.property,
+    designType: item.designType,
+    mergedMeta: item.mergedMeta,
+    validate: /* @__PURE__ */ __name(async (value) => {
+      for (const validator of item.validators) {
+        const err = await validator(value);
+        if (err) return err;
+      }
+    }, "validate")
+  }));
+}
+__name(extractRules, "extractRules");
+function extractDataByRules(data, rules) {
+  let transformed = {};
+  const projectContainerOnly = /* @__PURE__ */ __name((value, rule) => {
+    const nested = rule.mergedMeta?.nested;
+    if (!nested || !isPhecda(nested)) return value;
+    if (rule.designType === Array) return Array.isArray(value) ? [] : value;
+    return isObject(value) ? {} : value;
+  }, "projectContainerOnly");
+  for (const rule of rules) {
+    if (!rule.property) continue;
+    const tokens = parsePath(rule.property);
+    const concreteValues = collectConcretePathsByTokens(data, tokens);
+    for (const concrete of concreteValues) {
+      const projectedValue = projectContainerOnly(concrete.value, rule);
+      transformed = setByConcreteKeys(transformed, concrete.keys, projectedValue);
+    }
+  }
+  return transformed;
+}
+__name(extractDataByRules, "extractDataByRules");
+async function validateWithRules(data, rules, collectErrors = false) {
+  const errors = [];
+  for (const rule of rules) {
+    if (!rule.property) {
+      const err = await rule.validate(data);
+      if (err) {
+        errors.push(err);
+        if (!collectErrors) break;
+      }
+      continue;
+    }
+    const tokens = parsePath(rule.property);
+    const values = collectConcretePathsByTokens(data, tokens).map((v) => v.value);
+    const targetValues = values.length ? values : tokens.length === 1 ? [
+      void 0
+    ] : [];
+    for (const value of targetValues) {
+      const err = await rule.validate(value);
+      if (err) {
+        errors.push(err);
+        break;
+      }
+    }
+    if (errors.length && !collectErrors) break;
+  }
+  return errors;
+}
+__name(validateWithRules, "validateWithRules");
+async function validate(model, data, collectErrors = false, createErrMsg = _createErrorMessage, equalFn = (a, b) => a === b) {
+  const errors = [];
+  if (!isObject(data)) {
+    errors.push("data must be an object");
     return errors;
   }
-  __name(parse, "parse");
-  return await parse(model, data);
+  const rules = extractRules(model, createErrMsg, equalFn);
+  return await validateWithRules(data, rules, collectErrors);
 }
 __name(validate, "validate");
 // Annotate the CommonJS export names for ESM import in node:
@@ -952,6 +1086,8 @@ __name(validate, "validate");
   _createErrorMessage,
   activeInstance,
   addDecoToClass,
+  extractDataByRules,
+  extractRules,
   functionToClass,
   get,
   getInject,
@@ -979,6 +1115,7 @@ __name(validate, "validate");
   setInject,
   setMeta,
   validate,
+  validateWithRules,
   wait,
   ...require("reflect-metadata")
 });

package/dist/index.mjs

@@ -201,23 +201,21 @@ function isAsyncFunc(fn) {
 __name(isAsyncFunc, "isAsyncFunc");
 function invoke(instance, key, ...params) {
   const metaKeys = getMetaKey(instance);
-  const names = [];
   return Promise.allSettled(metaKeys.map((k) => {
-    return getMeta(instance, k);
-  }).flat().filter((item) => {
-    if (typeof item[key] === "function") {
+    const names = [];
+    const meta = getMeta(instance, k);
+    return meta.filter((item) => {
       if (item.__NAME__) {
-        if (names.includes(item.__NAME__)) {
-          return false;
-        }
+        if (names.includes(item.__NAME__)) return false;
         names.push(item.__NAME__);
         return true;
       } else {
         return true;
       }
-    } else {
-      return false;
-    }
+    });
+  }).flat().filter((item) => {
+    if (typeof item[key] === "function") return true;
+    else return false;
   }).map((item) => item[key](instance, ...params))).then((res) => {
     res.filter((item) => item.status === "rejected").forEach((item) => {
       console.error(item.reason);
@@ -665,6 +663,70 @@ Base = _ts_decorate([
 ], Base);
 
 // src/validate.ts
+function parsePath(path) {
+  if (!path) return [];
+  return path.split(".").flatMap((token) => {
+    if (!token) return [];
+    if (token.endsWith("[]")) return [
+      token.slice(0, -2),
+      "[]"
+    ];
+    return [
+      token
+    ];
+  });
+}
+__name(parsePath, "parsePath");
+function collectConcretePathsByTokens(data, tokens) {
+  if (!tokens.length) return [
+    {
+      keys: [],
+      value: data
+    }
+  ];
+  const walk = /* @__PURE__ */ __name((node, tokenIndex, keys) => {
+    if (tokenIndex >= tokens.length) return [
+      {
+        keys,
+        value: node
+      }
+    ];
+    const token = tokens[tokenIndex];
+    if (token === "[]") {
+      if (!Array.isArray(node)) return [];
+      return node.flatMap((item, idx) => walk(item, tokenIndex + 1, [
+        ...keys,
+        idx
+      ]));
+    }
+    if (node === null || node === void 0) return [];
+    const nodeType = typeof node;
+    if (nodeType !== "object" && nodeType !== "function") return [];
+    return walk(node[token], tokenIndex + 1, [
+      ...keys,
+      token
+    ]);
+  }, "walk");
+  return walk(data, 0, []);
+}
+__name(collectConcretePathsByTokens, "collectConcretePathsByTokens");
+function setByConcreteKeys(target, keys, value) {
+  if (!keys.length) return value;
+  let node = target;
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const isLast = i === keys.length - 1;
+    if (isLast) {
+      node[key] = value;
+      break;
+    }
+    const nextKey = keys[i + 1];
+    if (node[key] === void 0) node[key] = typeof nextKey === "number" ? [] : {};
+    node = node[key];
+  }
+  return target;
+}
+__name(setByConcreteKeys, "setByConcreteKeys");
 var _createErrorMessage = /* @__PURE__ */ __name((type, { property, meta }) => {
   switch (type) {
     case "const":
@@ -702,128 +764,197 @@ function isObject(value) {
   return Object.prototype.toString.call(value) === "[object Object]";
 }
 __name(isObject, "isObject");
-async function validate(model, data, collectErrors = false, createErrMsg = _createErrorMessage, equalFn = (a, b) => a === b) {
-  async function parse(model2, data2) {
-    const errors = [];
-    if (!isObject(data2)) {
-      errors.push("data must be an object");
-      return errors;
-    }
-    for (const key of getMetaKey(model2)) {
-      const meta = getMergedMeta(model2, key);
-      const property = key === SHARE_KEY ? "" : key;
-      const type = property === "" ? model2 : Reflect.getMetadata("design:type", model2.prototype, key);
-      const { rules = [], nested, oneOf, min, max, enum: enumMap, required } = meta;
-      const value = property === "" ? data2 : data2?.[key];
-      const allRules = [
-        async (args2) => {
-          const { value: value2 } = args2;
-          if ("const" in meta) {
-            if (!equalFn(value2, meta.const)) return createErrMsg("const", args2);
-          }
-          if (required === false && value2 === void 0) return true;
-          if (required !== false && value2 === void 0) return createErrMsg("required", args2);
-          if (type === String && typeof value2 !== "string") return createErrMsg("string", args2);
-          if (type === Number && typeof value2 !== "number") return createErrMsg("number", args2);
-          if (type === Boolean && typeof value2 !== "boolean") return createErrMsg("boolean", args2);
-          if (type === Array) {
-            if (!Array.isArray(value2)) return createErrMsg("array", args2);
-            if (!nested) return;
-            for (const i in value2) {
-              if (nested === String && typeof value2[i] !== "string") return createErrMsg("stringArray", args2);
-              if (nested === Number && typeof value2[i] !== "number") return createErrMsg("numberArray", args2);
-              if (nested === Boolean && typeof value2[i] !== "boolean") return createErrMsg("booleanArray", args2);
-              if (isPhecda(nested)) {
-                if (!isObject(value2[i])) return createErrMsg("object", {
-                  ...args2,
-                  arrayIndex: i
-                });
-                const errs = await parse(nested, value2[i]);
-                if (errs.length) {
-                  errors.push(errs[0]);
-                  break;
+function extractRules(model, createErrMsg = _createErrorMessage, equalFn = (a, b) => a === b, parentPath = "") {
+  const mergedRuleMap = /* @__PURE__ */ new Map();
+  const collect = /* @__PURE__ */ __name((currentModel, currentPath) => {
+    for (const key of getMetaKey(currentModel)) {
+      const mergedMeta = getMergedMeta(currentModel, key);
+      const baseProperty = key === SHARE_KEY ? "" : key;
+      const property = baseProperty && currentPath ? `${currentPath}.${baseProperty}` : baseProperty || currentPath;
+      const designType = baseProperty === "" ? currentModel : Reflect.getMetadata("design:type", currentModel.prototype, key);
+      const ruleRunner = /* @__PURE__ */ __name(async (value) => {
+        const { rules = [], nested, oneOf, min, max, enum: enumMap, required } = mergedMeta;
+        const args = {
+          value,
+          property,
+          meta: mergedMeta,
+          model: currentModel
+        };
+        const allRules = [
+          async (localArgs) => {
+            const { value: value2 } = localArgs;
+            if ("const" in mergedMeta) {
+              if (!equalFn(value2, mergedMeta.const)) return createErrMsg("const", localArgs);
+            }
+            if (required === false && value2 === void 0) return true;
+            if (required !== false && value2 === void 0) return createErrMsg("required", localArgs);
+            if (designType === String && typeof value2 !== "string") return createErrMsg("string", localArgs);
+            if (designType === Number && typeof value2 !== "number") return createErrMsg("number", localArgs);
+            if (designType === Boolean && typeof value2 !== "boolean") return createErrMsg("boolean", localArgs);
+            if (designType === Array) {
+              if (!Array.isArray(value2)) return createErrMsg("array", localArgs);
+              if (!nested) return;
+              for (const i in value2) {
+                if (nested === String && typeof value2[i] !== "string") return createErrMsg("stringArray", localArgs);
+                if (nested === Number && typeof value2[i] !== "number") return createErrMsg("numberArray", localArgs);
+                if (nested === Boolean && typeof value2[i] !== "boolean") return createErrMsg("booleanArray", localArgs);
+                if (isPhecda(nested)) {
+                  if (!isObject(value2[i])) return createErrMsg("object", {
+                    ...localArgs,
+                    arrayIndex: i
+                  });
                 }
               }
+            } else if (nested && isPhecda(nested)) {
+              if (!isObject(value2)) return createErrMsg("object", localArgs);
             }
-          } else {
-            if (nested && isPhecda(nested)) {
-              if (!isObject(value2)) return createErrMsg("object", args2);
-              const errs = await parse(nested, value2);
-              if (errs.length) errors.push(errs[0]);
+            if (min) {
+              if (typeof value2 === "number" && value2 < min) return createErrMsg("min", localArgs);
+              if (typeof value2 === "string" && value2.length < min) return createErrMsg("min", localArgs);
+              if (Array.isArray(value2) && value2.length < min) return createErrMsg("min", localArgs);
             }
-          }
-          if (min) {
-            if (typeof value2 === "number" && value2 < min) return createErrMsg("min", args2);
-            if (typeof value2 === "string" && value2.length < min) return createErrMsg("min", args2);
-            if (Array.isArray(value2) && value2.length < min) return createErrMsg("min", args2);
-          }
-          if (max) {
-            if (typeof value2 === "number" && value2 > max) return createErrMsg("max", args2);
-            if (typeof value2 === "string" && value2.length > max) return createErrMsg("max", args2);
-            if (Array.isArray(value2) && value2.length > max) return createErrMsg("max", args2);
-          }
-          if (enumMap) {
-            if (!Object.values(enumMap).includes(value2)) return createErrMsg("enum", args2);
-          }
-          if (oneOf) {
-            let isCorrect = false;
-            for (const item of oneOf) {
-              switch (item) {
-                case String:
-                  if (typeof value2 === "string") isCorrect = true;
-                  break;
-                case Number:
-                  if (typeof value2 === "number") isCorrect = true;
-                  break;
-                case Boolean:
-                  if (typeof value2 === "boolean") isCorrect = true;
-                  break;
-                default:
-                  if (isPhecda(item)) {
-                    const errs = await validate(item, value2);
-                    if (!errs.length) {
-                      isCorrect = true;
-                      break;
-                    }
-                  } else if (typeof item === "function") {
-                    const ret = await item(args2);
-                    if (ret) {
-                      isCorrect = true;
-                      break;
-                    }
-                  } else {
-                    if (equalFn(value2, item)) {
+            if (max) {
+              if (typeof value2 === "number" && value2 > max) return createErrMsg("max", localArgs);
+              if (typeof value2 === "string" && value2.length > max) return createErrMsg("max", localArgs);
+              if (Array.isArray(value2) && value2.length > max) return createErrMsg("max", localArgs);
+            }
+            if (enumMap) {
+              if (!Object.values(enumMap).includes(value2)) return createErrMsg("enum", localArgs);
+            }
+            if (oneOf) {
+              let isCorrect = false;
+              for (const item of oneOf) {
+                switch (item) {
+                  case String:
+                    if (typeof value2 === "string") isCorrect = true;
+                    break;
+                  case Number:
+                    if (typeof value2 === "number") isCorrect = true;
+                    break;
+                  case Boolean:
+                    if (typeof value2 === "boolean") isCorrect = true;
+                    break;
+                  default:
+                    if (isPhecda(item)) {
+                      const errs = await validate(item, value2);
+                      if (!errs.length) {
+                        isCorrect = true;
+                        break;
+                      }
+                    } else if (typeof item === "function") {
+                      const ret = await item(localArgs);
+                      if (ret) {
+                        isCorrect = true;
+                        break;
+                      }
+                    } else if (equalFn(value2, item)) {
                       isCorrect = true;
                       break;
                     }
-                  }
+                }
               }
+              if (!isCorrect) return createErrMsg("oneOf", localArgs);
             }
-            if (!isCorrect) return createErrMsg("oneOf", args2);
-          }
-        },
-        ...rules
-      ];
-      const args = {
-        value,
-        property,
-        meta,
-        model: model2
-      };
-      for (const rule of allRules) {
-        const errMsg = await rule(args);
-        if (errMsg === true) break;
-        if (errMsg) {
-          errors.push(errMsg);
-          break;
+          },
+          ...rules
+        ];
+        for (const rule of allRules) {
+          const errMsg = await rule(args);
+          if (errMsg === true) return;
+          if (errMsg) return errMsg;
         }
+      }, "ruleRunner");
+      const current = mergedRuleMap.get(property);
+      if (!current) {
+        mergedRuleMap.set(property, {
+          property,
+          designType,
+          mergedMeta,
+          validators: [
+            ruleRunner
+          ]
+        });
+      } else {
+        current.validators.push(ruleRunner);
+      }
+      if (mergedMeta.nested && isPhecda(mergedMeta.nested)) {
+        const nestedPath = designType === Array ? `${property}[]` : property;
+        collect(mergedMeta.nested, nestedPath);
       }
-      if (errors.length !== 0 && !collectErrors) break;
     }
+  }, "collect");
+  collect(model, parentPath);
+  return [
+    ...mergedRuleMap.values()
+  ].map((item) => ({
+    property: item.property,
+    designType: item.designType,
+    mergedMeta: item.mergedMeta,
+    validate: /* @__PURE__ */ __name(async (value) => {
+      for (const validator of item.validators) {
+        const err = await validator(value);
+        if (err) return err;
+      }
+    }, "validate")
+  }));
+}
+__name(extractRules, "extractRules");
+function extractDataByRules(data, rules) {
+  let transformed = {};
+  const projectContainerOnly = /* @__PURE__ */ __name((value, rule) => {
+    const nested = rule.mergedMeta?.nested;
+    if (!nested || !isPhecda(nested)) return value;
+    if (rule.designType === Array) return Array.isArray(value) ? [] : value;
+    return isObject(value) ? {} : value;
+  }, "projectContainerOnly");
+  for (const rule of rules) {
+    if (!rule.property) continue;
+    const tokens = parsePath(rule.property);
+    const concreteValues = collectConcretePathsByTokens(data, tokens);
+    for (const concrete of concreteValues) {
+      const projectedValue = projectContainerOnly(concrete.value, rule);
+      transformed = setByConcreteKeys(transformed, concrete.keys, projectedValue);
+    }
+  }
+  return transformed;
+}
+__name(extractDataByRules, "extractDataByRules");
+async function validateWithRules(data, rules, collectErrors = false) {
+  const errors = [];
+  for (const rule of rules) {
+    if (!rule.property) {
+      const err = await rule.validate(data);
+      if (err) {
+        errors.push(err);
+        if (!collectErrors) break;
+      }
+      continue;
+    }
+    const tokens = parsePath(rule.property);
+    const values = collectConcretePathsByTokens(data, tokens).map((v) => v.value);
+    const targetValues = values.length ? values : tokens.length === 1 ? [
+      void 0
+    ] : [];
+    for (const value of targetValues) {
+      const err = await rule.validate(value);
+      if (err) {
+        errors.push(err);
+        break;
+      }
+    }
+    if (errors.length && !collectErrors) break;
+  }
+  return errors;
+}
+__name(validateWithRules, "validateWithRules");
+async function validate(model, data, collectErrors = false, createErrMsg = _createErrorMessage, equalFn = (a, b) => a === b) {
+  const errors = [];
+  if (!isObject(data)) {
+    errors.push("data must be an object");
     return errors;
   }
-  __name(parse, "parse");
-  return await parse(model, data);
+  const rules = extractRules(model, createErrMsg, equalFn);
+  return await validateWithRules(data, rules, collectErrors);
 }
 __name(validate, "validate");
 export {
@@ -864,6 +995,8 @@ export {
   _createErrorMessage,
   activeInstance,
   addDecoToClass,
+  extractDataByRules,
+  extractRules,
   functionToClass,
   get,
   getInject,
@@ -891,5 +1024,6 @@ export {
   setInject,
   setMeta,
   validate,
+  validateWithRules,
   wait
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phecda-core",
-  "version": "5.2.0",
+  "version": "5.3.0",
   "description": "provide base function and abstract limit to other phecda module ",
   "author": "fgsreally",
   "license": "MIT",