phecda-core 3.0.2 → 3.1.1

package/dist/index.mjs

@@ -1,56 +1,65 @@
 var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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/core.ts
 var SHARE_KEY = Symbol("phecda");
 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 绑定的属性，
+         * 某属性即使被捕捉，可被强行忽略，优先级最高
+        */
       __IGNORE_KEY: /* @__PURE__ */ new Set(),
       /**
-       * @Clear 绑定的属性，
-       * 消除父类在该key上的state/handler, 但export key 和 state
-      */
+         * @Clear 绑定的属性，
+         * 消除父类在该key上的state/handler, 但export key 和 state
+        */
       __CLEAR_KEY: /* @__PURE__ */ new Set(),
       /**
-       * 存在状态的变量
-       * @deprecated
-      */
+         * 存在状态的变量
+         * @deprecated
+        */
       __STATE_KEY: /* @__PURE__ */ new Set(),
       /**
-       * 状态变量的处理器
-      */
+         * 状态变量的处理器
+        */
       __STATE_HANDLER__: /* @__PURE__ */ new Map(),
       /**
-       * 状态变量的共有状态
-      */
+         * 状态变量的共有状态
+        */
       __STATE_NAMESPACE__: /* @__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;
@@ -60,7 +69,6 @@ function setStateKey(proto, key) {
   proto[PHECDA_KEY].__STATE_KEY.add(key);
   setExposeKey(proto, key);
 }
-__name(setStateKey, "setStateKey");
 function setExposeKey(proto, key) {
   if (!key) {
     key = SHARE_KEY;
@@ -69,7 +77,6 @@ function setExposeKey(proto, key) {
   init(proto);
   proto[PHECDA_KEY].__EXPOSE_KEY.add(key);
 }
-__name(setExposeKey, "setExposeKey");
 function setIgnoreKey(proto, key) {
   if (!key) {
     key = SHARE_KEY;
@@ -78,19 +85,17 @@ function setIgnoreKey(proto, key) {
   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);
+  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;
@@ -100,114 +105,89 @@ function setState(proto, key, state) {
   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
-  ];
+  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));
+    if (proto.hasOwnProperty(PHECDA_KEY))
+      proto[PHECDA_KEY].__STATE_KEY.forEach((item) => set2.add(item));
     proto = Object.getPrototypeOf(proto);
   }
-  return [
-    ...set2
-  ];
+  return [...set2];
 }
-__name(getStateKey, "getStateKey");
 function getOwnExposeKey(target) {
   const proto = getPhecdaFromTarget(target);
-  return [
-    ...proto[PHECDA_KEY].__EXPOSE_KEY
-  ].filter((item) => !proto[PHECDA_KEY].__IGNORE_KEY.has(item));
+  return [...proto[PHECDA_KEY].__EXPOSE_KEY].filter((item) => !proto[PHECDA_KEY].__IGNORE_KEY.has(item));
 }
-__name(getOwnExposeKey, "getOwnExposeKey");
 function getExposeKey(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))
+      [...proto[PHECDA_KEY].__EXPOSE_KEY].forEach((item) => !origin[PHECDA_KEY].__IGNORE_KEY.has(item) && set2.add(item));
     proto = Object.getPrototypeOf(proto);
   }
-  return [
-    ...set2
-  ];
+  return [...set2];
 }
-__name(getExposeKey, "getExposeKey");
 function getOwnIgnoreKey(target) {
   const proto = getPhecdaFromTarget(target);
-  return [
-    ...proto[PHECDA_KEY]?.__IGNORE_KEY
-  ];
+  return [...proto[PHECDA_KEY]?.__IGNORE_KEY];
 }
-__name(getOwnIgnoreKey, "getOwnIgnoreKey");
 function getOwnHandler(target, key) {
   const proto = getPhecdaFromTarget(target);
   return proto[PHECDA_KEY]?.__STATE_HANDLER__.get(key) || [];
 }
-__name(getOwnHandler, "getOwnHandler");
 function getHandler(target, 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;
+      if (proto[PHECDA_KEY].__CLEAR_KEY.has(key))
+        break;
     }
     proto = Object.getPrototypeOf(proto);
   }
-  return [
-    ...set2
-  ];
+  return [...set2];
 }
-__name(getHandler, "getHandler");
 function getState(target, key = SHARE_KEY) {
   let proto = getPhecdaFromTarget(target);
   let 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;
+      if (state)
+        ret = { ...state, ...ret };
+      if (proto[PHECDA_KEY].__CLEAR_KEY.has(key))
+        break;
     }
     proto = Object.getPrototypeOf(proto);
   }
   return ret;
 }
-__name(getState, "getState");
 function getOwnState(target, key = SHARE_KEY) {
   const proto = getPhecdaFromTarget(target);
   return proto[PHECDA_KEY].__STATE_NAMESPACE__.get(key) || {};
 }
-__name(getOwnState, "getOwnState");
 function invokeHandler(event, module) {
   const stateVars = getExposeKey(module);
   const initHandlers = stateVars.map((item) => {
     return getHandler(module, item).filter((h) => !!h[event]).map((h) => h[event](module));
   }).flat();
-  return Promise.all(initHandlers);
+  return module.__PROMISE_SYMBOL__ = Promise.all(initHandlers);
 }
-__name(invokeHandler, "invokeHandler");
 function set(proto, key, value) {
   init(proto);
   proto[`__${key.toUpperCase()}__`] = value;
 }
-__name(set, "set");
 function get(proto, key) {
   return proto[`__${key.toUpperCase()}__`];
 }
-__name(get, "get");
 
 // src/decorators/core.ts
 function Init(proto, key) {
@@ -218,7 +198,6 @@ function Init(proto, key) {
     }
   });
 }
-__name(Init, "Init");
 function Unmount(proto, key) {
   setStateKey(proto, key);
   setHandler(proto, key, {
@@ -227,7 +206,6 @@ function Unmount(proto, key) {
     }
   });
 }
-__name(Unmount, "Unmount");
 function Bind(value) {
   return (proto, k) => {
     setStateKey(proto, k);
@@ -236,57 +214,57 @@ function Bind(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);
 }
-__name(Clear, "Clear");
 function Expose(proto, key) {
   setExposeKey(proto, key);
 }
-__name(Expose, "Expose");
 function Empty(model) {
   init(model.prototype);
 }
-__name(Empty, "Empty");
+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;
+    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];
+  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);
@@ -296,15 +274,16 @@ function transformInstance(instance, force = false) {
     if (handlers) {
       for (const handler of handlers) {
         const pipe = handler.pipe;
-        if (!pipe) continue;
+        if (!pipe)
+          continue;
         pipe(instance, addError);
-        if (err.length && !force) return err;
+        if (err.length && !force)
+          return err;
       }
     }
   }
   return err;
 }
-__name(transformInstance, "transformInstance");
 async function transformInstanceAsync(instance, force = false) {
   const err = [];
   const keys = getExposeKey(instance);
@@ -314,15 +293,16 @@ async function transformInstanceAsync(instance, force = false) {
     if (handlers) {
       for (const handler of handlers) {
         const pipe = handler.pipe;
-        if (!pipe) continue;
+        if (!pipe)
+          continue;
         await pipe(instance, addError);
-        if (err.length && !force) return err;
+        if (err.length && !force)
+          return err;
       }
     }
   }
   return err;
 }
-__name(transformInstanceAsync, "transformInstanceAsync");
 function transformProperty(instance, property, force = false) {
   const err = [];
   const handlers = getHandler(instance, property);
@@ -330,14 +310,15 @@ function transformProperty(instance, property, force = false) {
   if (handlers) {
     for (const handler of handlers) {
       const pipe = handler.pipe;
-      if (!pipe) continue;
+      if (!pipe)
+        continue;
       pipe(instance, addError);
-      if (err.length && !force) return err;
+      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);
@@ -345,125 +326,117 @@ async function transformPropertyAsync(instance, property, force = false) {
   if (handlers) {
     for (const handler of handlers) {
       const pipe = handler.pipe;
-      if (!pipe) continue;
+      if (!pipe)
+        continue;
       await pipe(instance, addError);
-      if (err.length && !force) return err;
+      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];
+  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];
+  for (const i in data)
+    snap[i] = data[i];
   return {
     data,
     clear() {
-      for (const i in snap) delete data[i];
+      for (const i in snap)
+        delete data[i];
     },
     apply() {
-      for (const i in snap) data[i] = snap[i];
+      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);
 }
-__name(setPropertyState, "setPropertyState");
 function getShareState(target, getter) {
   const state = getOwnState(target, SHARE_KEY) || {};
   return getter(state);
 }
-__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) => {
+      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) => {
+    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);
@@ -471,8 +444,10 @@ function To(...callbacks) {
       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);
+            if (isAsyncFunc(cb))
+              instance[key] = await cb(instance[key], instance, key);
+            else
+              instance[key] = cb(instance[key], instance, key);
           } catch (e) {
             addError(e.message);
           }
@@ -481,29 +456,31 @@ function To(...callbacks) {
     });
   };
 }
-__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 (isAsyncFunc(cb))
+          ret = await cb(instance[key]);
+        else
+          ret = cb(instance[key]);
         if (!ret) {
-          if (typeof info === "string") addError(info);
-          else addError(info());
+          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) => {
+      init: (instance) => {
         if (typeof instance[key] === "function") {
           const oldFn = instance[key].bind(instance);
           if (isAsyncFunc(oldFn)) {
@@ -512,7 +489,8 @@ function Err(cb, isCatch = false) {
                 await oldFn(...args);
               } catch (e) {
                 cb(e, instance, key);
-                if (!isCatch) throw e;
+                if (!isCatch)
+                  throw e;
               }
             };
           } else {
@@ -521,28 +499,23 @@ function Err(cb, isCatch = false) {
                 oldFn(...args);
               } catch (e) {
                 cb(e, instance, key);
-                if (!isCatch) throw e;
+                if (!isCatch)
+                  throw e;
               }
             };
           }
         }
-      }, "init")
+      }
     });
   };
 }
-__name(Err, "Err");
 function Watcher(eventName, options) {
   let cb;
   return (proto, key) => {
     setStateKey(proto, key);
     setHandler(proto, key, {
       init(instance) {
-        return cb = getInject("watcher")?.({
-          eventName,
-          instance,
-          key,
-          options
-        });
+        return cb = getInject("watcher")?.({ eventName, instance, key, options });
       },
       unmount() {
         return cb?.();
@@ -550,7 +523,6 @@ function Watcher(eventName, options) {
     });
   };
 }
-__name(Watcher, "Watcher");
 function Effect(cb) {
   return (proto, key) => {
     setStateKey(proto, key);
@@ -571,28 +543,22 @@ 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");
+  if (!json)
+    json = (v) => JSON.parse(v);
+  if (!stringify)
+    stringify = (v) => JSON.stringify(v);
   return (proto, key) => {
     const tag = storeKey || 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")
+      init: (instance) => {
+        return getInject("storage")?.({ instance, key, tag, toJSON: json, toString: stringify });
+      }
     });
   };
 }
-__name(Storage, "Storage");
 function If(value, ...decorators) {
   if (value) {
     return (...args) => {
@@ -602,27 +568,11 @@ function If(value, ...decorators) {
   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);
@@ -643,16 +593,17 @@ 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);
 export {
   Assign,
   Base,
@@ -668,6 +619,7 @@ export {
   Ignore,
   Init,
   Inject,
+  Injectable,
   Isolate,
   PHECDA_KEY,
   Pipeline,