phecda-core 3.0.0-alpha.10 → 3.0.0-alpha.11

package/dist/index.d.ts

@@ -1,3 +1,11 @@
+declare function Init(proto: any, key: PropertyKey): void;
+declare function Unmount(proto: any, key: PropertyKey): void;
+declare function Bind(value: any): (proto: any, k: PropertyKey) => void;
+declare function Ignore(proto: any, key: PropertyKey): void;
+declare function Clear(proto: any, key: PropertyKey): void;
+declare function Expose(proto: any, key: PropertyKey): void;
+declare function Empty(module: any): void;
+
 interface NameSpace {
     [name: string]: Phecda;
 }
@@ -25,37 +33,51 @@ type ClassValue<I> = {
 interface Events {
 }
 
-declare function Init(proto: any, key: PropertyKey): void;
-declare function Unmount(proto: any, key: PropertyKey): void;
-declare function Bind(value: any): (proto: any, k: PropertyKey) => void;
-declare function Ignore(proto: any, key: PropertyKey): void;
-declare function Clear(proto: any, key: PropertyKey): void;
-declare function Err<Fn extends (...args: any) => any>(cb: Fn): (proto: any, key: PropertyKey) => void;
-declare function Expose(proto: any, key: PropertyKey): void;
-declare function To(...callbacks: ((arg: any, instance: any, key: string) => any)[]): (proto: any, key: PropertyKey) => void;
+declare function Isolate(target: any): void;
 declare function Tag(tag: PropertyKey): (module: any) => void;
 declare function Unique(desc?: string): (module: any) => void;
 declare function Assign(cb: (instance?: any) => any): (module: any) => void;
 declare function Global(module: any): void;
-declare function Empty(module: any): void;
-declare const DataMap: InjectData;
-declare function Provide<K extends keyof InjectData>(key: K, value: InjectData[K]): void;
-declare function Inject<K extends keyof InjectData>(key: K): InjectData[K];
-declare function Nested<M extends new (...args: any) => any>(module: M): (proto: any, key: PropertyKey) => void;
-declare function Isolate(): (target: any) => void;
+declare function To(...callbacks: ((arg: any, instance: any, key: string) => any)[]): (proto: any, key: PropertyKey) => void;
+declare function Err(cb: (e: Error | any) => void, isCatch?: boolean): (proto: any, key: PropertyKey) => void;
+interface StorageParam {
+    key?: string;
+    instance: any;
+    tag: string;
+    toJSON: (str: string) => any;
+    toString: (arg: any) => string;
+}
+interface WatcherParam {
+    key: string;
+    instance: any;
+    eventName: string;
+    options?: {
+        once?: boolean;
+    };
+}
+declare function Watcher(eventName: keyof Events, options?: {
+    once?: boolean;
+}): (proto: any, key: string) => void;
+declare function Effect(eventName: string, options?: any): (proto: any, key: string) => void;
+declare function Storage({ key: storeKey, toJSON, toString }?: {
+    toJSON?: (str: string) => any;
+    toString?: (arg: any) => string;
+    key?: string;
+}): (proto: any, key?: PropertyKey) => void;
 
 declare function getTag<M extends Construct | AbConstruct>(moduleOrInstance: M | InstanceType<M>): PropertyKey;
 declare function getBind<M extends Construct | AbConstruct>(module: M): any;
 declare function plainToClass<M extends Construct, Data extends Record<PropertyKey, any>>(module: M, input: Data): InstanceType<M>;
 declare function transformClass<M extends Construct>(instance: InstanceType<M>, force?: boolean): Promise<string[]>;
-declare function classToValue<M>(instance: M): ClassValue<M>;
+declare function classToPlain<M>(instance: M): ClassValue<M>;
 declare function snapShot<T extends Construct>(data: InstanceType<T>): {
     data: InstanceType<T>;
     clear(): void;
     apply(): void;
 };
-declare function addDecoToClass<M extends Construct | AbConstruct>(c: M, key: keyof InstanceType<M> | string, handler: ((target: any, key: PropertyKey) => void), type?: 'property' | 'class'): void;
+declare function addDecoToClass<M extends Construct | AbConstruct>(c: M, key: keyof InstanceType<M> | PropertyKey, handler: PropertyDecorator | ClassDecorator): void;
 declare function Pipeline(...decos: ((...args: any) => void)[]): (...args: any) => void;
+declare function isAsyncFunc(fn: Function): boolean;
 
 declare function isPhecda(module: any): module is Construct;
 declare const SHARE_KEY: unique symbol;
@@ -76,32 +98,11 @@ declare function getOwnState(instance: Phecda, key: PropertyKey): Object;
 declare function getState(instance: Phecda, key: PropertyKey): any;
 declare function invokeHandler(event: string, instance: Phecda): Promise<any[]>;
 
-interface StorageParam {
-    key?: string;
-    instance: any;
-    tag: string;
-    toJSON: (str: string) => any;
-    toString: (arg: any) => string;
-}
-interface WatcherParam {
-    key: string;
-    instance: any;
-    eventName: string;
-    options?: {
-        once?: boolean;
-    };
-}
+declare const DataMap: InjectData;
+declare function Provide<K extends keyof InjectData>(key: K, value: InjectData[K]): void;
+declare function Inject<K extends keyof InjectData>(key: K): InjectData[K];
 declare const activeInstance: Record<string, any>;
 declare function injectProperty(key: string, value: any): Record<string, any>;
 declare function getProperty(key: string): any;
-declare function Watcher(eventName: keyof Events, options?: {
-    once?: boolean;
-}): (proto: any, key: string) => void;
-declare function Effect(eventName: string, options?: any): (proto: any, key: string) => void;
-declare function Storage({ key: storeKey, toJSON, toString }?: {
-    toJSON?: (str: string) => any;
-    toString?: (arg: any) => string;
-    key?: string;
-}): (proto: any, key?: PropertyKey) => void;
 
-export { AbConstruct, Assign, Bind, ClassValue, Clear, Construct, DataMap, Effect, Empty, Err, Events, Expose, Global, Handler, Ignore, Init, Inject, InjectData, Isolate, NameSpace, Nested, Phecda, Pipeline, Provide, SHARE_KEY, Storage, StorageParam, Tag, To, Unique, Unmount, Watcher, WatcherParam, activeInstance, addDecoToClass, classToValue, getBind, getExposeKey, getHandler, getModuleState, getOwnExposeKey, getOwnHandler, getOwnIgnoreKey, getOwnModuleState, getOwnState, getProperty, getState, getTag, init, injectProperty, invokeHandler, isPhecda, plainToClass, regisHandler, setExposeKey, setIgnoreKey, setState, setVar, snapShot, transformClass };
+export { AbConstruct, Assign, Bind, ClassValue, Clear, Construct, DataMap, Effect, Empty, Err, Events, Expose, Global, Handler, Ignore, Init, Inject, InjectData, Isolate, NameSpace, Phecda, Pipeline, Provide, SHARE_KEY, Storage, StorageParam, Tag, To, Unique, Unmount, Watcher, WatcherParam, activeInstance, addDecoToClass, classToPlain, getBind, getExposeKey, getHandler, getModuleState, getOwnExposeKey, getOwnHandler, getOwnIgnoreKey, getOwnModuleState, getOwnState, getProperty, getState, getTag, init, injectProperty, invokeHandler, isAsyncFunc, isPhecda, plainToClass, regisHandler, setExposeKey, setIgnoreKey, setState, setVar, snapShot, transformClass };

package/dist/index.js

@@ -34,7 +34,6 @@ __export(src_exports, {
   Init: () => Init,
   Inject: () => Inject,
   Isolate: () => Isolate,
-  Nested: () => Nested,
   Pipeline: () => Pipeline,
   Provide: () => Provide,
   SHARE_KEY: () => SHARE_KEY,
@@ -46,7 +45,7 @@ __export(src_exports, {
   Watcher: () => Watcher,
   activeInstance: () => activeInstance,
   addDecoToClass: () => addDecoToClass,
-  classToValue: () => classToValue,
+  classToPlain: () => classToPlain,
   getBind: () => getBind,
   getExposeKey: () => getExposeKey,
   getHandler: () => getHandler,
@@ -58,10 +57,11 @@ __export(src_exports, {
   getOwnState: () => getOwnState,
   getProperty: () => getProperty,
   getState: () => getState,
-  getTag: () => getTag2,
+  getTag: () => getTag,
   init: () => init,
   injectProperty: () => injectProperty,
   invokeHandler: () => invokeHandler,
+  isAsyncFunc: () => isAsyncFunc,
   isPhecda: () => isPhecda,
   plainToClass: () => plainToClass,
   regisHandler: () => regisHandler,
@@ -223,13 +223,63 @@ function invokeHandler(event, instance) {
 }
 __name(invokeHandler, "invokeHandler");
 
+// src/decorators/core.ts
+function Init(proto, key) {
+  setVar(proto, key);
+  regisHandler(proto, key, {
+    async init(instance) {
+      return instance[key]();
+    }
+  });
+}
+__name(Init, "Init");
+function Unmount(proto, key) {
+  setVar(proto, key);
+  regisHandler(proto, key, {
+    async unmount(instance) {
+      return instance[key]();
+    }
+  });
+}
+__name(Unmount, "Unmount");
+function Bind(value) {
+  return (proto, k) => {
+    setVar(proto, k);
+    setState(proto, k, {
+      value
+    });
+  };
+}
+__name(Bind, "Bind");
+function Ignore(proto, key) {
+  setIgnoreKey(proto, key);
+}
+__name(Ignore, "Ignore");
+function Clear(proto, key) {
+  init(proto);
+  proto._namespace.__EXPOSE_VAR__.delete(key);
+  proto._namespace.__IGNORE_VAR__.delete(key);
+  proto._namespace.__STATE_VAR__.delete(key);
+  proto._namespace.__STATE_HANDLER__.delete(key);
+  proto._namespace.__STATE_NAMESPACE__.delete(key);
+}
+__name(Clear, "Clear");
+function Expose(proto, key) {
+  setExposeKey(proto, key);
+}
+__name(Expose, "Expose");
+function Empty(module2) {
+  init(module2.prototype);
+}
+__name(Empty, "Empty");
+
 // src/helper.ts
-function getTag2(moduleOrInstance) {
+function getTag(moduleOrInstance) {
   if (typeof moduleOrInstance === "object")
     moduleOrInstance = moduleOrInstance.constructor;
   return moduleOrInstance.prototype?.__TAG__ || moduleOrInstance.name;
 }
-__name(getTag2, "getTag");
+__name(getTag, "getTag");
 function getBind(module2) {
   const instance = new module2();
   const keys = getModuleState(instance);
@@ -271,14 +321,14 @@ async function transformClass(instance, force = false) {
   return err;
 }
 __name(transformClass, "transformClass");
-function classToValue(instance) {
+function classToPlain(instance) {
   const data = {};
   const exposeVars = getExposeKey(instance);
   for (const item of exposeVars)
     data[item] = instance[item];
-  return data;
+  return JSON.parse(JSON.stringify(data));
 }
-__name(classToValue, "classToValue");
+__name(classToPlain, "classToPlain");
 function snapShot(data) {
   const snap = {};
   for (const i in data)
@@ -296,8 +346,8 @@ function snapShot(data) {
   };
 }
 __name(snapShot, "snapShot");
-function addDecoToClass(c, key, handler, type = "class") {
-  handler(type === "class" ? c.prototype : c, key);
+function addDecoToClass(c, key, handler) {
+  handler(key === SHARE_KEY ? c : c.prototype, key);
 }
 __name(addDecoToClass, "addDecoToClass");
 function Pipeline(...decos) {
@@ -307,73 +357,43 @@ function Pipeline(...decos) {
   };
 }
 __name(Pipeline, "Pipeline");
-
-// src/decorators.ts
-function Init(proto, key) {
-  setVar(proto, key);
-  regisHandler(proto, key, {
-    async init(instance) {
-      return instance[key]();
-    }
-  });
+function isAsyncFunc(fn) {
+  return fn[Symbol.toStringTag] === "AsyncFunction";
 }
-__name(Init, "Init");
-function Unmount(proto, key) {
-  setVar(proto, key);
-  regisHandler(proto, key, {
-    async unmount(instance) {
-      return instance[key]();
-    }
-  });
-}
-__name(Unmount, "Unmount");
-function Bind(value) {
-  return (proto, k) => {
-    setVar(proto, k);
-    setState(proto, k, {
-      value
-    });
-  };
-}
-__name(Bind, "Bind");
-function Ignore(proto, key) {
-  setIgnoreKey(proto, key);
+__name(isAsyncFunc, "isAsyncFunc");
+
+// src/di.ts
+var DataMap = {};
+function Provide(key, value) {
+  DataMap[key] = value;
 }
-__name(Ignore, "Ignore");
-function Clear(proto, key) {
-  init(proto);
-  proto._namespace.__EXPOSE_VAR__.delete(key);
-  proto._namespace.__IGNORE_VAR__.delete(key);
-  proto._namespace.__STATE_VAR__.delete(key);
-  proto._namespace.__STATE_HANDLER__.delete(key);
-  proto._namespace.__STATE_NAMESPACE__.delete(key);
+__name(Provide, "Provide");
+var EmptyProxy = new Proxy(Empty, {
+  apply() {
+    return EmptyProxy;
+  }
+});
+function Inject(key) {
+  return DataMap[key] || EmptyProxy;
 }
-__name(Clear, "Clear");
-function Err(cb) {
-  return (proto, key) => {
-    setVar(proto, key);
-    regisHandler(proto, key, {
-      error: cb
-    });
-  };
+__name(Inject, "Inject");
+var activeInstance = {};
+function injectProperty(key, value) {
+  activeInstance[key] = value;
+  return activeInstance;
 }
-__name(Err, "Err");
-function Expose(proto, key) {
-  setExposeKey(proto, key);
+__name(injectProperty, "injectProperty");
+function getProperty(key) {
+  return activeInstance[key];
 }
-__name(Expose, "Expose");
-function To(...callbacks) {
-  return (proto, key) => {
-    setVar(proto, key);
-    regisHandler(proto, key, {
-      async pipe(instance) {
-        for (const cb of callbacks)
-          instance[key] = await cb(instance[key], instance, key);
-      }
-    });
-  };
+__name(getProperty, "getProperty");
+
+// src/decorators/function.ts
+function Isolate(target) {
+  init(target.prototype);
+  target.prototype.__ISOLATE__ = true;
 }
-__name(To, "To");
+__name(Isolate, "Isolate");
 function Tag(tag) {
   return (module2) => {
     init(module2.prototype);
@@ -419,53 +439,52 @@ function Global(module2) {
   });
 }
 __name(Global, "Global");
-function Empty(module2) {
-  init(module2.prototype);
-}
-__name(Empty, "Empty");
-var DataMap = {};
-function Provide(key, value) {
-  DataMap[key] = value;
-}
-__name(Provide, "Provide");
-var EmptyProxy = new Proxy(Empty, {
-  apply() {
-    return EmptyProxy;
-  }
-});
-function Inject(key) {
-  return DataMap[key] || EmptyProxy;
-}
-__name(Inject, "Inject");
-function Nested(module2) {
-  return To(async (property) => {
-    const instance = plainToClass(module2, property);
-    const err = await transformClass(instance);
-    if (err.length > 0)
-      throw new Error(err[0]);
-    return instance;
-  });
-}
-__name(Nested, "Nested");
-function Isolate() {
-  return (target) => {
-    init(target.prototype);
-    target.prototype.__ISOLATE__ = true;
+function To(...callbacks) {
+  return (proto, key) => {
+    setVar(proto, key);
+    regisHandler(proto, key, {
+      async pipe(instance) {
+        for (const cb of callbacks)
+          instance[key] = await cb(instance[key], instance, key);
+      }
+    });
   };
 }
-__name(Isolate, "Isolate");
-
-// src/custom/decorator.ts
-var activeInstance = {};
-function injectProperty(key, value) {
-  activeInstance[key] = value;
-  return activeInstance;
-}
-__name(injectProperty, "injectProperty");
-function getProperty(key) {
-  return activeInstance[key];
+__name(To, "To");
+function Err(cb, isCatch = false) {
+  return (proto, key) => {
+    setVar(proto, key);
+    regisHandler(proto, key, {
+      init: (instance) => {
+        if (typeof instance[key] === "function") {
+          const oldFn = instance[key].bind(instance);
+          if (isAsyncFunc(oldFn)) {
+            instance[key] = async (...args) => {
+              try {
+                await oldFn(...args);
+              } catch (e) {
+                cb(e);
+                if (!isCatch)
+                  throw e;
+              }
+            };
+          } else {
+            instance[key] = (...args) => {
+              try {
+                oldFn(...args);
+              } catch (e) {
+                cb(e);
+                if (!isCatch)
+                  throw e;
+              }
+            };
+          }
+        }
+      }
+    });
+  };
 }
-__name(getProperty, "getProperty");
+__name(Err, "Err");
 function Watcher(eventName, options) {
   let cb;
   return (proto, key) => {
@@ -568,7 +587,6 @@ __name(Storage, "Storage");
   Init,
   Inject,
   Isolate,
-  Nested,
   Pipeline,
   Provide,
   SHARE_KEY,
@@ -580,7 +598,7 @@ __name(Storage, "Storage");
   Watcher,
   activeInstance,
   addDecoToClass,
-  classToValue,
+  classToPlain,
   getBind,
   getExposeKey,
   getHandler,
@@ -596,6 +614,7 @@ __name(Storage, "Storage");
   init,
   injectProperty,
   invokeHandler,
+  isAsyncFunc,
   isPhecda,
   plainToClass,
   regisHandler,

package/dist/index.mjs

@@ -150,13 +150,63 @@ function invokeHandler(event, instance) {
 }
 __name(invokeHandler, "invokeHandler");
 
+// src/decorators/core.ts
+function Init(proto, key) {
+  setVar(proto, key);
+  regisHandler(proto, key, {
+    async init(instance) {
+      return instance[key]();
+    }
+  });
+}
+__name(Init, "Init");
+function Unmount(proto, key) {
+  setVar(proto, key);
+  regisHandler(proto, key, {
+    async unmount(instance) {
+      return instance[key]();
+    }
+  });
+}
+__name(Unmount, "Unmount");
+function Bind(value) {
+  return (proto, k) => {
+    setVar(proto, k);
+    setState(proto, k, {
+      value
+    });
+  };
+}
+__name(Bind, "Bind");
+function Ignore(proto, key) {
+  setIgnoreKey(proto, key);
+}
+__name(Ignore, "Ignore");
+function Clear(proto, key) {
+  init(proto);
+  proto._namespace.__EXPOSE_VAR__.delete(key);
+  proto._namespace.__IGNORE_VAR__.delete(key);
+  proto._namespace.__STATE_VAR__.delete(key);
+  proto._namespace.__STATE_HANDLER__.delete(key);
+  proto._namespace.__STATE_NAMESPACE__.delete(key);
+}
+__name(Clear, "Clear");
+function Expose(proto, key) {
+  setExposeKey(proto, key);
+}
+__name(Expose, "Expose");
+function Empty(module) {
+  init(module.prototype);
+}
+__name(Empty, "Empty");
+
 // src/helper.ts
-function getTag2(moduleOrInstance) {
+function getTag(moduleOrInstance) {
   if (typeof moduleOrInstance === "object")
     moduleOrInstance = moduleOrInstance.constructor;
   return moduleOrInstance.prototype?.__TAG__ || moduleOrInstance.name;
 }
-__name(getTag2, "getTag");
+__name(getTag, "getTag");
 function getBind(module) {
   const instance = new module();
   const keys = getModuleState(instance);
@@ -198,14 +248,14 @@ async function transformClass(instance, force = false) {
   return err;
 }
 __name(transformClass, "transformClass");
-function classToValue(instance) {
+function classToPlain(instance) {
   const data = {};
   const exposeVars = getExposeKey(instance);
   for (const item of exposeVars)
     data[item] = instance[item];
-  return data;
+  return JSON.parse(JSON.stringify(data));
 }
-__name(classToValue, "classToValue");
+__name(classToPlain, "classToPlain");
 function snapShot(data) {
   const snap = {};
   for (const i in data)
@@ -223,8 +273,8 @@ function snapShot(data) {
   };
 }
 __name(snapShot, "snapShot");
-function addDecoToClass(c, key, handler, type = "class") {
-  handler(type === "class" ? c.prototype : c, key);
+function addDecoToClass(c, key, handler) {
+  handler(key === SHARE_KEY ? c : c.prototype, key);
 }
 __name(addDecoToClass, "addDecoToClass");
 function Pipeline(...decos) {
@@ -234,73 +284,43 @@ function Pipeline(...decos) {
   };
 }
 __name(Pipeline, "Pipeline");
-
-// src/decorators.ts
-function Init(proto, key) {
-  setVar(proto, key);
-  regisHandler(proto, key, {
-    async init(instance) {
-      return instance[key]();
-    }
-  });
+function isAsyncFunc(fn) {
+  return fn[Symbol.toStringTag] === "AsyncFunction";
 }
-__name(Init, "Init");
-function Unmount(proto, key) {
-  setVar(proto, key);
-  regisHandler(proto, key, {
-    async unmount(instance) {
-      return instance[key]();
-    }
-  });
-}
-__name(Unmount, "Unmount");
-function Bind(value) {
-  return (proto, k) => {
-    setVar(proto, k);
-    setState(proto, k, {
-      value
-    });
-  };
-}
-__name(Bind, "Bind");
-function Ignore(proto, key) {
-  setIgnoreKey(proto, key);
+__name(isAsyncFunc, "isAsyncFunc");
+
+// src/di.ts
+var DataMap = {};
+function Provide(key, value) {
+  DataMap[key] = value;
 }
-__name(Ignore, "Ignore");
-function Clear(proto, key) {
-  init(proto);
-  proto._namespace.__EXPOSE_VAR__.delete(key);
-  proto._namespace.__IGNORE_VAR__.delete(key);
-  proto._namespace.__STATE_VAR__.delete(key);
-  proto._namespace.__STATE_HANDLER__.delete(key);
-  proto._namespace.__STATE_NAMESPACE__.delete(key);
+__name(Provide, "Provide");
+var EmptyProxy = new Proxy(Empty, {
+  apply() {
+    return EmptyProxy;
+  }
+});
+function Inject(key) {
+  return DataMap[key] || EmptyProxy;
 }
-__name(Clear, "Clear");
-function Err(cb) {
-  return (proto, key) => {
-    setVar(proto, key);
-    regisHandler(proto, key, {
-      error: cb
-    });
-  };
+__name(Inject, "Inject");
+var activeInstance = {};
+function injectProperty(key, value) {
+  activeInstance[key] = value;
+  return activeInstance;
 }
-__name(Err, "Err");
-function Expose(proto, key) {
-  setExposeKey(proto, key);
+__name(injectProperty, "injectProperty");
+function getProperty(key) {
+  return activeInstance[key];
 }
-__name(Expose, "Expose");
-function To(...callbacks) {
-  return (proto, key) => {
-    setVar(proto, key);
-    regisHandler(proto, key, {
-      async pipe(instance) {
-        for (const cb of callbacks)
-          instance[key] = await cb(instance[key], instance, key);
-      }
-    });
-  };
+__name(getProperty, "getProperty");
+
+// src/decorators/function.ts
+function Isolate(target) {
+  init(target.prototype);
+  target.prototype.__ISOLATE__ = true;
 }
-__name(To, "To");
+__name(Isolate, "Isolate");
 function Tag(tag) {
   return (module) => {
     init(module.prototype);
@@ -346,53 +366,52 @@ function Global(module) {
   });
 }
 __name(Global, "Global");
-function Empty(module) {
-  init(module.prototype);
-}
-__name(Empty, "Empty");
-var DataMap = {};
-function Provide(key, value) {
-  DataMap[key] = value;
-}
-__name(Provide, "Provide");
-var EmptyProxy = new Proxy(Empty, {
-  apply() {
-    return EmptyProxy;
-  }
-});
-function Inject(key) {
-  return DataMap[key] || EmptyProxy;
-}
-__name(Inject, "Inject");
-function Nested(module) {
-  return To(async (property) => {
-    const instance = plainToClass(module, property);
-    const err = await transformClass(instance);
-    if (err.length > 0)
-      throw new Error(err[0]);
-    return instance;
-  });
-}
-__name(Nested, "Nested");
-function Isolate() {
-  return (target) => {
-    init(target.prototype);
-    target.prototype.__ISOLATE__ = true;
+function To(...callbacks) {
+  return (proto, key) => {
+    setVar(proto, key);
+    regisHandler(proto, key, {
+      async pipe(instance) {
+        for (const cb of callbacks)
+          instance[key] = await cb(instance[key], instance, key);
+      }
+    });
   };
 }
-__name(Isolate, "Isolate");
-
-// src/custom/decorator.ts
-var activeInstance = {};
-function injectProperty(key, value) {
-  activeInstance[key] = value;
-  return activeInstance;
-}
-__name(injectProperty, "injectProperty");
-function getProperty(key) {
-  return activeInstance[key];
+__name(To, "To");
+function Err(cb, isCatch = false) {
+  return (proto, key) => {
+    setVar(proto, key);
+    regisHandler(proto, key, {
+      init: (instance) => {
+        if (typeof instance[key] === "function") {
+          const oldFn = instance[key].bind(instance);
+          if (isAsyncFunc(oldFn)) {
+            instance[key] = async (...args) => {
+              try {
+                await oldFn(...args);
+              } catch (e) {
+                cb(e);
+                if (!isCatch)
+                  throw e;
+              }
+            };
+          } else {
+            instance[key] = (...args) => {
+              try {
+                oldFn(...args);
+              } catch (e) {
+                cb(e);
+                if (!isCatch)
+                  throw e;
+              }
+            };
+          }
+        }
+      }
+    });
+  };
 }
-__name(getProperty, "getProperty");
+__name(Err, "Err");
 function Watcher(eventName, options) {
   let cb;
   return (proto, key) => {
@@ -494,7 +513,6 @@ export {
   Init,
   Inject,
   Isolate,
-  Nested,
   Pipeline,
   Provide,
   SHARE_KEY,
@@ -506,7 +524,7 @@ export {
   Watcher,
   activeInstance,
   addDecoToClass,
-  classToValue,
+  classToPlain,
   getBind,
   getExposeKey,
   getHandler,
@@ -518,10 +536,11 @@ export {
   getOwnState,
   getProperty,
   getState,
-  getTag2 as getTag,
+  getTag,
   init,
   injectProperty,
   invokeHandler,
+  isAsyncFunc,
   isPhecda,
   plainToClass,
   regisHandler,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phecda-core",
-  "version": "3.0.0-alpha.10",
+  "version": "3.0.0-alpha.11",
   "description": "provide base function and abstract limit to other phecda module ",
   "main": "dist/index.js",
   "module": "dist/index.mjs",