phecda-core 3.0.0-alpha.10 → 3.0.0-alpha.12

package/dist/index.mjs

@@ -2,18 +2,19 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/core.ts
+var SHARE_KEY = Symbol("phecda");
+var PHECDA_KEY = Symbol("phecda");
 function isPhecda(module) {
   if (typeof module === "function")
-    return !!module.prototype?._namespace;
+    return !!module.prototype?.[PHECDA_KEY];
   return false;
 }
 __name(isPhecda, "isPhecda");
-var SHARE_KEY = Symbol("phecda-core");
 function init(proto) {
   if (!proto)
     return;
-  if (!proto.hasOwnProperty("_namespace")) {
-    proto._namespace = {
+  if (!proto.hasOwnProperty(PHECDA_KEY)) {
+    proto[PHECDA_KEY] = {
       __EXPOSE_VAR__: /* @__PURE__ */ new Set(),
       __IGNORE_VAR__: /* @__PURE__ */ new Set(),
       __STATE_VAR__: /* @__PURE__ */ new Set(),
@@ -23,55 +24,79 @@ function init(proto) {
   }
 }
 __name(init, "init");
-function setVar(proto, key) {
+function getPhecdaFromTarget(target) {
+  if (typeof target === "function")
+    return target.prototype;
+  if (target.hasOwnProperty(PHECDA_KEY))
+    return target;
+  return Object.getPrototypeOf(target);
+}
+__name(getPhecdaFromTarget, "getPhecdaFromTarget");
+function setStateVar(proto, key) {
   init(proto);
-  proto._namespace.__STATE_VAR__.add(key);
+  proto[PHECDA_KEY].__STATE_VAR__.add(key);
   setExposeKey(proto, key);
 }
-__name(setVar, "setVar");
+__name(setStateVar, "setStateVar");
 function setExposeKey(proto, key) {
   init(proto);
-  proto._namespace.__EXPOSE_VAR__.add(key);
+  proto[PHECDA_KEY].__EXPOSE_VAR__.add(key);
 }
 __name(setExposeKey, "setExposeKey");
 function setIgnoreKey(proto, key) {
   init(proto);
-  proto._namespace.__IGNORE_VAR__.add(key);
+  proto[PHECDA_KEY].__IGNORE_VAR__.add(key);
 }
 __name(setIgnoreKey, "setIgnoreKey");
-function getOwnModuleState(instance) {
-  instance = Object.getPrototypeOf(instance);
+function setHandler(proto, key, handler) {
+  init(proto);
+  if (!proto[PHECDA_KEY].__STATE_HANDLER__.has(key))
+    proto[PHECDA_KEY].__STATE_HANDLER__.set(key, [
+      handler
+    ]);
+  else
+    proto[PHECDA_KEY].__STATE_HANDLER__.get(key).push(handler);
+}
+__name(setHandler, "setHandler");
+function setState(proto, key, state) {
+  init(proto);
+  const namespace = proto[PHECDA_KEY].__STATE_NAMESPACE__;
+  namespace.set(key, state);
+}
+__name(setState, "setState");
+function getOwnStateVars(target) {
+  const proto = getPhecdaFromTarget(target);
   return [
-    ...instance._namespace.__STATE_VAR__
+    ...proto[PHECDA_KEY].__STATE_VAR__
   ];
 }
-__name(getOwnModuleState, "getOwnModuleState");
-function getModuleState(instance) {
-  let proto = Object.getPrototypeOf(instance);
+__name(getOwnStateVars, "getOwnStateVars");
+function getStateVars(target) {
+  let proto = getPhecdaFromTarget(target);
   const set = /* @__PURE__ */ new Set();
-  while (proto?._namespace) {
-    proto._namespace.__STATE_VAR__.forEach((item) => set.add(item));
+  while (proto?.[PHECDA_KEY]) {
+    proto[PHECDA_KEY].__STATE_VAR__.forEach((item) => set.add(item));
     proto = Object.getPrototypeOf(proto);
   }
   return [
     ...set
   ];
 }
-__name(getModuleState, "getModuleState");
-function getOwnExposeKey(instance) {
-  instance = Object.getPrototypeOf(instance);
+__name(getStateVars, "getStateVars");
+function getOwnExposeKey(target) {
+  const proto = getPhecdaFromTarget(target);
   return [
-    ...instance._namespace.__EXPOSE_VAR__
-  ].filter((item) => !instance._namespace.__IGNORE_VAR__.has(item));
+    ...proto[PHECDA_KEY].__EXPOSE_VAR__
+  ].filter((item) => !proto[PHECDA_KEY].__IGNORE_VAR__.has(item));
 }
 __name(getOwnExposeKey, "getOwnExposeKey");
-function getExposeKey(instance) {
-  let proto = Object.getPrototypeOf(instance);
+function getExposeKey(target) {
+  let proto = getPhecdaFromTarget(target);
   const set = /* @__PURE__ */ new Set();
-  while (proto?._namespace) {
+  while (proto?.[PHECDA_KEY]) {
     [
-      ...proto._namespace.__EXPOSE_VAR__
-    ].forEach((item) => !proto._namespace.__IGNORE_VAR__.has(item) && set.add(item));
+      ...proto[PHECDA_KEY].__EXPOSE_VAR__
+    ].forEach((item) => !proto[PHECDA_KEY].__IGNORE_VAR__.has(item) && set.add(item));
     proto = Object.getPrototypeOf(proto);
   }
   return [
@@ -79,35 +104,27 @@ function getExposeKey(instance) {
   ];
 }
 __name(getExposeKey, "getExposeKey");
-function getOwnIgnoreKey(instance) {
-  if (!instance?._namespace)
+function getOwnIgnoreKey(target) {
+  const proto = getPhecdaFromTarget(target);
+  if (!proto?.[PHECDA_KEY])
     return [];
   return [
-    ...instance._namespace.__IGNORE_VAR__
+    ...proto[PHECDA_KEY].__IGNORE_VAR__
   ];
 }
 __name(getOwnIgnoreKey, "getOwnIgnoreKey");
-function regisHandler(proto, key, handler) {
-  init(proto);
-  if (!proto._namespace.__STATE_HANDLER__.has(key))
-    proto._namespace.__STATE_HANDLER__.set(key, [
-      handler
-    ]);
-  else
-    proto._namespace.__STATE_HANDLER__.get(key).push(handler);
-}
-__name(regisHandler, "regisHandler");
-function getOwnHandler(instance, key) {
-  if (!instance?._namespace)
+function getOwnHandler(target, key) {
+  const proto = getPhecdaFromTarget(target);
+  if (!proto?.[PHECDA_KEY])
     return [];
-  return instance._namespace.__STATE_HANDLER__.get(key) || [];
+  return proto[PHECDA_KEY].__STATE_HANDLER__.get(key) || [];
 }
 __name(getOwnHandler, "getOwnHandler");
-function getHandler(instance, key) {
-  let proto = Object.getPrototypeOf(instance);
+function getHandler(target, key) {
+  let proto = getPhecdaFromTarget(target);
   const set = /* @__PURE__ */ new Set();
-  while (proto?._namespace) {
-    proto._namespace.__STATE_HANDLER__.get(key)?.forEach((item) => set.add(item));
+  while (proto?.[PHECDA_KEY]) {
+    proto[PHECDA_KEY].__STATE_HANDLER__.get(key)?.forEach((item) => set.add(item));
     proto = Object.getPrototypeOf(proto);
   }
   return [
@@ -115,22 +132,11 @@ function getHandler(instance, key) {
   ];
 }
 __name(getHandler, "getHandler");
-function setState(proto, key, state) {
-  init(proto);
-  const namespace = proto._namespace.__STATE_NAMESPACE__;
-  namespace.set(key, state);
-}
-__name(setState, "setState");
-function getOwnState(instance, key) {
-  instance = Object.getPrototypeOf(instance);
-  return instance._namespace.__STATE_NAMESPACE__.get(key) || {};
-}
-__name(getOwnState, "getOwnState");
-function getState(instance, key) {
-  let proto = Object.getPrototypeOf(instance);
+function getState(target, key) {
+  let proto = getPhecdaFromTarget(target);
   let ret = {};
-  while (proto?._namespace) {
-    const state = proto._namespace.__STATE_NAMESPACE__.get(key);
+  while (proto?.[PHECDA_KEY]) {
+    const state = proto[PHECDA_KEY].__STATE_NAMESPACE__.get(key);
     if (state)
       ret = {
         ...state,
@@ -141,6 +147,11 @@ function getState(instance, key) {
   return ret;
 }
 __name(getState, "getState");
+function getOwnState(target, key) {
+  const proto = getPhecdaFromTarget(target);
+  return proto[PHECDA_KEY].__STATE_NAMESPACE__.get(key) || {};
+}
+__name(getOwnState, "getOwnState");
 function invokeHandler(event, instance) {
   const stateVars = getExposeKey(instance);
   const initHandlers = stateVars.map((item) => {
@@ -150,16 +161,66 @@ function invokeHandler(event, instance) {
 }
 __name(invokeHandler, "invokeHandler");
 
+// src/decorators/core.ts
+function Init(proto, key) {
+  setStateVar(proto, key);
+  setHandler(proto, key, {
+    async init(instance) {
+      return instance[key]();
+    }
+  });
+}
+__name(Init, "Init");
+function Unmount(proto, key) {
+  setStateVar(proto, key);
+  setHandler(proto, key, {
+    async unmount(instance) {
+      return instance[key]();
+    }
+  });
+}
+__name(Unmount, "Unmount");
+function Bind(value) {
+  return (proto, k) => {
+    setStateVar(proto, k);
+    setState(proto, k, {
+      value
+    });
+  };
+}
+__name(Bind, "Bind");
+function Ignore(proto, key) {
+  setIgnoreKey(proto, key);
+}
+__name(Ignore, "Ignore");
+function Clear(proto, key) {
+  init(proto);
+  proto[PHECDA_KEY].__EXPOSE_VAR__.delete(key);
+  proto[PHECDA_KEY].__IGNORE_VAR__.delete(key);
+  proto[PHECDA_KEY].__STATE_VAR__.delete(key);
+  proto[PHECDA_KEY].__STATE_HANDLER__.delete(key);
+  proto[PHECDA_KEY].__STATE_NAMESPACE__.delete(key);
+}
+__name(Clear, "Clear");
+function Expose(proto, key) {
+  setExposeKey(proto, key);
+}
+__name(Expose, "Expose");
+function Empty(module) {
+  init(module.prototype);
+}
+__name(Empty, "Empty");
+
 // src/helper.ts
-function getTag2(moduleOrInstance) {
+function getTag(moduleOrInstance) {
   if (typeof moduleOrInstance === "object")
     moduleOrInstance = moduleOrInstance.constructor;
   return moduleOrInstance.prototype?.__TAG__ || moduleOrInstance.name;
 }
-__name(getTag2, "getTag");
+__name(getTag, "getTag");
 function getBind(module) {
   const instance = new module();
-  const keys = getModuleState(instance);
+  const keys = getStateVars(instance);
   const ret = {};
   for (const item of keys) {
     const state = getState(instance, item);
@@ -179,12 +240,14 @@ function plainToClass(module, input) {
 __name(plainToClass, "plainToClass");
 async function transformClass(instance, force = false) {
   const err = [];
-  const stateVars = getModuleState(instance);
-  for (const item of stateVars) {
+  const keys = getExposeKey(instance);
+  for (const item of keys) {
     const handlers = getHandler(instance, item);
     if (handlers) {
       for (const handler of handlers) {
         const pipe = handler.pipe;
+        if (!pipe)
+          continue;
         try {
           await pipe(instance);
         } catch (e) {
@@ -198,14 +261,34 @@ async function transformClass(instance, force = false) {
   return err;
 }
 __name(transformClass, "transformClass");
-function classToValue(instance) {
+async function transformProperty(instance, property, force = false) {
+  const err = [];
+  const handlers = getHandler(instance, property);
+  if (handlers) {
+    for (const handler of handlers) {
+      const pipe = handler.pipe;
+      if (!pipe)
+        continue;
+      try {
+        await pipe(instance);
+      } catch (e) {
+        err.push(e.message);
+        if (!force)
+          return err;
+      }
+    }
+  }
+  return err;
+}
+__name(transformProperty, "transformProperty");
+function classToPlain(instance) {
   const data = {};
   const exposeVars = getExposeKey(instance);
   for (const item of exposeVars)
     data[item] = instance[item];
-  return data;
+  return JSON.parse(JSON.stringify(data));
 }
-__name(classToValue, "classToValue");
+__name(classToPlain, "classToPlain");
 function snapShot(data) {
   const snap = {};
   for (const i in data)
@@ -223,8 +306,8 @@ function snapShot(data) {
   };
 }
 __name(snapShot, "snapShot");
-function addDecoToClass(c, key, handler, type = "class") {
-  handler(type === "class" ? c.prototype : c, key);
+function addDecoToClass(c, key, handler) {
+  handler(key === SHARE_KEY ? c : c.prototype, key);
 }
 __name(addDecoToClass, "addDecoToClass");
 function Pipeline(...decos) {
@@ -234,73 +317,43 @@ function Pipeline(...decos) {
   };
 }
 __name(Pipeline, "Pipeline");
-
-// src/decorators.ts
-function Init(proto, key) {
-  setVar(proto, key);
-  regisHandler(proto, key, {
-    async init(instance) {
-      return instance[key]();
-    }
-  });
-}
-__name(Init, "Init");
-function Unmount(proto, key) {
-  setVar(proto, key);
-  regisHandler(proto, key, {
-    async unmount(instance) {
-      return instance[key]();
-    }
-  });
-}
-__name(Unmount, "Unmount");
-function Bind(value) {
-  return (proto, k) => {
-    setVar(proto, k);
-    setState(proto, k, {
-      value
-    });
-  };
+function isAsyncFunc(fn) {
+  return fn[Symbol.toStringTag] === "AsyncFunction";
 }
-__name(Bind, "Bind");
-function Ignore(proto, key) {
-  setIgnoreKey(proto, key);
+__name(isAsyncFunc, "isAsyncFunc");
+
+// src/di.ts
+var DataMap = {};
+function Provide(key, value) {
+  DataMap[key] = value;
 }
-__name(Ignore, "Ignore");
-function Clear(proto, key) {
-  init(proto);
-  proto._namespace.__EXPOSE_VAR__.delete(key);
-  proto._namespace.__IGNORE_VAR__.delete(key);
-  proto._namespace.__STATE_VAR__.delete(key);
-  proto._namespace.__STATE_HANDLER__.delete(key);
-  proto._namespace.__STATE_NAMESPACE__.delete(key);
+__name(Provide, "Provide");
+var EmptyProxy = new Proxy(Empty, {
+  apply() {
+    return EmptyProxy;
+  }
+});
+function Inject(key) {
+  return DataMap[key] || EmptyProxy;
 }
-__name(Clear, "Clear");
-function Err(cb) {
-  return (proto, key) => {
-    setVar(proto, key);
-    regisHandler(proto, key, {
-      error: cb
-    });
-  };
+__name(Inject, "Inject");
+var activeInstance = {};
+function injectProperty(key, value) {
+  activeInstance[key] = value;
+  return activeInstance;
 }
-__name(Err, "Err");
-function Expose(proto, key) {
-  setExposeKey(proto, key);
+__name(injectProperty, "injectProperty");
+function getProperty(key) {
+  return activeInstance[key];
 }
-__name(Expose, "Expose");
-function To(...callbacks) {
-  return (proto, key) => {
-    setVar(proto, key);
-    regisHandler(proto, key, {
-      async pipe(instance) {
-        for (const cb of callbacks)
-          instance[key] = await cb(instance[key], instance, key);
-      }
-    });
-  };
+__name(getProperty, "getProperty");
+
+// src/decorators/function.ts
+function Isolate(target) {
+  init(target.prototype);
+  target.prototype.__ISOLATE__ = true;
 }
-__name(To, "To");
+__name(Isolate, "Isolate");
 function Tag(tag) {
   return (module) => {
     init(module.prototype);
@@ -318,8 +371,8 @@ __name(Unique, "Unique");
 function Assign(cb) {
   return (module) => {
     init(module.prototype);
-    setVar(module.prototype, SHARE_KEY);
-    regisHandler(module.prototype, SHARE_KEY, {
+    setStateVar(module.prototype, SHARE_KEY);
+    setHandler(module.prototype, SHARE_KEY, {
       init: async (instance) => {
         const value = await cb(instance);
         if (value && typeof value === "object" && !Array.isArray(value)) {
@@ -333,8 +386,8 @@ function Assign(cb) {
 __name(Assign, "Assign");
 function Global(module) {
   init(module.prototype);
-  setVar(module.prototype, SHARE_KEY);
-  regisHandler(module.prototype, SHARE_KEY, {
+  setStateVar(module.prototype, SHARE_KEY);
+  setHandler(module.prototype, SHARE_KEY, {
     init: async (instance) => {
       const tag = instance.__TAG__;
       if (!tag)
@@ -346,58 +399,57 @@ function Global(module) {
   });
 }
 __name(Global, "Global");
-function Empty(module) {
-  init(module.prototype);
-}
-__name(Empty, "Empty");
-var DataMap = {};
-function Provide(key, value) {
-  DataMap[key] = value;
-}
-__name(Provide, "Provide");
-var EmptyProxy = new Proxy(Empty, {
-  apply() {
-    return EmptyProxy;
-  }
-});
-function Inject(key) {
-  return DataMap[key] || EmptyProxy;
-}
-__name(Inject, "Inject");
-function Nested(module) {
-  return To(async (property) => {
-    const instance = plainToClass(module, property);
-    const err = await transformClass(instance);
-    if (err.length > 0)
-      throw new Error(err[0]);
-    return instance;
-  });
-}
-__name(Nested, "Nested");
-function Isolate() {
-  return (target) => {
-    init(target.prototype);
-    target.prototype.__ISOLATE__ = true;
+function To(...callbacks) {
+  return (proto, key) => {
+    setStateVar(proto, key);
+    setHandler(proto, key, {
+      async pipe(instance) {
+        for (const cb of callbacks)
+          instance[key] = await cb(instance[key], instance, key);
+      }
+    });
   };
 }
-__name(Isolate, "Isolate");
-
-// src/custom/decorator.ts
-var activeInstance = {};
-function injectProperty(key, value) {
-  activeInstance[key] = value;
-  return activeInstance;
-}
-__name(injectProperty, "injectProperty");
-function getProperty(key) {
-  return activeInstance[key];
+__name(To, "To");
+function Err(cb, isCatch = false) {
+  return (proto, key) => {
+    setStateVar(proto, key);
+    setHandler(proto, key, {
+      init: (instance) => {
+        if (typeof instance[key] === "function") {
+          const oldFn = instance[key].bind(instance);
+          if (isAsyncFunc(oldFn)) {
+            instance[key] = async (...args) => {
+              try {
+                await oldFn(...args);
+              } catch (e) {
+                cb(e, instance, key);
+                if (!isCatch)
+                  throw e;
+              }
+            };
+          } else {
+            instance[key] = (...args) => {
+              try {
+                oldFn(...args);
+              } catch (e) {
+                cb(e, instance, key);
+                if (!isCatch)
+                  throw e;
+              }
+            };
+          }
+        }
+      }
+    });
+  };
 }
-__name(getProperty, "getProperty");
+__name(Err, "Err");
 function Watcher(eventName, options) {
   let cb;
   return (proto, key) => {
-    setVar(proto, key);
-    regisHandler(proto, key, {
+    setStateVar(proto, key);
+    setHandler(proto, key, {
       init(instance) {
         return cb = getProperty("watcher")?.({
           eventName,
@@ -415,8 +467,8 @@ function Watcher(eventName, options) {
 __name(Watcher, "Watcher");
 function Effect(eventName, options) {
   return (proto, key) => {
-    setVar(proto, key);
-    regisHandler(proto, key, {
+    setStateVar(proto, key);
+    setHandler(proto, key, {
       init(instance) {
         instance[`$_${key}`] = instance[key];
         Object.defineProperty(instance, key, {
@@ -449,8 +501,8 @@ function Storage({ key: storeKey, toJSON, toString } = {}) {
     if (key) {
       init(proto);
       tag = storeKey || `${getTag(proto)}_${key}`;
-      setVar(proto, key);
-      regisHandler(proto, key, {
+      setStateVar(proto, key);
+      setHandler(proto, key, {
         init: (instance) => {
           return getProperty("storage")?.({
             instance,
@@ -464,8 +516,8 @@ function Storage({ key: storeKey, toJSON, toString } = {}) {
     } else {
       init(proto.prototype);
       tag = storeKey || getTag(proto);
-      setVar(proto.prototype, SHARE_KEY);
-      regisHandler(proto.prototype, SHARE_KEY, {
+      setStateVar(proto.prototype, SHARE_KEY);
+      setHandler(proto.prototype, SHARE_KEY, {
         init: (instance) => {
           return getProperty("storage")?.({
             instance,
@@ -494,7 +546,7 @@ export {
   Init,
   Inject,
   Isolate,
-  Nested,
+  PHECDA_KEY,
   Pipeline,
   Provide,
   SHARE_KEY,
@@ -506,29 +558,31 @@ export {
   Watcher,
   activeInstance,
   addDecoToClass,
-  classToValue,
+  classToPlain,
   getBind,
   getExposeKey,
   getHandler,
-  getModuleState,
   getOwnExposeKey,
   getOwnHandler,
   getOwnIgnoreKey,
-  getOwnModuleState,
   getOwnState,
+  getOwnStateVars,
   getProperty,
   getState,
-  getTag2 as getTag,
+  getStateVars,
+  getTag,
   init,
   injectProperty,
   invokeHandler,
+  isAsyncFunc,
   isPhecda,
   plainToClass,
-  regisHandler,
   setExposeKey,
+  setHandler,
   setIgnoreKey,
   setState,
-  setVar,
+  setStateVar,
   snapShot,
-  transformClass
+  transformClass,
+  transformProperty
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phecda-core",
-  "version": "3.0.0-alpha.10",
+  "version": "3.0.0-alpha.12",
   "description": "provide base function and abstract limit to other phecda module ",
   "main": "dist/index.js",
   "module": "dist/index.mjs",