phecda-core 3.0.0-alpha.8 → 3.0.0-beta.13

package/dist/index.mjs

@@ -2,18 +2,19 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/core.ts
+var SHARE_KEY = Symbol("phecda");
+var PHECDA_KEY = Symbol("phecda");
 function isPhecda(module) {
   if (typeof module === "function")
-    return !!module.prototype?._namespace;
+    return !!module.prototype[PHECDA_KEY];
   return false;
 }
 __name(isPhecda, "isPhecda");
-var SHARE_KEY = Symbol("phecda-core");
 function init(proto) {
   if (!proto)
     return;
-  if (!proto.hasOwnProperty("_namespace")) {
-    proto._namespace = {
+  if (!proto.hasOwnProperty(PHECDA_KEY)) {
+    proto[PHECDA_KEY] = {
       __EXPOSE_VAR__: /* @__PURE__ */ new Set(),
       __IGNORE_VAR__: /* @__PURE__ */ new Set(),
       __STATE_VAR__: /* @__PURE__ */ new Set(),
@@ -23,114 +24,115 @@ function init(proto) {
   }
 }
 __name(init, "init");
-function setVar(proto, key) {
+function getPhecdaFromTarget(target) {
+  if (typeof target === "function")
+    return target.prototype;
+  if (target.hasOwnProperty(PHECDA_KEY))
+    return target;
+  return Object.getPrototypeOf(target);
+}
+__name(getPhecdaFromTarget, "getPhecdaFromTarget");
+function setStateVar(proto, key) {
   init(proto);
-  proto._namespace.__STATE_VAR__.add(key);
+  proto[PHECDA_KEY].__STATE_VAR__.add(key);
   setExposeKey(proto, key);
 }
-__name(setVar, "setVar");
+__name(setStateVar, "setStateVar");
 function setExposeKey(proto, key) {
   init(proto);
-  proto._namespace.__EXPOSE_VAR__.add(key);
+  proto[PHECDA_KEY].__EXPOSE_VAR__.add(key);
 }
 __name(setExposeKey, "setExposeKey");
 function setIgnoreKey(proto, key) {
   init(proto);
-  proto._namespace.__IGNORE_VAR__.add(key);
+  proto[PHECDA_KEY].__IGNORE_VAR__.add(key);
 }
 __name(setIgnoreKey, "setIgnoreKey");
-function getOwnModuleState(instance) {
-  instance = Object.getPrototypeOf(instance);
+function setHandler(proto, key, handler) {
+  init(proto);
+  if (!proto[PHECDA_KEY].__STATE_HANDLER__.has(key))
+    proto[PHECDA_KEY].__STATE_HANDLER__.set(key, [
+      handler
+    ]);
+  else
+    proto[PHECDA_KEY].__STATE_HANDLER__.get(key).push(handler);
+}
+__name(setHandler, "setHandler");
+function setState(proto, key, state) {
+  init(proto);
+  const namespace = proto[PHECDA_KEY].__STATE_NAMESPACE__;
+  namespace.set(key, state);
+}
+__name(setState, "setState");
+function getOwnStateVars(target) {
+  const proto = getPhecdaFromTarget(target);
   return [
-    ...instance._namespace.__STATE_VAR__
+    ...proto[PHECDA_KEY].__STATE_VAR__
   ];
 }
-__name(getOwnModuleState, "getOwnModuleState");
-function getModuleState(instance) {
-  let proto = Object.getPrototypeOf(instance);
-  const set = /* @__PURE__ */ new Set();
-  while (proto?._namespace) {
-    proto._namespace.__STATE_VAR__.forEach((item) => set.add(item));
+__name(getOwnStateVars, "getOwnStateVars");
+function getStateVars(target) {
+  let proto = getPhecdaFromTarget(target);
+  const set2 = /* @__PURE__ */ new Set();
+  while (proto?.[PHECDA_KEY]) {
+    proto[PHECDA_KEY].__STATE_VAR__.forEach((item) => set2.add(item));
     proto = Object.getPrototypeOf(proto);
   }
   return [
-    ...set
+    ...set2
   ];
 }
-__name(getModuleState, "getModuleState");
-function getOwnExposeKey(instance) {
-  instance = Object.getPrototypeOf(instance);
+__name(getStateVars, "getStateVars");
+function getOwnExposeKey(target) {
+  const proto = getPhecdaFromTarget(target);
   return [
-    ...instance._namespace.__EXPOSE_VAR__
-  ].filter((item) => !instance._namespace.__IGNORE_VAR__.has(item));
+    ...proto[PHECDA_KEY].__EXPOSE_VAR__
+  ].filter((item) => !proto[PHECDA_KEY].__IGNORE_VAR__.has(item));
 }
 __name(getOwnExposeKey, "getOwnExposeKey");
-function getExposeKey(instance) {
-  let proto = Object.getPrototypeOf(instance);
-  const set = /* @__PURE__ */ new Set();
-  while (proto?._namespace) {
+function getExposeKey(target) {
+  let proto = getPhecdaFromTarget(target);
+  const set2 = /* @__PURE__ */ new Set();
+  while (proto?.[PHECDA_KEY]) {
     [
-      ...proto._namespace.__EXPOSE_VAR__
-    ].forEach((item) => !proto._namespace.__IGNORE_VAR__.has(item) && set.add(item));
+      ...proto[PHECDA_KEY].__EXPOSE_VAR__
+    ].forEach((item) => !proto[PHECDA_KEY].__IGNORE_VAR__.has(item) && set2.add(item));
     proto = Object.getPrototypeOf(proto);
   }
   return [
-    ...set
+    ...set2
   ];
 }
 __name(getExposeKey, "getExposeKey");
-function getOwnIgnoreKey(instance) {
-  if (!instance?._namespace)
-    return [];
+function getOwnIgnoreKey(target) {
+  const proto = getPhecdaFromTarget(target);
   return [
-    ...instance._namespace.__IGNORE_VAR__
+    ...proto[PHECDA_KEY]?.__IGNORE_VAR__
   ];
 }
 __name(getOwnIgnoreKey, "getOwnIgnoreKey");
-function regisHandler(proto, key, handler) {
-  init(proto);
-  if (!proto._namespace.__STATE_HANDLER__.has(key))
-    proto._namespace.__STATE_HANDLER__.set(key, [
-      handler
-    ]);
-  else
-    proto._namespace.__STATE_HANDLER__.get(key).push(handler);
-}
-__name(regisHandler, "regisHandler");
-function getOwnHandler(instance, key) {
-  if (!instance?._namespace)
-    return [];
-  return instance._namespace.__STATE_HANDLER__.get(key) || [];
+function getOwnHandler(target, key) {
+  const proto = getPhecdaFromTarget(target);
+  return proto[PHECDA_KEY]?.__STATE_HANDLER__.get(key) || [];
 }
 __name(getOwnHandler, "getOwnHandler");
-function getHandler(instance, key) {
-  let proto = Object.getPrototypeOf(instance);
-  const set = /* @__PURE__ */ new Set();
-  while (proto?._namespace) {
-    proto._namespace.__STATE_HANDLER__.get(key)?.forEach((item) => set.add(item));
+function getHandler(target, key) {
+  let proto = getPhecdaFromTarget(target);
+  const set2 = /* @__PURE__ */ new Set();
+  while (proto?.[PHECDA_KEY]) {
+    proto[PHECDA_KEY].__STATE_HANDLER__.get(key)?.forEach((item) => set2.add(item));
     proto = Object.getPrototypeOf(proto);
   }
   return [
-    ...set
+    ...set2
   ];
 }
 __name(getHandler, "getHandler");
-function setState(proto, key, state) {
-  init(proto);
-  const namespace = proto._namespace.__STATE_NAMESPACE__;
-  namespace.set(key, state);
-}
-__name(setState, "setState");
-function getOwnState(instance, key) {
-  instance = Object.getPrototypeOf(instance);
-  return instance._namespace.__STATE_NAMESPACE__.get(key) || {};
-}
-__name(getOwnState, "getOwnState");
-function getState(instance, key) {
-  let proto = Object.getPrototypeOf(instance);
+function getState(target, key) {
+  let proto = getPhecdaFromTarget(target);
   let ret = {};
-  while (proto?._namespace) {
-    const state = proto._namespace.__STATE_NAMESPACE__.get(key);
+  while (proto?.[PHECDA_KEY]) {
+    const state = proto[PHECDA_KEY].__STATE_NAMESPACE__.get(key);
     if (state)
       ret = {
         ...state,
@@ -141,42 +143,89 @@ function getState(instance, key) {
   return ret;
 }
 __name(getState, "getState");
-function registerParallel(instance) {
+function getOwnState(target, key) {
+  const proto = getPhecdaFromTarget(target);
+  return proto[PHECDA_KEY].__STATE_NAMESPACE__.get(key) || {};
+}
+__name(getOwnState, "getOwnState");
+function invokeHandler(event, instance) {
   const stateVars = getExposeKey(instance);
   const initHandlers = stateVars.map((item) => {
-    return getHandler(instance, item).filter((h) => h.init).map((h) => h.init(instance));
+    return getHandler(instance, item).filter((h) => !!h[event]).map((h) => h[event](instance));
   }).flat();
   return Promise.all(initHandlers);
 }
-__name(registerParallel, "registerParallel");
-async function registerSerial(instance) {
-  const stateVars = getExposeKey(instance);
-  for (const item of stateVars) {
-    const handlers = getHandler(instance, item);
-    for (const hanlder of handlers)
-      await hanlder.init?.(instance);
-  }
+__name(invokeHandler, "invokeHandler");
+function set(proto, key, value) {
+  init(proto);
+  proto[PHECDA_KEY][`__${key.toUpperCase()}__`] = value;
 }
-__name(registerSerial, "registerSerial");
-function unmountParallel(instance) {
-  const stateVars = getExposeKey(instance);
-  const initHandlers = stateVars.map((item) => {
-    return getHandler(instance, item).filter((h) => h.unmount).map((h) => h.init(instance));
-  }).flat();
-  return Promise.all(initHandlers);
+__name(set, "set");
+function get(proto, key) {
+  return proto[PHECDA_KEY]?.[`__${key.toUpperCase()}__`];
 }
-__name(unmountParallel, "unmountParallel");
+__name(get, "get");
+
+// src/decorators/core.ts
+function Init(proto, key) {
+  setStateVar(proto, key);
+  setHandler(proto, key, {
+    async init(instance) {
+      return instance[key]();
+    }
+  });
+}
+__name(Init, "Init");
+function Unmount(proto, key) {
+  setStateVar(proto, key);
+  setHandler(proto, key, {
+    async unmount(instance) {
+      return instance[key]();
+    }
+  });
+}
+__name(Unmount, "Unmount");
+function Bind(value) {
+  return (proto, k) => {
+    setStateVar(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[PHECDA_KEY].__EXPOSE_VAR__.delete(key);
+  proto[PHECDA_KEY].__IGNORE_VAR__.delete(key);
+  proto[PHECDA_KEY].__STATE_VAR__.delete(key);
+  proto[PHECDA_KEY].__STATE_HANDLER__.delete(key);
+  proto[PHECDA_KEY].__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 getTag(moduleOrInstance) {
   if (typeof moduleOrInstance === "object")
     moduleOrInstance = moduleOrInstance.constructor;
-  return moduleOrInstance.prototype?.__TAG__ || moduleOrInstance.name;
+  return moduleOrInstance.prototype[PHECDA_KEY]?.__TAG__ || moduleOrInstance.name;
 }
 __name(getTag, "getTag");
 function getBind(module) {
   const instance = new module();
-  const keys = getModuleState(instance);
+  const keys = getStateVars(instance);
   const ret = {};
   for (const item of keys) {
     const state = getState(instance, item);
@@ -194,35 +243,88 @@ function plainToClass(module, input) {
   return instance;
 }
 __name(plainToClass, "plainToClass");
-async function transformClass(instance, force = false) {
+function transformInstance(instance, force = false) {
+  const err = [];
+  const keys = getExposeKey(instance);
+  const addError = err.push.bind(err);
+  for (const item of keys) {
+    const handlers = getHandler(instance, item);
+    if (handlers) {
+      for (const handler of handlers) {
+        const pipe = handler.pipe;
+        if (!pipe)
+          continue;
+        pipe(instance, addError);
+        if (err.length && !force)
+          return err;
+      }
+    }
+  }
+  return err;
+}
+__name(transformInstance, "transformInstance");
+async function transformInstanceAsync(instance, force = false) {
   const err = [];
-  const stateVars = getModuleState(instance);
-  for (const item of stateVars) {
+  const keys = getExposeKey(instance);
+  const addError = err.push.bind(err);
+  for (const item of keys) {
     const handlers = getHandler(instance, item);
     if (handlers) {
       for (const handler of handlers) {
         const pipe = handler.pipe;
-        try {
-          await pipe(instance);
-        } catch (e) {
-          err.push(e.message);
-          if (!force)
-            return err;
-        }
+        if (!pipe)
+          continue;
+        await pipe(instance, addError);
+        if (err.length && !force)
+          return err;
       }
     }
   }
   return err;
 }
-__name(transformClass, "transformClass");
-function classToValue(instance) {
+__name(transformInstanceAsync, "transformInstanceAsync");
+function transformProperty(instance, property, force = false) {
+  const err = [];
+  const handlers = getHandler(instance, property);
+  const addError = err.push.bind(err);
+  if (handlers) {
+    for (const handler of handlers) {
+      const pipe = handler.pipe;
+      if (!pipe)
+        continue;
+      pipe(instance, addError);
+      if (err.length && !force)
+        return err;
+    }
+  }
+  return err;
+}
+__name(transformProperty, "transformProperty");
+async function transformPropertyAsync(instance, property, force = false) {
+  const err = [];
+  const handlers = getHandler(instance, property);
+  const addError = err.push.bind(err);
+  if (handlers) {
+    for (const handler of handlers) {
+      const pipe = handler.pipe;
+      if (!pipe)
+        continue;
+      await pipe(instance, addError);
+      if (err.length && !force)
+        return err;
+    }
+  }
+  return err;
+}
+__name(transformPropertyAsync, "transformPropertyAsync");
+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)
@@ -240,8 +342,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) {
@@ -251,92 +353,55 @@ 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]();
-    }
-  });
-}
-__name(Init, "Init");
-function Unmount(proto, key) {
-  setVar(proto, key);
-  regisHandler(proto, key, {
-    async unmount(instance) {
-      return instance[key]();
-    }
-  });
+function isAsyncFunc(fn) {
+  return fn[Symbol.toStringTag] === "AsyncFunction";
 }
-__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");
+function Inject(key) {
+  return DataMap[key];
 }
-__name(Clear, "Clear");
-function Err(cb) {
-  return (proto, key) => {
-    setVar(proto, key);
-    regisHandler(proto, key, {
-      error: cb
-    });
-  };
+__name(Inject, "Inject");
+var activeInstance = {};
+function injectKey(key, value) {
+  activeInstance[key] = value;
+  return activeInstance;
 }
-__name(Err, "Err");
-function Expose(proto, key) {
-  setExposeKey(proto, key);
+__name(injectKey, "injectKey");
+function getKey(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(getKey, "getKey");
+
+// src/decorators/function.ts
+function Isolate(module) {
+  set(module.prototype, "isolate", true);
+  module.prototype[PHECDA_KEY].__ISOLATE__ = true;
 }
-__name(To, "To");
+__name(Isolate, "Isolate");
 function Tag(tag) {
   return (module) => {
-    init(module.prototype);
-    module.prototype.__TAG__ = tag;
+    set(module.prototype, "tag", tag);
   };
 }
 __name(Tag, "Tag");
 function Unique(desc) {
   return (module) => {
-    init(module.prototype);
-    module.prototype.__TAG__ = Symbol(desc || module.name);
+    set(module.prototype, "tag", Symbol(desc || module.name));
   };
 }
 __name(Unique, "Unique");
 function Assign(cb) {
   return (module) => {
     init(module.prototype);
-    setVar(module.prototype, SHARE_KEY);
-    regisHandler(module.prototype, SHARE_KEY, {
+    setStateVar(module.prototype, SHARE_KEY);
+    setHandler(module.prototype, SHARE_KEY, {
       init: async (instance) => {
         const value = await cb(instance);
         if (value && typeof value === "object" && !Array.isArray(value)) {
@@ -350,10 +415,10 @@ function Assign(cb) {
 __name(Assign, "Assign");
 function Global(module) {
   init(module.prototype);
-  setVar(module.prototype, SHARE_KEY);
-  regisHandler(module.prototype, SHARE_KEY, {
+  setStateVar(module.prototype, SHARE_KEY);
+  setHandler(module.prototype, SHARE_KEY, {
     init: async (instance) => {
-      const tag = instance.__TAG__;
+      const tag = instance[PHECDA_KEY].__TAG__;
       if (!tag)
         return;
       if (!globalThis.__PHECDA__)
@@ -363,59 +428,88 @@ 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) => {
-    target.prototype.__ISOLATE__ = true;
+function To(...callbacks) {
+  return (proto, key) => {
+    setStateVar(proto, key);
+    setHandler(proto, key, {
+      async pipe(instance, addError) {
+        for (const cb of callbacks) {
+          try {
+            if (isAsyncFunc(cb))
+              instance[key] = await cb(instance[key], instance, key);
+            else
+              instance[key] = cb(instance[key], instance, key);
+          } catch (e) {
+            addError(e.message);
+          }
+        }
+      }
+    });
   };
 }
-__name(Isolate, "Isolate");
-
-// src/custom/decorator.ts
-var activeInstance = {};
-function injectProperty(key, value) {
-  activeInstance[key] = value;
-  return activeInstance;
+__name(To, "To");
+function Rule(cb, info) {
+  return (proto, key) => {
+    setStateVar(proto, key);
+    setHandler(proto, key, {
+      async pipe(instance, addError) {
+        let ret;
+        if (isAsyncFunc(cb))
+          ret = await cb(instance[key]);
+        else
+          ret = cb(instance[key]);
+        if (!ret) {
+          if (typeof info === "string")
+            addError(info);
+          else
+            addError(info());
+        }
+      }
+    });
+  };
 }
-__name(injectProperty, "injectProperty");
-function getProperty(key) {
-  return activeInstance[key];
+__name(Rule, "Rule");
+function Err(cb, isCatch = false) {
+  return (proto, key) => {
+    setStateVar(proto, key);
+    setHandler(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, instance, key);
+                if (!isCatch)
+                  throw e;
+              }
+            };
+          } else {
+            instance[key] = (...args) => {
+              try {
+                oldFn(...args);
+              } catch (e) {
+                cb(e, instance, key);
+                if (!isCatch)
+                  throw e;
+              }
+            };
+          }
+        }
+      }
+    });
+  };
 }
-__name(getProperty, "getProperty");
+__name(Err, "Err");
 function Watcher(eventName, options) {
   let cb;
   return (proto, key) => {
-    setVar(proto, key);
-    regisHandler(proto, key, {
+    setStateVar(proto, key);
+    setHandler(proto, key, {
       init(instance) {
-        return cb = getProperty("watcher")?.({
+        return cb = getKey("watcher")?.({
           eventName,
           instance,
           key,
@@ -429,10 +523,10 @@ function Watcher(eventName, options) {
   };
 }
 __name(Watcher, "Watcher");
-function Effect(eventName, options) {
+function Effect(cb) {
   return (proto, key) => {
-    setVar(proto, key);
-    regisHandler(proto, key, {
+    setStateVar(proto, key);
+    setHandler(proto, key, {
       init(instance) {
         instance[`$_${key}`] = instance[key];
         Object.defineProperty(instance, key, {
@@ -441,12 +535,7 @@ function Effect(eventName, options) {
           },
           set(v) {
             instance[`$_${key}`] = v;
-            getProperty(`effect-${eventName}`)?.({
-              instance,
-              key,
-              value: v,
-              options
-            });
+            cb(v, instance, key);
             return true;
           }
         });
@@ -455,34 +544,40 @@ function Effect(eventName, options) {
   };
 }
 __name(Effect, "Effect");
-function Storage(storeKey) {
+function Storage({ key: storeKey, toJSON, toString } = {}) {
+  if (!toJSON)
+    toJSON = /* @__PURE__ */ __name((v) => JSON.parse(v), "toJSON");
+  if (!toString)
+    toString = /* @__PURE__ */ __name((v) => JSON.stringify(v), "toString");
   return (proto, key) => {
     let tag;
     if (key) {
       init(proto);
-      tag = storeKey || proto.__TAG__;
-      const uniTag = Symbol(tag);
-      setVar(proto, uniTag);
-      regisHandler(proto, uniTag, {
+      tag = storeKey || `${getTag(proto)}_${key}`;
+      setStateVar(proto, key);
+      setHandler(proto, key, {
         init: (instance) => {
-          return getProperty("storage")?.({
+          return getKey("storage")?.({
             instance,
             key,
-            tag
+            tag,
+            toJSON,
+            toString
           });
         }
       });
     } else {
       init(proto.prototype);
-      tag = storeKey || `${proto.prototype.__TAG__}_${key}`;
-      const uniTag = Symbol(tag);
-      setVar(proto.prototype, uniTag);
-      regisHandler(proto.prototype, uniTag, {
+      tag = storeKey || getTag(proto);
+      setStateVar(proto.prototype, SHARE_KEY);
+      setHandler(proto.prototype, SHARE_KEY, {
         init: (instance) => {
-          return getProperty("storage")?.({
+          return getKey("storage")?.({
             instance,
-            key: "",
-            tag
+            key,
+            tag,
+            toJSON,
+            toString
           });
         }
       });
@@ -504,9 +599,10 @@ export {
   Init,
   Inject,
   Isolate,
-  Nested,
+  PHECDA_KEY,
   Pipeline,
   Provide,
+  Rule,
   SHARE_KEY,
   Storage,
   Tag,
@@ -516,31 +612,35 @@ export {
   Watcher,
   activeInstance,
   addDecoToClass,
-  classToValue,
+  classToPlain,
+  get,
   getBind,
   getExposeKey,
   getHandler,
-  getModuleState,
+  getKey,
   getOwnExposeKey,
   getOwnHandler,
   getOwnIgnoreKey,
-  getOwnModuleState,
   getOwnState,
-  getProperty,
+  getOwnStateVars,
   getState,
+  getStateVars,
   getTag,
   init,
-  injectProperty,
+  injectKey,
+  invokeHandler,
+  isAsyncFunc,
   isPhecda,
   plainToClass,
-  regisHandler,
-  registerParallel,
-  registerSerial,
+  set,
   setExposeKey,
+  setHandler,
   setIgnoreKey,
   setState,
-  setVar,
+  setStateVar,
   snapShot,
-  transformClass,
-  unmountParallel
+  transformInstance,
+  transformInstanceAsync,
+  transformProperty,
+  transformPropertyAsync
 };