phecda-core 3.1.1 → 4.0.1

package/dist/index.js

@@ -30,7 +30,7 @@ var src_exports = {};
 __export(src_exports, {
   Assign: () => Assign,
   Base: () => Base,
-  Bind: () => Bind,
+  CLEAR_KEY: () => CLEAR_KEY,
   Clear: () => Clear,
   DataMap: () => DataMap,
   Effect: () => Effect,
@@ -39,7 +39,6 @@ __export(src_exports, {
   Expose: () => Expose,
   Global: () => Global,
   If: () => If,
-  Ignore: () => Ignore,
   Init: () => Init,
   Inject: () => Inject,
   Injectable: () => Injectable,
@@ -47,55 +46,41 @@ __export(src_exports, {
   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,
+  wait: () => wait
 });
 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")
@@ -108,33 +93,9 @@ function init(proto) {
   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()
     };
   }
 }
@@ -145,183 +106,127 @@ function getPhecdaFromTarget(target) {
     return target;
   return Object.getPrototypeOf(target);
 }
-function setStateKey(proto, key) {
-  if (!key) {
-    key = SHARE_KEY;
-    proto = proto.prototype;
-  }
-  init(proto);
-  proto[PHECDA_KEY].__STATE_KEY.add(key);
-  setExposeKey(proto, key);
-}
-function setExposeKey(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].__EXPOSE_KEY.add(key);
-}
-function setIgnoreKey(proto, key) {
-  if (!key) {
-    key = SHARE_KEY;
-    proto = proto.prototype;
-  }
-  init(proto);
-  proto[PHECDA_KEY].__IGNORE_KEY.add(key);
-}
-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);
-}
-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);
-}
-function getOwnStateKey(target) {
-  const proto = getPhecdaFromTarget(target);
-  return [...proto[PHECDA_KEY].__STATE_KEY];
-}
-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);
 }
-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()];
 }
-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];
 }
-function getOwnIgnoreKey(target) {
-  const proto = getPhecdaFromTarget(target);
-  return [...proto[PHECDA_KEY]?.__IGNORE_KEY];
-}
-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()];
 }
-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);
 }
-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;
 }
-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) || {};
-}
-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);
+  const meta = proto[PHECDA_KEY].__META__.get(property);
+  return typeof index === "number" ? meta.params.get(index) : meta.data;
 }
-function set(proto, key, value) {
+function set(proto, property, value) {
   init(proto);
-  proto[`__${key.toUpperCase()}__`] = value;
+  proto[`__${property.toUpperCase()}__`] = value;
 }
-function get(proto, key) {
-  return proto[`__${key.toUpperCase()}__`];
+function get(proto, property) {
+  return proto[`__${property.toUpperCase()}__`];
 }
 
 // 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]();
     }
   });
 }
-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]();
     }
   });
 }
-function Bind(value) {
-  return (proto, k) => {
-    setStateKey(proto, k);
-    setState(proto, k, {
-      value
-    });
-  };
-}
-function Ignore(proto, key) {
-  if (!key) {
-    proto = proto.prototype;
-    key = SHARE_KEY;
-  }
-  ;
-  setIgnoreKey(proto, key);
-}
-function Clear(proto, key) {
-  if (!key) {
-    proto = proto.prototype;
-    key = SHARE_KEY;
-  }
-  ;
-  init(proto);
-  proto[PHECDA_KEY].__CLEAR_KEY.add(key);
-}
-function Expose(proto, key) {
-  setExposeKey(proto, key);
+function Expose(proto, property, index) {
+  setMeta(proto, property, index, {});
 }
 function Empty(model) {
   init(model.prototype);
 }
+function Clear(proto, property, index) {
+  setMeta(proto, property, index, {
+    [CLEAR_KEY]: true
+  });
+}
 function Injectable() {
   return (target) => Empty(target);
 }
@@ -332,117 +237,6 @@ function getTag(moduleOrInstance) {
     moduleOrInstance = moduleOrInstance.constructor;
   return get(moduleOrInstance.prototype, "tag") || moduleOrInstance.name;
 }
-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;
-}
-function plainToClass(model, input) {
-  const instance = new model();
-  const keys = getExposeKey(instance);
-  for (const item of keys)
-    instance[item] = input[item];
-  return instance;
-}
-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;
-}
-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;
-}
-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;
-}
-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;
-}
-function classToPlain(instance) {
-  const data = {};
-  const exposeVars = getExposeKey(instance);
-  for (const item of exposeVars)
-    data[item] = instance[item];
-  return JSON.parse(JSON.stringify(data));
-}
-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];
-    }
-  };
-}
 function addDecoToClass(c, key, handler) {
   handler(key ? c.prototype : c, key);
 }
@@ -455,15 +249,64 @@ function Pipeline(...decos) {
 function isAsyncFunc(fn) {
   return fn[Symbol.toStringTag] === "AsyncFunction";
 }
-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 () => {
+  };
+}
+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;
 }
-function getShareState(target, getter) {
-  const state = getOwnState(target, SHARE_KEY) || {};
-  return getter(state);
+function wait(...instances) {
+  return Promise.all(instances.map((i) => i.__PROMISE_SYMBOL__));
 }
 
 // src/di.ts
@@ -499,8 +342,7 @@ function Unique(desc) {
 }
 function Assign(cb) {
   return (model) => {
-    setStateKey(model);
-    setHandler(model, void 0, {
+    setMeta(model, void 0, void 0, {
       init: async (instance) => {
         const value = await cb(instance);
         if (value && typeof value === "object" && !Array.isArray(value)) {
@@ -512,8 +354,7 @@ function Assign(cb) {
   };
 }
 function Global(model) {
-  setStateKey(model);
-  setHandler(model, void 0, {
+  setMeta(model, void 0, void 0, {
     init: async (instance) => {
       const tag = getTag(instance);
       if (!globalThis.__PHECDA__)
@@ -522,68 +363,28 @@ function Global(model) {
     }
   });
 }
-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);
-          }
-        }
-      }
-    });
-  };
-}
-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());
-        }
-      }
-    });
-  };
-}
 function Err(cb, isCatch = false) {
-  return (proto, key) => {
-    setStateKey(proto, key);
-    setHandler(proto, key, {
+  return (proto, property) => {
+    setMeta(proto, property, void 0, {
       init: (instance) => {
-        if (typeof instance[key] === "function") {
-          const oldFn = instance[key].bind(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);
+                cb(e, instance, property);
                 if (!isCatch)
                   throw e;
               }
             };
           } else {
-            instance[key] = (...args) => {
+            instance[property] = (...args) => {
               try {
                 oldFn(...args);
               } catch (e) {
-                cb(e, instance, key);
+                cb(e, instance, property);
                 if (!isCatch)
                   throw e;
               }
@@ -596,11 +397,10 @@ function Err(cb, isCatch = false) {
 }
 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?.();
@@ -609,18 +409,17 @@ function Watcher(eventName, options) {
   };
 }
 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;
           }
         });
@@ -628,31 +427,21 @@ function Effect(cb) {
     });
   };
 }
-function Storage({ key: storeKey, json, stringify } = {}) {
+function Storage({ key, json, stringify } = {}) {
   if (!json)
     json = (v) => JSON.parse(v);
   if (!stringify)
     stringify = (v) => JSON.stringify(v);
-  return (proto, key) => {
-    const tag = storeKey || getTag(proto);
+  return (proto, property) => {
+    const tag = key || getTag(proto);
     init(proto);
-    setStateKey(proto, key);
-    setHandler(proto, key, {
+    setMeta(proto, property, void 0, {
       init: (instance) => {
-        return getInject("storage")?.({ instance, key, tag, toJSON: json, toString: stringify });
+        return getInject("storage")?.({ instance, property, tag, toJSON: json, toString: stringify });
       }
     });
   };
 }
-function If(value, ...decorators) {
-  if (value) {
-    return (...args) => {
-      decorators.forEach((d) => d(...args));
-    };
-  }
-  return () => {
-  };
-}
 
 // src/base.ts
 var Base = class {
@@ -693,7 +482,7 @@ Base = __decorateClass([
 0 && (module.exports = {
   Assign,
   Base,
-  Bind,
+  CLEAR_KEY,
   Clear,
   DataMap,
   Effect,
@@ -702,7 +491,6 @@ Base = __decorateClass([
   Expose,
   Global,
   If,
-  Ignore,
   Init,
   Inject,
   Injectable,
@@ -710,48 +498,33 @@ Base = __decorateClass([
   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,
+  wait
 });