phecda-core 4.5.0 → 5.0.0

package/dist/index.mjs

@@ -1,57 +1,50 @@
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/index.ts
+export * from "reflect-metadata";
 
 // src/core.ts
 var SHARE_KEY = Symbol("phecda[share]");
 var CLEAR_KEY = Symbol("phecda[clear]");
 var PHECDA_KEY = Symbol("phecda");
 function isPhecda(model) {
-  if (typeof model === "function")
-    return !!model.prototype[PHECDA_KEY];
+  if (typeof model === "function") return !!model.prototype[PHECDA_KEY];
   return false;
 }
+__name(isPhecda, "isPhecda");
 function init(proto) {
-  if (!proto)
-    return;
+  if (!proto) return;
   if (!proto.hasOwnProperty(PHECDA_KEY)) {
     proto[PHECDA_KEY] = {
       /**
-         * 元数据
-        */
+       * 元数据
+      */
       __META__: /* @__PURE__ */ new Map()
     };
   }
 }
+__name(init, "init");
 function getPhecdaFromTarget(target) {
-  if (typeof target === "function")
-    return target.prototype;
-  if (target.hasOwnProperty(PHECDA_KEY))
-    return target;
+  if (typeof target === "function") return target.prototype;
+  if (target.hasOwnProperty(PHECDA_KEY)) return target;
   return Object.getPrototypeOf(target);
 }
+__name(getPhecdaFromTarget, "getPhecdaFromTarget");
 function setMeta(proto, property, index, meta) {
-  if (typeof proto === "function" && proto.prototype)
-    proto = proto.prototype;
+  if (typeof proto === "function" && proto.prototype) proto = proto.prototype;
   if (!property) {
     property = SHARE_KEY;
-    if (proto.prototype)
-      proto = proto.prototype;
+    if (proto.prototype) proto = proto.prototype;
   }
   init(proto);
-  if (!proto[PHECDA_KEY].__META__.has(property))
-    proto[PHECDA_KEY].__META__.set(property, { data: [], params: /* @__PURE__ */ new Map() });
+  if (!proto[PHECDA_KEY].__META__.has(property)) proto[PHECDA_KEY].__META__.set(property, {
+    data: [],
+    params: /* @__PURE__ */ new Map()
+  });
   const oldMeta = proto[PHECDA_KEY].__META__.get(property);
   if (typeof index === "number") {
-    if (!oldMeta.params.has(index))
-      oldMeta.params.set(index, []);
+    if (!oldMeta.params.has(index)) oldMeta.params.set(index, []);
     const paramsMeta = oldMeta.params.get(index);
     paramsMeta.push(meta);
   } else {
@@ -59,27 +52,36 @@ function setMeta(proto, property, index, meta) {
   }
   proto[PHECDA_KEY].__META__.set(property, oldMeta);
 }
+__name(setMeta, "setMeta");
 function getOwnMetaKey(target) {
   const proto = getPhecdaFromTarget(target);
-  return [...proto[PHECDA_KEY].__META__.keys()];
+  return [
+    ...proto[PHECDA_KEY].__META__.keys()
+  ];
 }
+__name(getOwnMetaKey, "getOwnMetaKey");
 function getMetaKey(target) {
   let proto = getPhecdaFromTarget(target);
   const set2 = /* @__PURE__ */ new Set();
   while (proto?.[PHECDA_KEY]) {
     if (proto.hasOwnProperty(PHECDA_KEY)) {
-      for (const property of proto[PHECDA_KEY].__META__.keys())
-        set2.add(property);
+      for (const property of proto[PHECDA_KEY].__META__.keys()) set2.add(property);
     }
     proto = Object.getPrototypeOf(proto);
   }
-  return [...set2];
+  return [
+    ...set2
+  ];
 }
+__name(getMetaKey, "getMetaKey");
 function getOwnMetaParams(target, key = SHARE_KEY) {
   const proto = getPhecdaFromTarget(target);
   const { params } = proto[PHECDA_KEY].__META__.get(key);
-  return [...params.keys()];
+  return [
+    ...params.keys()
+  ];
 }
+__name(getOwnMetaParams, "getOwnMetaParams");
 function getMetaParams(target, key = SHARE_KEY) {
   let proto = getPhecdaFromTarget(target);
   const set2 = /* @__PURE__ */ new Set();
@@ -87,14 +89,16 @@ function getMetaParams(target, key = SHARE_KEY) {
     if (proto.hasOwnProperty(PHECDA_KEY)) {
       const meta = proto[PHECDA_KEY].__META__.get(key);
       if (meta) {
-        for (const index of meta.params.keys())
-          set2.add(index);
+        for (const index of meta.params.keys()) set2.add(index);
       }
     }
     proto = Object.getPrototypeOf(proto);
   }
-  return [...set2].sort((a, b) => a - b);
+  return [
+    ...set2
+  ].sort((a, b) => a - b);
 }
+__name(getMetaParams, "getMetaParams");
 function getMeta(target, property = SHARE_KEY, index) {
   let proto = getPhecdaFromTarget(target);
   const ret = [];
@@ -107,14 +111,12 @@ function getMeta(target, property = SHARE_KEY, index) {
           if (paramMeta) {
             const index2 = paramMeta.findIndex((item) => item[CLEAR_KEY]);
             ret.unshift(...paramMeta.slice(index2 + 1));
-            if (index2 > -1)
-              break;
+            if (index2 > -1) break;
           }
         } else {
           const index2 = meta.data.findIndex((item) => item[CLEAR_KEY]);
           ret.unshift(...meta.data.slice(index2 + 1));
-          if (index2 > -1)
-            break;
+          if (index2 > -1) break;
         }
       }
     }
@@ -122,18 +124,22 @@ function getMeta(target, property = SHARE_KEY, index) {
   }
   return ret;
 }
+__name(getMeta, "getMeta");
 function getOwnMeta(target, property = SHARE_KEY, index) {
   const proto = getPhecdaFromTarget(target);
   const meta = proto[PHECDA_KEY].__META__.get(property);
   return typeof index === "number" ? meta.params.get(index) : meta.data;
 }
+__name(getOwnMeta, "getOwnMeta");
 function set(proto, property, value) {
   init(proto);
   proto[`__${property.toUpperCase()}__`] = value;
 }
+__name(set, "set");
 function get(proto, property) {
   return proto[`__${property.toUpperCase()}__`];
 }
+__name(get, "get");
 
 // src/decorators/core.ts
 function Init(proto, property) {
@@ -143,6 +149,7 @@ function Init(proto, property) {
     }
   });
 }
+__name(Init, "Init");
 function Unmount(proto, property) {
   setMeta(proto, property, void 0, {
     async unmount(instance) {
@@ -150,39 +157,46 @@ function Unmount(proto, property) {
     }
   });
 }
+__name(Unmount, "Unmount");
 function Expose(proto, property, index) {
   setMeta(proto, property, index, {});
 }
+__name(Expose, "Expose");
 function Empty(model) {
   init(model.prototype);
 }
+__name(Empty, "Empty");
 function Clear(proto, property, index) {
   setMeta(proto, property, index, {
     [CLEAR_KEY]: true
   });
 }
+__name(Clear, "Clear");
 function Injectable() {
   return (target) => Empty(target);
 }
+__name(Injectable, "Injectable");
 
 // src/helper.ts
 function getTag(moduleOrInstance) {
-  if (typeof moduleOrInstance === "object")
-    moduleOrInstance = moduleOrInstance.constructor;
+  if (typeof moduleOrInstance === "object") moduleOrInstance = moduleOrInstance.constructor;
   return get(moduleOrInstance.prototype, "tag") || moduleOrInstance.name;
 }
+__name(getTag, "getTag");
 function addDecoToClass(c, key, handler) {
   handler(key ? c.prototype : c, key);
 }
+__name(addDecoToClass, "addDecoToClass");
 function Pipeline(...decos) {
   return (...args) => {
-    for (const d of decos)
-      d(...args);
+    for (const d of decos) d(...args);
   };
 }
+__name(Pipeline, "Pipeline");
 function isAsyncFunc(fn) {
   return fn[Symbol.toStringTag] === "AsyncFunction";
 }
+__name(isAsyncFunc, "isAsyncFunc");
 function invoke(instance, key, ...params) {
   const metaKeys = getMetaKey(instance);
   return Promise.allSettled(metaKeys.map((k) => {
@@ -194,12 +208,15 @@ function invoke(instance, key, ...params) {
     return res;
   });
 }
+__name(invoke, "invoke");
 function invokeInit(instance) {
   return instance.__PROMISE_SYMBOL__ = invoke(instance, "init");
 }
+__name(invokeInit, "invokeInit");
 function invokeUnmount(instance) {
   return instance.__PROMISE_SYMBOL__ = invoke(instance, "unmount");
 }
+__name(invokeUnmount, "invokeUnmount");
 function If(value, ...decorators) {
   if (value) {
     return (...args) => {
@@ -209,22 +226,22 @@ function If(value, ...decorators) {
   return () => {
   };
 }
+__name(If, "If");
 function getMergedMeta(target, property, index, merger = defaultMerger) {
   const meta = getMeta(target, property, index);
   return meta.reduce((p, c) => {
     return merger(p, c);
   }, {});
 }
+__name(getMergedMeta, "getMergedMeta");
 function defaultMerger(prev, cur) {
   const newMeta = {};
   for (const key in prev) {
-    if (key === CLEAR_KEY)
-      continue;
+    if (key === CLEAR_KEY) continue;
     newMeta[key] = prev[key];
   }
   for (const key in cur) {
-    if (key === CLEAR_KEY)
-      continue;
+    if (key === CLEAR_KEY) continue;
     if (newMeta[key] && cur[key]) {
       if (Array.isArray(newMeta[key]) && Array.isArray(cur[key])) {
         const set2 = new Set(newMeta[key]);
@@ -232,7 +249,9 @@ function defaultMerger(prev, cur) {
           set2.delete(item);
           set2.add(item);
         });
-        newMeta[key] = [...set2];
+        newMeta[key] = [
+          ...set2
+        ];
       } else if (typeof newMeta[key] === "object" && typeof cur[key] === "object") {
         newMeta[key] = defaultMerger(newMeta[key], cur[key]);
       } else {
@@ -244,9 +263,11 @@ function defaultMerger(prev, cur) {
   }
   return newMeta;
 }
+__name(defaultMerger, "defaultMerger");
 function wait(...instances) {
   return Promise.all(instances.map((i) => i.__PROMISE_SYMBOL__));
 }
+__name(wait, "wait");
 function objectToClass(obj) {
   return class {
     constructor() {
@@ -254,15 +275,21 @@ function objectToClass(obj) {
     }
   };
 }
+__name(objectToClass, "objectToClass");
 function functionToClass(fn) {
   return class {
+    prototype;
     constructor(...args) {
       Object.setPrototypeOf(this, fn(...args));
     }
   };
 }
+__name(functionToClass, "functionToClass");
 function omit(classFn, ...properties) {
   const newClass = class extends classFn {
+    static {
+      __name(this, "newClass");
+    }
     constructor(...args) {
       super(...args);
       properties.forEach((k) => {
@@ -271,21 +298,23 @@ function omit(classFn, ...properties) {
     }
   };
   getMetaKey(classFn).forEach((k) => {
-    if (properties.includes(k))
-      addDecoToClass(newClass, k, Clear);
+    if (properties.includes(k)) addDecoToClass(newClass, k, Clear);
   });
   return newClass;
 }
+__name(omit, "omit");
 function pick(classFn, ...properties) {
   const newClass = class {
+    static {
+      __name(this, "newClass");
+    }
     constructor(...args) {
       const instance = new classFn(...args);
       properties.forEach((prop) => {
         Object.defineProperty(this, prop, {
           get() {
             const data = instance[prop];
-            if (typeof data === "function")
-              return data.bind(this);
+            if (typeof data === "function") return data.bind(this);
             return data;
           },
           set(val) {
@@ -305,77 +334,89 @@ function pick(classFn, ...properties) {
   });
   return newClass;
 }
+__name(pick, "pick");
 function partial(classFn, ...properties) {
   const newClass = class extends classFn {
+    static {
+      __name(this, "newClass");
+    }
   };
   getMetaKey(classFn).forEach((k) => {
-    if (properties.length === 0 || properties.includes(k))
-      addDecoToClass(newClass, k, Optional);
+    if (properties.length === 0 || properties.includes(k)) addDecoToClass(newClass, k, Optional);
   });
   return newClass;
 }
+__name(partial, "partial");
 function override(classFn, ...properties) {
   return classFn;
 }
+__name(override, "override");
 
 // src/di.ts
 var DataMap = {};
 function Provide(key, value) {
   DataMap[key] = value;
 }
+__name(Provide, "Provide");
 function Inject(key) {
   return DataMap[key];
 }
+__name(Inject, "Inject");
 var activeInstance = {};
 function setInject(key, value) {
   activeInstance[key] = value;
   return activeInstance;
 }
+__name(setInject, "setInject");
 function getInject(key) {
   return activeInstance[key];
 }
+__name(getInject, "getInject");
 
 // src/decorators/function.ts
 function Isolate(model) {
   set(model.prototype, "isolate", true);
 }
+__name(Isolate, "Isolate");
 function Tag(tag) {
   return (model) => {
     set(model.prototype, "tag", tag);
   };
 }
+__name(Tag, "Tag");
 function Unique(desc) {
   return (model) => {
     set(model.prototype, "tag", Symbol(desc || model.name));
   };
 }
+__name(Unique, "Unique");
 function Assign(cb) {
   return (model) => {
     setMeta(model, void 0, void 0, {
-      init: async (instance) => {
+      init: /* @__PURE__ */ __name(async (instance) => {
         const value = await cb(instance);
         if (value && typeof value === "object" && !Array.isArray(value)) {
-          for (const i in value)
-            instance[i] = value[i];
+          for (const i in value) instance[i] = value[i];
         }
-      }
+      }, "init")
     });
   };
 }
+__name(Assign, "Assign");
 function Global(model) {
   setMeta(model, void 0, void 0, {
-    init: async (instance) => {
+    init: /* @__PURE__ */ __name(async (instance) => {
       const tag = getTag(instance);
-      if (!globalThis.__PHECDA__)
-        globalThis.__PHECDA__ = {};
+      if (!globalThis.__PHECDA__) globalThis.__PHECDA__ = {};
       globalThis.__PHECDA__[tag] = instance.constructor;
-    }
+    }, "init")
   });
 }
+__name(Global, "Global");
 function Err(cb, isCatch = false) {
   return (proto, property) => {
     setMeta(proto, property, void 0, {
-      init: (instance) => {
+      init: /* @__PURE__ */ __name((instance) => {
         if (typeof instance[property] === "function") {
           const oldFn = instance[property].bind(instance);
           if (isAsyncFunc(oldFn)) {
@@ -384,8 +425,7 @@ function Err(cb, isCatch = false) {
                 await oldFn(...args);
               } catch (e) {
                 cb(e, instance, property);
-                if (!isCatch)
-                  throw e;
+                if (!isCatch) throw e;
               }
             };
           } else {
@@ -394,22 +434,27 @@ function Err(cb, isCatch = false) {
                 oldFn(...args);
               } catch (e) {
                 cb(e, instance, property);
-                if (!isCatch)
-                  throw e;
+                if (!isCatch) throw e;
               }
             };
           }
         }
-      }
+      }, "init")
     });
   };
 }
+__name(Err, "Err");
 function Watcher(eventName, options) {
   let cb;
   return (proto, property) => {
     setMeta(proto, property, void 0, {
       init(instance) {
-        return cb = getInject("watcher")?.({ eventName, instance, property, options });
+        return cb = getInject("watcher")?.({
+          eventName,
+          instance,
+          property,
+          options
+        });
       },
       unmount() {
         return cb?.();
@@ -417,6 +462,7 @@ function Watcher(eventName, options) {
     });
   };
 }
+__name(Watcher, "Watcher");
 function Effect(cb) {
   return (proto, property) => {
     setMeta(proto, property, void 0, {
@@ -436,44 +482,119 @@ function Effect(cb) {
     });
   };
 }
+__name(Effect, "Effect");
 function Storage({ key, json, stringify } = {}) {
-  if (!json)
-    json = (v) => JSON.parse(v);
-  if (!stringify)
-    stringify = (v) => JSON.stringify(v);
+  if (!json) json = /* @__PURE__ */ __name((v) => JSON.parse(v), "json");
+  if (!stringify) stringify = /* @__PURE__ */ __name((v) => JSON.stringify(v), "stringify");
   return (proto, property) => {
     const tag = key || getTag(proto);
     init(proto);
     setMeta(proto, property, void 0, {
-      init: (instance) => {
-        return getInject("storage")?.({ instance, property, tag, toJSON: json, toString: stringify });
-      }
+      init: /* @__PURE__ */ __name((instance) => {
+        return getInject("storage")?.({
+          instance,
+          property,
+          tag,
+          toJSON: json,
+          toString: stringify
+        });
+      }, "init")
     });
   };
 }
+__name(Storage, "Storage");
 
 // src/decorators/other.ts
+function Doc(doc) {
+  return (target, property, index) => {
+    setMeta(target, property, index, {
+      doc
+    });
+  };
+}
+__name(Doc, "Doc");
+
+// src/decorators/rule.ts
 function Rule(...rules) {
   return (target, property, index) => {
-    setMeta(target, property, index, { rules });
+    setMeta(target, property, index, {
+      rules
+    });
   };
 }
+__name(Rule, "Rule");
 function Required(target, property, index) {
-  setMeta(target, property, index, { required: true });
+  setMeta(target, property, index, {
+    required: true
+  });
 }
+__name(Required, "Required");
 function Optional(target, property, index) {
-  setMeta(target, property, index, { required: false });
+  setMeta(target, property, index, {
+    required: false
+  });
 }
-function Doc(doc) {
+__name(Optional, "Optional");
+function Min(min) {
   return (target, property, index) => {
-    setMeta(target, property, index, { doc });
+    setMeta(target, property, index, {
+      min
+    });
   };
 }
+__name(Min, "Min");
+function Max(max) {
+  return (target, property, index) => {
+    setMeta(target, property, index, {
+      max
+    });
+  };
+}
+__name(Max, "Max");
+function Nested(model) {
+  return (target, property) => {
+    setMeta(target, property, void 0, {
+      nested: model
+    });
+  };
+}
+__name(Nested, "Nested");
+function OneOf(...models) {
+  return (target, property) => {
+    setMeta(target, property, void 0, {
+      oneOf: models
+    });
+  };
+}
+__name(OneOf, "OneOf");
+function Enum(map) {
+  return (target, property) => {
+    setMeta(target, property, void 0, {
+      enum: map
+    });
+  };
+}
+__name(Enum, "Enum");
 
 // src/base.ts
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
 var Base = class {
+  static {
+    __name(this, "Base");
+  }
+  __UNMOUNT_SYMBOL__ = [];
+  __PROMISE_SYMBOL__;
   constructor() {
-    this.__UNMOUNT_SYMBOL__ = [];
   }
   get tag() {
     return getTag(this);
@@ -496,20 +617,164 @@ var Base = class {
   onUnmount(cb) {
     this.__UNMOUNT_SYMBOL__.push(cb);
   }
-  // @ts-expect-error for internal
   _unmount() {
     return Promise.all(this.__UNMOUNT_SYMBOL__.map((fn) => fn()));
   }
 };
-__decorateClass([
-  Init
-], Base.prototype, "init", 1);
-__decorateClass([
-  Unmount
-], Base.prototype, "_unmount", 1);
-Base = __decorateClass([
-  Empty
+_ts_decorate([
+  Init,
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", void 0)
+], Base.prototype, "init", null);
+_ts_decorate([
+  Unmount,
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", void 0)
+], Base.prototype, "_unmount", null);
+Base = _ts_decorate([
+  Empty,
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [])
 ], Base);
+
+// src/validate.ts
+var _createErrorMessage = /* @__PURE__ */ __name((type, { property, meta }) => {
+  switch (type) {
+    case "string":
+      return `must be a string for "${property}"`;
+    case "number":
+      return `must be a number for "${property}"`;
+    case "boolean":
+      return `must be a boolean for "${property}"`;
+    case "oneOf":
+      return `must be one of models(${meta.oneof.map((m) => getTag(m)).join(", ")}) for "${property}"`;
+    case "min":
+      return `must be greater than ${meta.min} for "${property}"`;
+    case "max":
+      return `must be less than ${meta.max} for "${property}"`;
+    case "enum":
+      return `must be one of ${Object.values(meta.enum).join(", ")} for "${property}"`;
+    case "required":
+      return `it is required for "${property}"`;
+    case "object":
+      return `must be an object for "${property}"`;
+    case "array":
+      return `must be an array for "${property}"`;
+    case "stringArray":
+      return `must be an array of strings for "${property}"`;
+    case "numberArray":
+      return `must be an array of numbers for "${property}"`;
+    case "booleanArray":
+      return `must be an array of booleans for "${property}"`;
+  }
+  return `invalid value for "${property}"`;
+}, "_createErrorMessage");
+function isObject(value) {
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+__name(isObject, "isObject");
+async function validate(model, data, collectErrors = false, createErrMsg = _createErrorMessage) {
+  async function parse(model2, data2) {
+    const 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 (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;
+                }
+              }
+            }
+          } 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", 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 modelOrRule of oneOf) {
+              if (isPhecda(modelOrRule)) {
+                const errs = await validate(modelOrRule, value2);
+                if (!errs.length) {
+                  isCorrect = true;
+                  break;
+                }
+              } else if (typeof modelOrRule === "function") {
+                const errs = await modelOrRule(args2);
+                if (!errs.length) {
+                  isCorrect = true;
+                  break;
+                }
+              }
+            }
+            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;
+        }
+      }
+      if (errors.length !== 0 && !collectErrors) break;
+    }
+    return errors;
+  }
+  __name(parse, "parse");
+  return await parse(model, data);
+}
+__name(validate, "validate");
 export {
   Assign,
   Base,
@@ -519,6 +784,7 @@ export {
   Doc,
   Effect,
   Empty,
+  Enum,
   Err,
   Expose,
   Global,
@@ -527,6 +793,10 @@ export {
   Inject,
   Injectable,
   Isolate,
+  Max,
+  Min,
+  Nested,
+  OneOf,
   Optional,
   PHECDA_KEY,
   Pipeline,
@@ -539,6 +809,7 @@ export {
   Unique,
   Unmount,
   Watcher,
+  _createErrorMessage,
   activeInstance,
   addDecoToClass,
   functionToClass,
@@ -567,5 +838,6 @@ export {
   set,
   setInject,
   setMeta,
+  validate,
   wait
 };