phecda-core 2.1.2-alpha.0 → 3.0.0-alpha.10

package/dist/index.js

@@ -33,12 +33,16 @@ __export(src_exports, {
   Ignore: () => Ignore,
   Init: () => Init,
   Inject: () => Inject,
+  Isolate: () => Isolate,
   Nested: () => Nested,
   Pipeline: () => Pipeline,
   Provide: () => Provide,
+  SHARE_KEY: () => SHARE_KEY,
   Storage: () => Storage,
   Tag: () => Tag,
   To: () => To,
+  Unique: () => Unique,
+  Unmount: () => Unmount,
   Watcher: () => Watcher,
   activeInstance: () => activeInstance,
   addDecoToClass: () => addDecoToClass,
@@ -46,49 +50,43 @@ __export(src_exports, {
   getBind: () => getBind,
   getExposeKey: () => getExposeKey,
   getHandler: () => getHandler,
-  getInitEvent: () => getInitEvent,
-  getModelState: () => getModelState,
+  getModuleState: () => getModuleState,
   getOwnExposeKey: () => getOwnExposeKey,
   getOwnHandler: () => getOwnHandler,
   getOwnIgnoreKey: () => getOwnIgnoreKey,
-  getOwnInitEvent: () => getOwnInitEvent,
-  getOwnModelState: () => getOwnModelState,
+  getOwnModuleState: () => getOwnModuleState,
   getOwnState: () => getOwnState,
   getProperty: () => getProperty,
   getState: () => getState,
-  getSymbol: () => getSymbol,
-  getTag: () => getTag,
+  getTag: () => getTag2,
   init: () => init,
   injectProperty: () => injectProperty,
+  invokeHandler: () => invokeHandler,
   isPhecda: () => isPhecda,
   plainToClass: () => plainToClass,
   regisHandler: () => regisHandler,
-  regisInitEvent: () => regisInitEvent,
-  register: () => register,
-  registerAsync: () => registerAsync,
   setExposeKey: () => setExposeKey,
   setIgnoreKey: () => setIgnoreKey,
-  setModelVar: () => setModelVar,
   setState: () => setState,
+  setVar: () => setVar,
   snapShot: () => snapShot,
   transformClass: () => transformClass
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/core.ts
-function isPhecda(target) {
-  if (typeof target === "function") {
-    return !!target.prototype?._namespace;
-  }
+function isPhecda(module2) {
+  if (typeof module2 === "function")
+    return !!module2.prototype?._namespace;
   return false;
 }
 __name(isPhecda, "isPhecda");
-function init(target) {
-  if (!target)
+var SHARE_KEY = Symbol("phecda-core");
+function init(proto) {
+  if (!proto)
     return;
-  if (!target.hasOwnProperty("_namespace")) {
-    target._namespace = {
-      __INIT_EVENT__: /* @__PURE__ */ new Set(),
+  if (!proto.hasOwnProperty("_namespace")) {
+    proto._namespace = {
       __EXPOSE_VAR__: /* @__PURE__ */ new Set(),
       __IGNORE_VAR__: /* @__PURE__ */ new Set(),
       __STATE_VAR__: /* @__PURE__ */ new Set(),
@@ -98,56 +96,31 @@ function init(target) {
   }
 }
 __name(init, "init");
-function regisInitEvent(target, key) {
-  init(target);
-  target._namespace.__INIT_EVENT__.add(key);
-}
-__name(regisInitEvent, "regisInitEvent");
-function getOwnInitEvent(target) {
-  if (!target?._namespace)
-    return [];
-  return [
-    ...target._namespace.__INIT_EVENT__
-  ];
-}
-__name(getOwnInitEvent, "getOwnInitEvent");
-function getInitEvent(target) {
-  let proto = Object.getPrototypeOf(target);
-  const set = /* @__PURE__ */ new Set();
-  while (proto?._namespace) {
-    proto._namespace.__INIT_EVENT__.forEach((item) => set.add(item));
-    proto = Object.getPrototypeOf(proto);
-  }
-  return [
-    ...set
-  ];
+function setVar(proto, key) {
+  init(proto);
+  proto._namespace.__STATE_VAR__.add(key);
+  setExposeKey(proto, key);
 }
-__name(getInitEvent, "getInitEvent");
-function setModelVar(target, key) {
-  init(target);
-  target._namespace.__STATE_VAR__.add(key);
-  setExposeKey(target, key);
-}
-__name(setModelVar, "setModelVar");
-function setExposeKey(target, key) {
-  init(target);
-  target._namespace.__EXPOSE_VAR__.add(key);
+__name(setVar, "setVar");
+function setExposeKey(proto, key) {
+  init(proto);
+  proto._namespace.__EXPOSE_VAR__.add(key);
 }
 __name(setExposeKey, "setExposeKey");
-function setIgnoreKey(target, key) {
-  init(target);
-  target._namespace.__IGNORE_VAR__.add(key);
+function setIgnoreKey(proto, key) {
+  init(proto);
+  proto._namespace.__IGNORE_VAR__.add(key);
 }
 __name(setIgnoreKey, "setIgnoreKey");
-function getOwnModelState(target) {
-  target = Object.getPrototypeOf(target);
+function getOwnModuleState(instance) {
+  instance = Object.getPrototypeOf(instance);
   return [
-    ...target._namespace.__STATE_VAR__
+    ...instance._namespace.__STATE_VAR__
   ];
 }
-__name(getOwnModelState, "getOwnModelState");
-function getModelState(target) {
-  let proto = Object.getPrototypeOf(target);
+__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));
@@ -157,16 +130,16 @@ function getModelState(target) {
     ...set
   ];
 }
-__name(getModelState, "getModelState");
-function getOwnExposeKey(target) {
-  target = Object.getPrototypeOf(target);
+__name(getModuleState, "getModuleState");
+function getOwnExposeKey(instance) {
+  instance = Object.getPrototypeOf(instance);
   return [
-    ...target._namespace.__EXPOSE_VAR__
-  ].filter((item) => !target._namespace.__IGNORE_VAR__.has(item));
+    ...instance._namespace.__EXPOSE_VAR__
+  ].filter((item) => !instance._namespace.__IGNORE_VAR__.has(item));
 }
 __name(getOwnExposeKey, "getOwnExposeKey");
-function getExposeKey(target) {
-  let proto = Object.getPrototypeOf(target);
+function getExposeKey(instance) {
+  let proto = Object.getPrototypeOf(instance);
   const set = /* @__PURE__ */ new Set();
   while (proto?._namespace) {
     [
@@ -179,32 +152,32 @@ function getExposeKey(target) {
   ];
 }
 __name(getExposeKey, "getExposeKey");
-function getOwnIgnoreKey(target) {
-  if (!target?._namespace)
+function getOwnIgnoreKey(instance) {
+  if (!instance?._namespace)
     return [];
   return [
-    ...target._namespace.__IGNORE_VAR__
+    ...instance._namespace.__IGNORE_VAR__
   ];
 }
 __name(getOwnIgnoreKey, "getOwnIgnoreKey");
-function regisHandler(target, key, handler) {
-  init(target);
-  if (!target._namespace.__STATE_HANDLER__.has(key))
-    target._namespace.__STATE_HANDLER__.set(key, [
+function regisHandler(proto, key, handler) {
+  init(proto);
+  if (!proto._namespace.__STATE_HANDLER__.has(key))
+    proto._namespace.__STATE_HANDLER__.set(key, [
       handler
     ]);
   else
-    target._namespace.__STATE_HANDLER__.get(key).push(handler);
+    proto._namespace.__STATE_HANDLER__.get(key).push(handler);
 }
 __name(regisHandler, "regisHandler");
-function getOwnHandler(target, key) {
-  if (!target?._namespace)
+function getOwnHandler(instance, key) {
+  if (!instance?._namespace)
     return [];
-  return target._namespace.__STATE_HANDLER__.get(key) || [];
+  return instance._namespace.__STATE_HANDLER__.get(key) || [];
 }
 __name(getOwnHandler, "getOwnHandler");
-function getHandler(target, key) {
-  let proto = Object.getPrototypeOf(target);
+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));
@@ -215,19 +188,19 @@ function getHandler(target, key) {
   ];
 }
 __name(getHandler, "getHandler");
-function setState(target, key, state) {
-  init(target);
-  const namespace = target._namespace.__STATE_NAMESPACE__;
+function setState(proto, key, state) {
+  init(proto);
+  const namespace = proto._namespace.__STATE_NAMESPACE__;
   namespace.set(key, state);
 }
 __name(setState, "setState");
-function getOwnState(target, key) {
-  target = Object.getPrototypeOf(target);
-  return target._namespace.__STATE_NAMESPACE__.get(key) || {};
+function getOwnState(instance, key) {
+  instance = Object.getPrototypeOf(instance);
+  return instance._namespace.__STATE_NAMESPACE__.get(key) || {};
 }
 __name(getOwnState, "getOwnState");
-function getState(target, key) {
-  let proto = Object.getPrototypeOf(target);
+function getState(instance, key) {
+  let proto = Object.getPrototypeOf(instance);
   let ret = {};
   while (proto?._namespace) {
     const state = proto._namespace.__STATE_NAMESPACE__.get(key);
@@ -241,38 +214,25 @@ function getState(target, key) {
   return ret;
 }
 __name(getState, "getState");
-function register(instance) {
+function invokeHandler(event, instance) {
   const stateVars = getExposeKey(instance);
-  for (const item of stateVars) {
-    const handlers = getHandler(instance, item);
-    for (const hanlder of handlers)
-      hanlder.init?.(instance);
-  }
+  const initHandlers = stateVars.map((item) => {
+    return getHandler(instance, item).filter((h) => !!h[event]).map((h) => h[event](instance));
+  }).flat();
+  return Promise.all(initHandlers);
 }
-__name(register, "register");
-async function registerAsync(instance) {
-  const stateVars = getExposeKey(instance);
-  for (const item of stateVars) {
-    const handlers = getHandler(instance, item);
-    for (const hanlder of handlers)
-      await hanlder.init?.(instance);
-  }
-}
-__name(registerAsync, "registerAsync");
+__name(invokeHandler, "invokeHandler");
 
 // src/helper.ts
-function getTag(Model) {
-  return Model.prototype?.__TAG__;
-}
-__name(getTag, "getTag");
-function getSymbol(instance) {
-  const Model = instance.constructor;
-  return getTag(Model) || Model.name;
-}
-__name(getSymbol, "getSymbol");
-function getBind(Model) {
-  const instance = new Model();
-  const keys = getModelState(instance);
+function getTag2(moduleOrInstance) {
+  if (typeof moduleOrInstance === "object")
+    moduleOrInstance = moduleOrInstance.constructor;
+  return moduleOrInstance.prototype?.__TAG__ || moduleOrInstance.name;
+}
+__name(getTag2, "getTag");
+function getBind(module2) {
+  const instance = new module2();
+  const keys = getModuleState(instance);
   const ret = {};
   for (const item of keys) {
     const state = getState(instance, item);
@@ -282,8 +242,8 @@ function getBind(Model) {
   return ret;
 }
 __name(getBind, "getBind");
-function plainToClass(Model, input) {
-  const instance = new Model();
+function plainToClass(module2, input) {
+  const instance = new module2();
   const keys = getExposeKey(instance);
   for (const item of keys)
     instance[item] = input[item];
@@ -292,7 +252,7 @@ function plainToClass(Model, input) {
 __name(plainToClass, "plainToClass");
 async function transformClass(instance, force = false) {
   const err = [];
-  const stateVars = getModelState(instance);
+  const stateVars = getModuleState(instance);
   for (const item of stateVars) {
     const handlers = getHandler(instance, item);
     if (handlers) {
@@ -336,8 +296,8 @@ function snapShot(data) {
   };
 }
 __name(snapShot, "snapShot");
-function addDecoToClass(c, key, handler, type = "normal") {
-  handler(type === "normal" ? c.prototype : c, key);
+function addDecoToClass(c, key, handler, type = "class") {
+  handler(type === "class" ? c.prototype : c, key);
 }
 __name(addDecoToClass, "addDecoToClass");
 function Pipeline(...decos) {
@@ -349,74 +309,90 @@ function Pipeline(...decos) {
 __name(Pipeline, "Pipeline");
 
 // src/decorators.ts
-function Init(target, key) {
-  setModelVar(target, key);
-  regisHandler(target, key, {
+function Init(proto, key) {
+  setVar(proto, key);
+  regisHandler(proto, key, {
     async init(instance) {
-      instance[key]();
+      return instance[key]();
     }
   });
 }
 __name(Init, "Init");
+function Unmount(proto, key) {
+  setVar(proto, key);
+  regisHandler(proto, key, {
+    async unmount(instance) {
+      return instance[key]();
+    }
+  });
+}
+__name(Unmount, "Unmount");
 function Bind(value) {
-  return (target, k) => {
-    setModelVar(target, k);
-    setState(target, k, {
+  return (proto, k) => {
+    setVar(proto, k);
+    setState(proto, k, {
       value
     });
   };
 }
 __name(Bind, "Bind");
-function Ignore(target, key) {
-  setIgnoreKey(target, key);
+function Ignore(proto, key) {
+  setIgnoreKey(proto, key);
 }
 __name(Ignore, "Ignore");
-function Clear(target, key) {
-  init(target);
-  target._namespace.__INIT_EVENT__.delete(key);
-  target._namespace.__EXPOSE_VAR__.delete(key);
-  target._namespace.__IGNORE_VAR__.delete(key);
-  target._namespace.__STATE_VAR__.delete(key);
-  target._namespace.__STATE_HANDLER__.delete(key);
-  target._namespace.__STATE_NAMESPACE__.delete(key);
+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(Clear, "Clear");
 function Err(cb) {
-  return (target, key) => {
-    setModelVar(target, key);
-    regisHandler(target, key, {
+  return (proto, key) => {
+    setVar(proto, key);
+    regisHandler(proto, key, {
       error: cb
     });
   };
 }
 __name(Err, "Err");
-function Expose(target, key) {
-  setExposeKey(target, key);
+function Expose(proto, key) {
+  setExposeKey(proto, key);
 }
 __name(Expose, "Expose");
-function To(cb) {
-  return (obj, key) => {
-    setModelVar(obj, key);
-    regisHandler(obj, key, {
+function To(...callbacks) {
+  return (proto, key) => {
+    setVar(proto, key);
+    regisHandler(proto, key, {
       async pipe(instance) {
-        instance[key] = await cb(instance[key], instance, key);
+        for (const cb of callbacks)
+          instance[key] = await cb(instance[key], instance, key);
       }
     });
   };
 }
 __name(To, "To");
 function Tag(tag) {
-  return (target) => {
-    init(target.prototype);
-    target.prototype.__TAG__ = tag;
+  return (module2) => {
+    init(module2.prototype);
+    module2.prototype.__TAG__ = tag;
   };
 }
 __name(Tag, "Tag");
+function Unique(desc) {
+  return (module2) => {
+    init(module2.prototype);
+    module2.prototype.__TAG__ = Symbol(desc || module2.name);
+  };
+}
+__name(Unique, "Unique");
 function Assign(cb) {
-  return (target) => {
-    init(target.prototype);
-    setModelVar(target.prototype, "__CLASS");
-    regisHandler(target.prototype, "__CLASS", {
+  return (module2) => {
+    init(module2.prototype);
+    setVar(module2.prototype, SHARE_KEY);
+    regisHandler(module2.prototype, SHARE_KEY, {
       init: async (instance) => {
         const value = await cb(instance);
         if (value && typeof value === "object" && !Array.isArray(value)) {
@@ -428,10 +404,10 @@ function Assign(cb) {
   };
 }
 __name(Assign, "Assign");
-function Global(target) {
-  init(target.prototype);
-  setModelVar(target.prototype, "__CLASS");
-  regisHandler(target.prototype, "__CLASS", {
+function Global(module2) {
+  init(module2.prototype);
+  setVar(module2.prototype, SHARE_KEY);
+  regisHandler(module2.prototype, SHARE_KEY, {
     init: async (instance) => {
       const tag = instance.__TAG__;
       if (!tag)
@@ -443,8 +419,8 @@ function Global(target) {
   });
 }
 __name(Global, "Global");
-function Empty(_target) {
-  init(_target.prototype);
+function Empty(module2) {
+  init(module2.prototype);
 }
 __name(Empty, "Empty");
 var DataMap = {};
@@ -461,9 +437,9 @@ function Inject(key) {
   return DataMap[key] || EmptyProxy;
 }
 __name(Inject, "Inject");
-function Nested(Model) {
+function Nested(module2) {
   return To(async (property) => {
-    const instance = plainToClass(Model, property);
+    const instance = plainToClass(module2, property);
     const err = await transformClass(instance);
     if (err.length > 0)
       throw new Error(err[0]);
@@ -471,8 +447,15 @@ function Nested(Model) {
   });
 }
 __name(Nested, "Nested");
+function Isolate() {
+  return (target) => {
+    init(target.prototype);
+    target.prototype.__ISOLATE__ = true;
+  };
+}
+__name(Isolate, "Isolate");
 
-// src/namespace.ts
+// src/custom/decorator.ts
 var activeInstance = {};
 function injectProperty(key, value) {
   activeInstance[key] = value;
@@ -483,28 +466,30 @@ function getProperty(key) {
   return activeInstance[key];
 }
 __name(getProperty, "getProperty");
-
-// src/custom/decorator.ts
 function Watcher(eventName, options) {
-  return (obj, key) => {
-    setModelVar(obj, key);
-    regisHandler(obj, key, {
+  let cb;
+  return (proto, key) => {
+    setVar(proto, key);
+    regisHandler(proto, key, {
       init(instance) {
-        getProperty("watcher")?.({
+        return cb = getProperty("watcher")?.({
           eventName,
           instance,
           key,
           options
         });
+      },
+      unmount() {
+        return cb?.();
       }
     });
   };
 }
 __name(Watcher, "Watcher");
 function Effect(eventName, options) {
-  return (obj, key) => {
-    setModelVar(obj, key);
-    regisHandler(obj, key, {
+  return (proto, key) => {
+    setVar(proto, key);
+    regisHandler(proto, key, {
       init(instance) {
         instance[`$_${key}`] = instance[key];
         Object.defineProperty(instance, key, {
@@ -527,34 +512,40 @@ function Effect(eventName, options) {
   };
 }
 __name(Effect, "Effect");
-function Storage(storeKey) {
-  return (target, key) => {
+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(target);
-      tag = storeKey || target.__TAG__;
-      const uniTag = Symbol(tag);
-      setModelVar(target, uniTag);
-      regisHandler(target, uniTag, {
+      init(proto);
+      tag = storeKey || `${getTag(proto)}_${key}`;
+      setVar(proto, key);
+      regisHandler(proto, key, {
         init: (instance) => {
-          getProperty("storage")?.({
+          return getProperty("storage")?.({
             instance,
             key,
-            tag
+            tag,
+            toJSON,
+            toString
           });
         }
       });
     } else {
-      init(target.prototype);
-      tag = storeKey || `${target.prototype.__TAG__}_${key}`;
-      const uniTag = Symbol(tag);
-      setModelVar(target.prototype, uniTag);
-      regisHandler(target.prototype, uniTag, {
+      init(proto.prototype);
+      tag = storeKey || getTag(proto);
+      setVar(proto.prototype, SHARE_KEY);
+      regisHandler(proto.prototype, SHARE_KEY, {
         init: (instance) => {
-          getProperty("storage")?.({
+          return getProperty("storage")?.({
             instance,
-            key: "",
-            tag
+            key,
+            tag,
+            toJSON,
+            toString
           });
         }
       });
@@ -576,12 +567,16 @@ __name(Storage, "Storage");
   Ignore,
   Init,
   Inject,
+  Isolate,
   Nested,
   Pipeline,
   Provide,
+  SHARE_KEY,
   Storage,
   Tag,
   To,
+  Unique,
+  Unmount,
   Watcher,
   activeInstance,
   addDecoToClass,
@@ -589,30 +584,25 @@ __name(Storage, "Storage");
   getBind,
   getExposeKey,
   getHandler,
-  getInitEvent,
-  getModelState,
+  getModuleState,
   getOwnExposeKey,
   getOwnHandler,
   getOwnIgnoreKey,
-  getOwnInitEvent,
-  getOwnModelState,
+  getOwnModuleState,
   getOwnState,
   getProperty,
   getState,
-  getSymbol,
   getTag,
   init,
   injectProperty,
+  invokeHandler,
   isPhecda,
   plainToClass,
   regisHandler,
-  regisInitEvent,
-  register,
-  registerAsync,
   setExposeKey,
   setIgnoreKey,
-  setModelVar,
   setState,
+  setVar,
   snapShot,
   transformClass
 });