phecda-core 3.1.0 → 4.0.0

package/dist/index.js

@@ -3,7 +3,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -17,13 +16,21 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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;
+};
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
   Assign: () => Assign,
   Base: () => Base,
-  Bind: () => Bind,
+  CLEAR_KEY: () => CLEAR_KEY,
   Clear: () => Clear,
   DataMap: () => DataMap,
   Effect: () => Effect,
@@ -32,602 +39,364 @@ __export(src_exports, {
   Expose: () => Expose,
   Global: () => Global,
   If: () => If,
-  Ignore: () => Ignore,
   Init: () => Init,
   Inject: () => Inject,
+  Injectable: () => Injectable,
   Isolate: () => Isolate,
   PHECDA_KEY: () => PHECDA_KEY,
   Pipeline: () => Pipeline,
   Provide: () => Provide,
-  Rule: () => Rule,
   SHARE_KEY: () => SHARE_KEY,
   Storage: () => Storage,
   Tag: () => Tag,
-  To: () => To,
   Unique: () => Unique,
   Unmount: () => Unmount,
   Watcher: () => Watcher,
   activeInstance: () => activeInstance,
   addDecoToClass: () => addDecoToClass,
-  classToPlain: () => classToPlain,
   get: () => get,
-  getBind: () => getBind,
-  getExposeKey: () => getExposeKey,
-  getHandler: () => getHandler,
   getInject: () => getInject,
-  getOwnExposeKey: () => getOwnExposeKey,
-  getOwnHandler: () => getOwnHandler,
-  getOwnIgnoreKey: () => getOwnIgnoreKey,
-  getOwnState: () => getOwnState,
-  getOwnStateKey: () => getOwnStateKey,
+  getMergedMeta: () => getMergedMeta,
+  getMeta: () => getMeta,
+  getMetaKey: () => getMetaKey,
+  getMetaParams: () => getMetaParams,
+  getOwnMeta: () => getOwnMeta,
+  getOwnMetaKey: () => getOwnMetaKey,
+  getOwnMetaParams: () => getOwnMetaParams,
   getPhecdaFromTarget: () => getPhecdaFromTarget,
-  getShareState: () => getShareState,
-  getState: () => getState,
-  getStateKey: () => getStateKey,
   getTag: () => getTag,
   init: () => init,
-  invokeHandler: () => invokeHandler,
+  invoke: () => invoke,
+  invokeInit: () => invokeInit,
+  invokeUnmount: () => invokeUnmount,
   isAsyncFunc: () => isAsyncFunc,
   isPhecda: () => isPhecda,
-  plainToClass: () => plainToClass,
   set: () => set,
-  setExposeKey: () => setExposeKey,
-  setHandler: () => setHandler,
-  setIgnoreKey: () => setIgnoreKey,
   setInject: () => setInject,
-  setPropertyState: () => setPropertyState,
-  setState: () => setState,
-  setStateKey: () => setStateKey,
-  snapShot: () => snapShot,
-  transformInstance: () => transformInstance,
-  transformInstanceAsync: () => transformInstanceAsync,
-  transformProperty: () => transformProperty,
-  transformPropertyAsync: () => transformPropertyAsync
+  setMeta: () => setMeta
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/core.ts
-var SHARE_KEY = Symbol("phecda");
+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] = {
       /**
-       * 暴露的变量，
-       * 只要属性上存在至少一个装饰器，该属性就会被捕捉到
-      */
-      __EXPOSE_KEY: /* @__PURE__ */ new Set(),
-      /**
-       * @Ignore 绑定的属性，
-       * 某属性即使被捕捉，可被强行忽略，优先级最高
-      */
-      __IGNORE_KEY: /* @__PURE__ */ new Set(),
-      /**
-       * @Clear 绑定的属性，
-       * 消除父类在该key上的state/handler, 但export key 和 state
-      */
-      __CLEAR_KEY: /* @__PURE__ */ new Set(),
-      /**
-       * 存在状态的变量
-       * @deprecated
-      */
-      __STATE_KEY: /* @__PURE__ */ new Set(),
-      /**
-       * 状态变量的处理器
-      */
-      __STATE_HANDLER__: /* @__PURE__ */ new Map(),
-      /**
-       * 状态变量的共有状态
-      */
-      __STATE_NAMESPACE__: /* @__PURE__ */ new Map()
+         * 元数据
+        */
+      __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 setStateKey(proto, key) {
-  if (!key) {
-    key = SHARE_KEY;
-    proto = proto.prototype;
-  }
-  init(proto);
-  proto[PHECDA_KEY].__STATE_KEY.add(key);
-  setExposeKey(proto, key);
-}
-__name(setStateKey, "setStateKey");
-function setExposeKey(proto, key) {
-  if (!key) {
-    key = SHARE_KEY;
-    proto = proto.prototype;
-  }
-  init(proto);
-  proto[PHECDA_KEY].__EXPOSE_KEY.add(key);
-}
-__name(setExposeKey, "setExposeKey");
-function setIgnoreKey(proto, key) {
-  if (!key) {
-    key = SHARE_KEY;
+function setMeta(proto, property, index, meta) {
+  if (!property) {
+    property = SHARE_KEY;
     proto = proto.prototype;
   }
   init(proto);
-  proto[PHECDA_KEY].__IGNORE_KEY.add(key);
-}
-__name(setIgnoreKey, "setIgnoreKey");
-function setHandler(proto, key, handler) {
-  if (!key) {
-    key = SHARE_KEY;
-    proto = proto.prototype;
-  }
-  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) {
-  if (!key) {
-    key = SHARE_KEY;
-    proto = proto.prototype;
-  }
-  init(proto);
-  const namespace = proto[PHECDA_KEY].__STATE_NAMESPACE__;
-  namespace.set(key, state);
-}
-__name(setState, "setState");
-function getOwnStateKey(target) {
-  const proto = getPhecdaFromTarget(target);
-  return [
-    ...proto[PHECDA_KEY].__STATE_KEY
-  ];
-}
-__name(getOwnStateKey, "getOwnStateKey");
-function getStateKey(target) {
-  let proto = getPhecdaFromTarget(target);
-  const set2 = /* @__PURE__ */ new Set();
-  while (proto?.[PHECDA_KEY]) {
-    if (proto.hasOwnProperty(PHECDA_KEY)) proto[PHECDA_KEY].__STATE_KEY.forEach((item) => set2.add(item));
-    proto = Object.getPrototypeOf(proto);
+  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, []);
+    const paramsMeta = oldMeta.params.get(index);
+    paramsMeta.push(meta);
+  } else {
+    oldMeta.data.push(meta);
   }
-  return [
-    ...set2
-  ];
+  proto[PHECDA_KEY].__META__.set(property, oldMeta);
 }
-__name(getStateKey, "getStateKey");
-function getOwnExposeKey(target) {
+function getOwnMetaKey(target) {
   const proto = getPhecdaFromTarget(target);
-  return [
-    ...proto[PHECDA_KEY].__EXPOSE_KEY
-  ].filter((item) => !proto[PHECDA_KEY].__IGNORE_KEY.has(item));
+  return [...proto[PHECDA_KEY].__META__.keys()];
 }
-__name(getOwnExposeKey, "getOwnExposeKey");
-function getExposeKey(target) {
+function getMetaKey(target) {
   let proto = getPhecdaFromTarget(target);
   const set2 = /* @__PURE__ */ new Set();
-  const origin = proto;
   while (proto?.[PHECDA_KEY]) {
-    if (proto.hasOwnProperty(PHECDA_KEY)) [
-      ...proto[PHECDA_KEY].__EXPOSE_KEY
-    ].forEach((item) => !origin[PHECDA_KEY].__IGNORE_KEY.has(item) && set2.add(item));
+    if (proto.hasOwnProperty(PHECDA_KEY)) {
+      for (const property of proto[PHECDA_KEY].__META__.keys())
+        set2.add(property);
+    }
     proto = Object.getPrototypeOf(proto);
   }
-  return [
-    ...set2
-  ];
-}
-__name(getExposeKey, "getExposeKey");
-function getOwnIgnoreKey(target) {
-  const proto = getPhecdaFromTarget(target);
-  return [
-    ...proto[PHECDA_KEY]?.__IGNORE_KEY
-  ];
+  return [...set2];
 }
-__name(getOwnIgnoreKey, "getOwnIgnoreKey");
-function getOwnHandler(target, key) {
+function getOwnMetaParams(target, key = SHARE_KEY) {
   const proto = getPhecdaFromTarget(target);
-  return proto[PHECDA_KEY]?.__STATE_HANDLER__.get(key) || [];
+  const { params } = proto[PHECDA_KEY].__META__.get(key);
+  return [...params.keys()];
 }
-__name(getOwnHandler, "getOwnHandler");
-function getHandler(target, key) {
+function getMetaParams(target, key = SHARE_KEY) {
   let proto = getPhecdaFromTarget(target);
   const set2 = /* @__PURE__ */ new Set();
   while (proto?.[PHECDA_KEY]) {
     if (proto.hasOwnProperty(PHECDA_KEY)) {
-      proto[PHECDA_KEY].__STATE_HANDLER__.get(key)?.forEach((item) => set2.add(item));
-      if (proto[PHECDA_KEY].__CLEAR_KEY.has(key)) break;
+      const meta = proto[PHECDA_KEY].__META__.get(key);
+      if (meta) {
+        for (const index of meta.params.keys())
+          set2.add(index);
+      }
     }
     proto = Object.getPrototypeOf(proto);
   }
-  return [
-    ...set2
-  ];
+  return [...set2].sort((a, b) => a - b);
 }
-__name(getHandler, "getHandler");
-function getState(target, key = SHARE_KEY) {
+function getMeta(target, property = SHARE_KEY, index) {
   let proto = getPhecdaFromTarget(target);
-  let ret = {};
+  const ret = [];
   while (proto?.[PHECDA_KEY]) {
     if (proto.hasOwnProperty(PHECDA_KEY)) {
-      const state = proto[PHECDA_KEY].__STATE_NAMESPACE__.get(key);
-      if (state) ret = {
-        ...state,
-        ...ret
-      };
-      if (proto[PHECDA_KEY].__CLEAR_KEY.has(key)) break;
+      const meta = proto[PHECDA_KEY].__META__.get(property);
+      if (meta) {
+        if (typeof index === "number") {
+          const paramMeta = meta.params.get(index);
+          if (paramMeta) {
+            const index2 = paramMeta.findIndex((item) => item[CLEAR_KEY]);
+            ret.unshift(...paramMeta.slice(index2 + 1));
+            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;
+        }
+      }
     }
     proto = Object.getPrototypeOf(proto);
   }
   return ret;
 }
-__name(getState, "getState");
-function getOwnState(target, key = SHARE_KEY) {
+function getOwnMeta(target, property = SHARE_KEY, index) {
   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(module2, item).filter((h) => !!h[event]).map((h) => h[event](module2));
-  }).flat();
-  return module2.__PROMISE_SYMBOL__ = Promise.all(initHandlers);
-}
-__name(invokeHandler, "invokeHandler");
-function set(proto, key, value) {
+  const meta = proto[PHECDA_KEY].__META__.get(property);
+  return typeof index === "number" ? meta.params.get(index) : meta.data;
+}
+function set(proto, property, value) {
   init(proto);
-  proto[`__${key.toUpperCase()}__`] = value;
+  proto[`__${property.toUpperCase()}__`] = value;
 }
-__name(set, "set");
-function get(proto, key) {
-  return proto[`__${key.toUpperCase()}__`];
+function get(proto, property) {
+  return proto[`__${property.toUpperCase()}__`];
 }
-__name(get, "get");
 
 // src/decorators/core.ts
-function Init(proto, key) {
-  setStateKey(proto, key);
-  setHandler(proto, key, {
+function Init(proto, property) {
+  setMeta(proto, property, void 0, {
     async init(instance) {
-      return instance[key]();
+      return instance[property]();
     }
   });
 }
-__name(Init, "Init");
-function Unmount(proto, key) {
-  setStateKey(proto, key);
-  setHandler(proto, key, {
+function Unmount(proto, property) {
+  setMeta(proto, property, void 0, {
     async unmount(instance) {
-      return instance[key]();
+      return instance[property]();
     }
   });
 }
-__name(Unmount, "Unmount");
-function Bind(value) {
-  return (proto, k) => {
-    setStateKey(proto, k);
-    setState(proto, k, {
-      value
-    });
-  };
-}
-__name(Bind, "Bind");
-function Ignore(proto, key) {
-  if (!key) {
-    proto = proto.prototype;
-    key = SHARE_KEY;
-  }
-  setIgnoreKey(proto, key);
-}
-__name(Ignore, "Ignore");
-function Clear(proto, key) {
-  if (!key) {
-    proto = proto.prototype;
-    key = SHARE_KEY;
-  }
-  init(proto);
-  proto[PHECDA_KEY].__CLEAR_KEY.add(key);
+function Expose(proto, property, index) {
+  setMeta(proto, property, index, {});
 }
-__name(Clear, "Clear");
-function Expose(proto, key) {
-  setExposeKey(proto, key);
-}
-__name(Expose, "Expose");
 function Empty(model) {
   init(model.prototype);
 }
-__name(Empty, "Empty");
+function Clear(proto, property, index) {
+  setMeta(proto, property, index, {
+    [CLEAR_KEY]: true
+  });
+}
+function Injectable() {
+  return (target) => Empty(target);
+}
 
 // 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 getBind(model) {
-  const instance = new model();
-  const keys = getStateKey(instance);
-  const ret = {};
-  for (const item of keys) {
-    const state = getState(instance, item);
-    if (state.value) ret[item] = state.value;
-  }
-  return ret;
-}
-__name(getBind, "getBind");
-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");
-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 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(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 JSON.parse(JSON.stringify(data));
-}
-__name(classToPlain, "classToPlain");
-function snapShot(data) {
-  const snap = {};
-  for (const i in data) snap[i] = data[i];
-  return {
-    data,
-    clear() {
-      for (const i in snap) delete data[i];
-    },
-    apply() {
-      for (const i in snap) data[i] = snap[i];
-    }
-  };
-}
-__name(snapShot, "snapShot");
 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 setPropertyState(target, k, setter) {
-  setStateKey(target, k);
-  const state = getOwnState(target, k) || {};
-  setter(state);
-  setState(target, k, state);
+function invoke(instance, key, ...params) {
+  const metaKeys = getMetaKey(instance);
+  return Promise.allSettled(metaKeys.map((k) => {
+    return getMeta(instance, k);
+  }).flat().filter((item) => typeof item[key] === "function").map((item) => item[key](instance, ...params)));
+}
+function invokeInit(instance) {
+  return instance.__PROMISE_SYMBOL__ = invoke(instance, "init");
+}
+function invokeUnmount(instance) {
+  return instance.__PROMISE_SYMBOL__ = invoke(instance, "unmount");
+}
+function If(value, ...decorators) {
+  if (value) {
+    return (...args) => {
+      decorators.forEach((d) => d(...args));
+    };
+  }
+  return () => {
+  };
 }
-__name(setPropertyState, "setPropertyState");
-function getShareState(target, getter) {
-  const state = getOwnState(target, SHARE_KEY) || {};
-  return getter(state);
+function getMergedMeta(target, property, index, merger = defaultMerger) {
+  const meta = getMeta(target, property, index);
+  return meta.reduce((p, c) => {
+    return merger(p, c);
+  }, {});
+}
+function defaultMerger(prev, cur) {
+  const newMeta = {};
+  for (const key in prev) {
+    if (key === CLEAR_KEY)
+      continue;
+    newMeta[key] = prev[key];
+  }
+  for (const key in cur) {
+    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]);
+        cur[key].forEach((item) => {
+          set2.delete(item);
+          set2.add(item);
+        });
+        newMeta[key] = [...set2];
+      } else if (typeof newMeta[key] === "object" && typeof cur[key] === "object") {
+        newMeta[key] = defaultMerger(newMeta[key], cur[key]);
+      } else {
+        newMeta[key] = cur[key];
+      }
+    } else {
+      newMeta[key] = cur[key];
+    }
+  }
+  return newMeta;
 }
-__name(getShareState, "getShareState");
 
 // 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) => {
-    setStateKey(model);
-    setHandler(model, void 0, {
-      init: /* @__PURE__ */ __name(async (instance) => {
+    setMeta(model, void 0, void 0, {
+      init: 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) {
-  setStateKey(model);
-  setHandler(model, void 0, {
-    init: /* @__PURE__ */ __name(async (instance) => {
+  setMeta(model, void 0, void 0, {
+    init: 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 To(...callbacks) {
-  return (proto, key) => {
-    setStateKey(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(To, "To");
-function Rule(cb, info) {
-  return (proto, key) => {
-    setStateKey(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(Rule, "Rule");
 function Err(cb, isCatch = false) {
-  return (proto, key) => {
-    setStateKey(proto, key);
-    setHandler(proto, key, {
-      init: /* @__PURE__ */ __name((instance) => {
-        if (typeof instance[key] === "function") {
-          const oldFn = instance[key].bind(instance);
+  return (proto, property) => {
+    setMeta(proto, property, void 0, {
+      init: (instance) => {
+        if (typeof instance[property] === "function") {
+          const oldFn = instance[property].bind(instance);
           if (isAsyncFunc(oldFn)) {
-            instance[key] = async (...args) => {
+            instance[property] = async (...args) => {
               try {
                 await oldFn(...args);
               } catch (e) {
-                cb(e, instance, key);
-                if (!isCatch) throw e;
+                cb(e, instance, property);
+                if (!isCatch)
+                  throw e;
               }
             };
           } else {
-            instance[key] = (...args) => {
+            instance[property] = (...args) => {
               try {
                 oldFn(...args);
               } catch (e) {
-                cb(e, instance, key);
-                if (!isCatch) throw e;
+                cb(e, instance, property);
+                if (!isCatch)
+                  throw e;
               }
             };
           }
         }
-      }, "init")
+      }
     });
   };
 }
-__name(Err, "Err");
 function Watcher(eventName, options) {
   let cb;
-  return (proto, key) => {
-    setStateKey(proto, key);
-    setHandler(proto, key, {
+  return (proto, property) => {
+    setMeta(proto, property, void 0, {
       init(instance) {
-        return cb = getInject("watcher")?.({
-          eventName,
-          instance,
-          key,
-          options
-        });
+        return cb = getInject("watcher")?.({ eventName, instance, property, options });
       },
       unmount() {
         return cb?.();
@@ -635,20 +404,18 @@ function Watcher(eventName, options) {
     });
   };
 }
-__name(Watcher, "Watcher");
 function Effect(cb) {
-  return (proto, key) => {
-    setStateKey(proto, key);
-    setHandler(proto, key, {
+  return (proto, property) => {
+    setMeta(proto, property, void 0, {
       init(instance) {
-        instance[`$_${key}`] = instance[key];
-        Object.defineProperty(instance, key, {
+        instance[`$_${property}`] = instance[property];
+        Object.defineProperty(instance, property, {
           get() {
-            return instance[`$_${key}`];
+            return instance[`$_${property}`];
           },
           set(v) {
-            instance[`$_${key}`] = v;
-            cb(v, instance, key);
+            instance[`$_${property}`] = v;
+            cb(v, instance, property);
             return true;
           }
         });
@@ -656,58 +423,26 @@ function Effect(cb) {
     });
   };
 }
-__name(Effect, "Effect");
-function Storage({ key: storeKey, json, stringify } = {}) {
-  if (!json) json = /* @__PURE__ */ __name((v) => JSON.parse(v), "json");
-  if (!stringify) stringify = /* @__PURE__ */ __name((v) => JSON.stringify(v), "stringify");
-  return (proto, key) => {
-    const tag = storeKey || getTag(proto);
+function Storage({ key, json, stringify } = {}) {
+  if (!json)
+    json = (v) => JSON.parse(v);
+  if (!stringify)
+    stringify = (v) => JSON.stringify(v);
+  return (proto, property) => {
+    const tag = key || getTag(proto);
     init(proto);
-    setStateKey(proto, key);
-    setHandler(proto, key, {
-      init: /* @__PURE__ */ __name((instance) => {
-        return getInject("storage")?.({
-          instance,
-          key,
-          tag,
-          toJSON: json,
-          toString: stringify
-        });
-      }, "init")
+    setMeta(proto, property, void 0, {
+      init: (instance) => {
+        return getInject("storage")?.({ instance, property, tag, toJSON: json, toString: stringify });
+      }
     });
   };
 }
-__name(Storage, "Storage");
-function If(value, ...decorators) {
-  if (value) {
-    return (...args) => {
-      decorators.forEach((d) => d(...args));
-    };
-  }
-  return () => {
-  };
-}
-__name(If, "If");
 
 // 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);
@@ -728,21 +463,22 @@ 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()));
   }
 };
-_ts_decorate([
-  Unmount,
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", []),
-  _ts_metadata("design:returntype", void 0)
-], Base.prototype, "_unmount", null);
+__decorateClass([
+  Unmount
+], Base.prototype, "_unmount", 1);
+Base = __decorateClass([
+  Empty
+], Base);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Assign,
   Base,
-  Bind,
+  CLEAR_KEY,
   Clear,
   DataMap,
   Effect,
@@ -751,55 +487,39 @@ _ts_decorate([
   Expose,
   Global,
   If,
-  Ignore,
   Init,
   Inject,
+  Injectable,
   Isolate,
   PHECDA_KEY,
   Pipeline,
   Provide,
-  Rule,
   SHARE_KEY,
   Storage,
   Tag,
-  To,
   Unique,
   Unmount,
   Watcher,
   activeInstance,
   addDecoToClass,
-  classToPlain,
   get,
-  getBind,
-  getExposeKey,
-  getHandler,
   getInject,
-  getOwnExposeKey,
-  getOwnHandler,
-  getOwnIgnoreKey,
-  getOwnState,
-  getOwnStateKey,
+  getMergedMeta,
+  getMeta,
+  getMetaKey,
+  getMetaParams,
+  getOwnMeta,
+  getOwnMetaKey,
+  getOwnMetaParams,
   getPhecdaFromTarget,
-  getShareState,
-  getState,
-  getStateKey,
   getTag,
   init,
-  invokeHandler,
+  invoke,
+  invokeInit,
+  invokeUnmount,
   isAsyncFunc,
   isPhecda,
-  plainToClass,
   set,
-  setExposeKey,
-  setHandler,
-  setIgnoreKey,
   setInject,
-  setPropertyState,
-  setState,
-  setStateKey,
-  snapShot,
-  transformInstance,
-  transformInstanceAsync,
-  transformProperty,
-  transformPropertyAsync
+  setMeta
 });