phecda-core 3.0.0-alpha.9 → 3.0.0-beta.14

package/dist/index.js

@@ -34,9 +34,10 @@ __export(src_exports, {
   Init: () => Init,
   Inject: () => Inject,
   Isolate: () => Isolate,
-  Nested: () => Nested,
+  PHECDA_KEY: () => PHECDA_KEY,
   Pipeline: () => Pipeline,
   Provide: () => Provide,
+  Rule: () => Rule,
   SHARE_KEY: () => SHARE_KEY,
   Storage: () => Storage,
   Tag: () => Tag,
@@ -46,47 +47,54 @@ __export(src_exports, {
   Watcher: () => Watcher,
   activeInstance: () => activeInstance,
   addDecoToClass: () => addDecoToClass,
-  classToValue: () => classToValue,
+  classToPlain: () => classToPlain,
+  get: () => get,
   getBind: () => getBind,
   getExposeKey: () => getExposeKey,
   getHandler: () => getHandler,
-  getModuleState: () => getModuleState,
+  getKey: () => getKey,
   getOwnExposeKey: () => getOwnExposeKey,
   getOwnHandler: () => getOwnHandler,
   getOwnIgnoreKey: () => getOwnIgnoreKey,
-  getOwnModuleState: () => getOwnModuleState,
   getOwnState: () => getOwnState,
-  getProperty: () => getProperty,
+  getOwnStateVars: () => getOwnStateVars,
   getState: () => getState,
+  getStateVars: () => getStateVars,
   getTag: () => getTag,
   init: () => init,
-  injectProperty: () => injectProperty,
+  injectKey: () => injectKey,
   invokeHandler: () => invokeHandler,
+  isAsyncFunc: () => isAsyncFunc,
   isPhecda: () => isPhecda,
   plainToClass: () => plainToClass,
-  regisHandler: () => regisHandler,
+  set: () => set,
   setExposeKey: () => setExposeKey,
+  setHandler: () => setHandler,
   setIgnoreKey: () => setIgnoreKey,
   setState: () => setState,
-  setVar: () => setVar,
+  setStateVar: () => setStateVar,
   snapShot: () => snapShot,
-  transformClass: () => transformClass
+  transformInstance: () => transformInstance,
+  transformInstanceAsync: () => transformInstanceAsync,
+  transformProperty: () => transformProperty,
+  transformPropertyAsync: () => transformPropertyAsync
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/core.ts
-function isPhecda(module2) {
-  if (typeof module2 === "function")
-    return !!module2.prototype?._namespace;
+var SHARE_KEY = Symbol("phecda");
+var PHECDA_KEY = Symbol("phecda");
+function isPhecda(model) {
+  if (typeof model === "function")
+    return !!model.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(),
@@ -96,114 +104,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,
@@ -214,25 +223,89 @@ function getState(instance, key) {
   return ret;
 }
 __name(getState, "getState");
-function invokeHandler(event, instance) {
-  const stateVars = getExposeKey(instance);
+function getOwnState(target, key) {
+  const proto = getPhecdaFromTarget(target);
+  return proto[PHECDA_KEY].__STATE_NAMESPACE__.get(key) || {};
+}
+__name(getOwnState, "getOwnState");
+function invokeHandler(event, module2) {
+  const stateVars = getExposeKey(module2);
   const initHandlers = stateVars.map((item) => {
-    return getHandler(instance, item).filter((h) => h[event]).map((h) => h[event](instance));
+    return getHandler(module2, item).filter((h) => !!h[event]).map((h) => h[event](module2));
   }).flat();
   return Promise.all(initHandlers);
 }
 __name(invokeHandler, "invokeHandler");
+function set(proto, key, value) {
+  init(proto);
+  proto[PHECDA_KEY][`__${key.toUpperCase()}__`] = value;
+}
+__name(set, "set");
+function get(proto, key) {
+  return proto[PHECDA_KEY]?.[`__${key.toUpperCase()}__`];
+}
+__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(model) {
+  init(model.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(module2) {
-  const instance = new module2();
-  const keys = getModuleState(instance);
+function getBind(model) {
+  const instance = new model();
+  const keys = getStateVars(instance);
   const ret = {};
   for (const item of keys) {
     const state = getState(instance, item);
@@ -242,43 +315,96 @@ function getBind(module2) {
   return ret;
 }
 __name(getBind, "getBind");
-function plainToClass(module2, input) {
-  const instance = new module2();
+function plainToClass(model, input) {
+  const instance = new model();
   const keys = getExposeKey(instance);
   for (const item of keys)
     instance[item] = input[item];
   return instance;
 }
 __name(plainToClass, "plainToClass");
-async function transformClass(instance, force = false) {
+function transformInstance(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;
+        pipe(instance, addError);
+        if (err.length && !force)
+          return err;
+      }
+    }
+  }
+  return err;
+}
+__name(transformInstance, "transformInstance");
+async function transformInstanceAsync(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;
+        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)
@@ -296,8 +422,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,92 +433,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(model) {
+  set(model.prototype, "isolate", true);
+  model.prototype[PHECDA_KEY].__ISOLATE__ = true;
 }
-__name(To, "To");
+__name(Isolate, "Isolate");
 function Tag(tag) {
-  return (module2) => {
-    init(module2.prototype);
-    module2.prototype.__TAG__ = tag;
+  return (model) => {
+    set(model.prototype, "tag", tag);
   };
 }
 __name(Tag, "Tag");
 function Unique(desc) {
-  return (module2) => {
-    init(module2.prototype);
-    module2.prototype.__TAG__ = Symbol(desc || module2.name);
+  return (model) => {
+    set(model.prototype, "tag", Symbol(desc || model.name));
   };
 }
 __name(Unique, "Unique");
 function Assign(cb) {
-  return (module2) => {
-    init(module2.prototype);
-    setVar(module2.prototype, SHARE_KEY);
-    regisHandler(module2.prototype, SHARE_KEY, {
+  return (model) => {
+    init(model.prototype);
+    setStateVar(model.prototype, SHARE_KEY);
+    setHandler(model.prototype, SHARE_KEY, {
       init: async (instance) => {
         const value = await cb(instance);
         if (value && typeof value === "object" && !Array.isArray(value)) {
@@ -404,12 +493,12 @@ function Assign(cb) {
   };
 }
 __name(Assign, "Assign");
-function Global(module2) {
-  init(module2.prototype);
-  setVar(module2.prototype, SHARE_KEY);
-  regisHandler(module2.prototype, SHARE_KEY, {
+function Global(model) {
+  init(model.prototype);
+  setStateVar(model.prototype, SHARE_KEY);
+  setHandler(model.prototype, SHARE_KEY, {
     init: async (instance) => {
-      const tag = instance.__TAG__;
+      const tag = instance[PHECDA_KEY].__TAG__;
       if (!tag)
         return;
       if (!globalThis.__PHECDA__)
@@ -419,59 +508,88 @@ 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) => {
-    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,
@@ -485,10 +603,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, {
@@ -497,12 +615,7 @@ function Effect(eventName, options) {
           },
           set(v) {
             instance[`$_${key}`] = v;
-            getProperty(`effect-${eventName}`)?.({
-              instance,
-              key,
-              value: v,
-              options
-            });
+            cb(v, instance, key);
             return true;
           }
         });
@@ -511,34 +624,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
           });
         }
       });
@@ -561,9 +680,10 @@ __name(Storage, "Storage");
   Init,
   Inject,
   Isolate,
-  Nested,
+  PHECDA_KEY,
   Pipeline,
   Provide,
+  Rule,
   SHARE_KEY,
   Storage,
   Tag,
@@ -573,29 +693,35 @@ __name(Storage, "Storage");
   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,
+  set,
   setExposeKey,
+  setHandler,
   setIgnoreKey,
   setState,
-  setVar,
+  setStateVar,
   snapShot,
-  transformClass
+  transformInstance,
+  transformInstanceAsync,
+  transformProperty,
+  transformPropertyAsync
 });