phecda-core 1.6.0 → 2.0.0-alpha.0

package/dist/index.js

@@ -25,6 +25,7 @@ __export(src_exports, {
   Bind: () => Bind,
   Clear: () => Clear,
   DataMap: () => DataMap,
+  Effect: () => Effect,
   Empty: () => Empty,
   Err: () => Err,
   Expose: () => Expose,
@@ -44,17 +45,20 @@ __export(src_exports, {
   getBind: () => getBind,
   getExposeKey: () => getExposeKey,
   getHandler: () => getHandler,
-  getIgnoreKey: () => getIgnoreKey,
   getInitEvent: () => getInitEvent,
   getModelState: () => getModelState,
+  getOwnExposeKey: () => getOwnExposeKey,
+  getOwnHandler: () => getOwnHandler,
+  getOwnIgnoreKey: () => getOwnIgnoreKey,
+  getOwnInitEvent: () => getOwnInitEvent,
+  getOwnModelState: () => getOwnModelState,
+  getOwnState: () => getOwnState,
   getProperty: () => getProperty,
   getState: () => getState,
   getTag: () => getTag,
   init: () => init,
   injectProperty: () => injectProperty,
   isPhecda: () => isPhecda,
-  mergeOptions: () => mergeOptions,
-  mergeState: () => mergeState,
   plainToClass: () => plainToClass,
   regisHandler: () => regisHandler,
   regisInitEvent: () => regisInitEvent,
@@ -62,59 +66,23 @@ __export(src_exports, {
   registerAsync: () => registerAsync,
   setExposeKey: () => setExposeKey,
   setIgnoreKey: () => setIgnoreKey,
-  setModalVar: () => setModalVar,
+  setModelVar: () => setModelVar,
+  setState: () => setState,
   snapShot: () => snapShot,
   to: () => to,
   validate: () => validate
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/utils.ts
-async function validate(p, v) {
-  if (typeof p === "string" || typeof p === "number") {
-    if (v === p)
-      return true;
-  }
-  if (typeof p === "function")
-    return p(v);
-  if (p instanceof RegExp)
-    return p.test(v);
-  return false;
-}
-__name(validate, "validate");
-function getTag(Model) {
-  return Model.prototype?.__TAG__;
-}
-__name(getTag, "getTag");
-function mergeOptions(obj1, obj2) {
-  if (!obj2)
-    return obj1;
-  for (const i in obj2) {
-    if (isObject(obj1[i]) && isObject(obj2[i])) {
-      mergeOptions(obj1[i], obj2[i]);
-      continue;
-    }
-    if (Array.isArray(obj1[i]) && Array.isArray(obj2[i])) {
-      obj1[i].push(...obj2[i].filter((item) => !obj1[i].includes(item)));
-      continue;
-    }
-    obj1[i] = obj2[i];
-  }
-  return obj1;
-}
-__name(mergeOptions, "mergeOptions");
-function isObject(obj) {
-  return Object.prototype.toString.call(obj) === "[object Object]";
-}
-__name(isObject, "isObject");
-
 // src/core.ts
 function isPhecda(target) {
   return target && !!target.prototype._namespace;
 }
 __name(isPhecda, "isPhecda");
 function init(target) {
-  if (!target._namespace) {
+  if (!target)
+    return;
+  if (!target.hasOwnProperty("_namespace")) {
     target._namespace = {
       __INIT_EVENT__: /* @__PURE__ */ new Set(),
       __EXPOSE_VAR__: /* @__PURE__ */ new Set(),
@@ -131,19 +99,32 @@ function regisInitEvent(target, key) {
   target._namespace.__INIT_EVENT__.add(key);
 }
 __name(regisInitEvent, "regisInitEvent");
-function getInitEvent(target) {
-  init(target);
+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
+  ];
+}
 __name(getInitEvent, "getInitEvent");
-function setModalVar(target, key) {
+function setModelVar(target, key) {
   init(target);
   target._namespace.__STATE_VAR__.add(key);
   setExposeKey(target, key);
 }
-__name(setModalVar, "setModalVar");
+__name(setModelVar, "setModelVar");
 function setExposeKey(target, key) {
   init(target);
   target._namespace.__EXPOSE_VAR__.add(key);
@@ -154,27 +135,54 @@ function setIgnoreKey(target, key) {
   target._namespace.__IGNORE_VAR__.add(key);
 }
 __name(setIgnoreKey, "setIgnoreKey");
-function getModelState(target) {
-  init(target);
+function getOwnModelState(target) {
+  target = Object.getPrototypeOf(target);
   return [
     ...target._namespace.__STATE_VAR__
   ];
 }
+__name(getOwnModelState, "getOwnModelState");
+function getModelState(target) {
+  let proto = Object.getPrototypeOf(target);
+  const set = /* @__PURE__ */ new Set();
+  while (proto?._namespace) {
+    proto._namespace.__STATE_VAR__.forEach((item) => set.add(item));
+    proto = Object.getPrototypeOf(proto);
+  }
+  return [
+    ...set
+  ];
+}
 __name(getModelState, "getModelState");
-function getExposeKey(target) {
-  init(target);
+function getOwnExposeKey(target) {
+  target = Object.getPrototypeOf(target);
   return [
     ...target._namespace.__EXPOSE_VAR__
   ].filter((item) => !target._namespace.__IGNORE_VAR__.has(item));
 }
+__name(getOwnExposeKey, "getOwnExposeKey");
+function getExposeKey(target) {
+  let proto = Object.getPrototypeOf(target);
+  const set = /* @__PURE__ */ new Set();
+  while (proto?._namespace) {
+    [
+      ...proto._namespace.__EXPOSE_VAR__
+    ].forEach((item) => !proto._namespace.__IGNORE_VAR__.has(item) && set.add(item));
+    proto = Object.getPrototypeOf(proto);
+  }
+  return [
+    ...set
+  ];
+}
 __name(getExposeKey, "getExposeKey");
-function getIgnoreKey(target) {
-  init(target);
+function getOwnIgnoreKey(target) {
+  if (!target?._namespace)
+    return [];
   return [
     ...target._namespace.__IGNORE_VAR__
   ];
 }
-__name(getIgnoreKey, "getIgnoreKey");
+__name(getOwnIgnoreKey, "getOwnIgnoreKey");
 function regisHandler(target, key, handler) {
   init(target);
   if (!target._namespace.__STATE_HANDLER__.has(key))
@@ -185,22 +193,48 @@ function regisHandler(target, key, handler) {
     target._namespace.__STATE_HANDLER__.get(key).push(handler);
 }
 __name(regisHandler, "regisHandler");
-function getHandler(target, key) {
+function getOwnHandler(target, key) {
+  if (!target?._namespace)
+    return [];
   return target._namespace.__STATE_HANDLER__.get(key) || [];
 }
+__name(getOwnHandler, "getOwnHandler");
+function getHandler(target, key) {
+  let proto = Object.getPrototypeOf(target);
+  const set = /* @__PURE__ */ new Set();
+  while (proto?._namespace) {
+    proto._namespace.__STATE_HANDLER__.get(key)?.forEach((item) => set.add(item));
+    proto = Object.getPrototypeOf(proto);
+  }
+  return [
+    ...set
+  ];
+}
 __name(getHandler, "getHandler");
-function mergeState(target, key, state) {
+function setState(target, key, state) {
+  init(target);
   const namespace = target._namespace.__STATE_NAMESPACE__;
-  if (!namespace.has(key))
-    namespace.set(key, state);
-  else
-    mergeOptions(namespace.get(key), state);
+  namespace.set(key, state);
 }
-__name(mergeState, "mergeState");
+__name(setState, "setState");
+function getOwnState(target, key) {
+  target = Object.getPrototypeOf(target);
+  return target._namespace.__STATE_NAMESPACE__.get(key) || {};
+}
+__name(getOwnState, "getOwnState");
 function getState(target, key) {
-  const namespace = target._namespace.__STATE_NAMESPACE__;
-  if (namespace)
-    return namespace.get(key);
+  let proto = Object.getPrototypeOf(target);
+  let ret = {};
+  while (proto?._namespace) {
+    const state = proto._namespace.__STATE_NAMESPACE__.get(key);
+    if (state)
+      ret = {
+        ...state,
+        ...ret
+      };
+    proto = Object.getPrototypeOf(proto);
+  }
+  return ret;
 }
 __name(getState, "getState");
 function register(instance) {
@@ -224,7 +258,7 @@ __name(registerAsync, "registerAsync");
 
 // src/decorators.ts
 function Init(target, key) {
-  setModalVar(target, key);
+  setModelVar(target, key);
   regisHandler(target, key, {
     async init(instance) {
       instance[key]();
@@ -234,8 +268,8 @@ function Init(target, key) {
 __name(Init, "Init");
 function Bind(value) {
   return (target, k) => {
-    setModalVar(target, k);
-    mergeState(target, k, {
+    setModelVar(target, k);
+    setState(target, k, {
       value
     });
   };
@@ -243,7 +277,7 @@ function Bind(value) {
 __name(Bind, "Bind");
 function Rule(rule, info, meta) {
   return (obj, key) => {
-    setModalVar(obj, key);
+    setModelVar(obj, key);
     regisHandler(obj, key, {
       rule,
       info,
@@ -268,7 +302,7 @@ function Clear(target, key) {
 __name(Clear, "Clear");
 function Err(cb) {
   return (target, key) => {
-    setModalVar(target, key);
+    setModelVar(target, key);
     regisHandler(target, key, {
       error: cb
     });
@@ -281,7 +315,7 @@ function Expose(target, key) {
 __name(Expose, "Expose");
 function Pipe(v) {
   return (obj, key) => {
-    setModalVar(obj, key);
+    setModelVar(obj, key);
     regisHandler(obj, key, {
       async pipe(instance) {
         const tasks = v.value;
@@ -301,7 +335,7 @@ __name(Tag, "Tag");
 function Assign(cb) {
   return (target) => {
     init(target.prototype);
-    setModalVar(target.prototype, "__CLASS");
+    setModelVar(target.prototype, "__CLASS");
     regisHandler(target.prototype, "__CLASS", {
       init: async (instance) => {
         const value = await cb(instance);
@@ -335,6 +369,24 @@ function Inject(key) {
 }
 __name(Inject, "Inject");
 
+// src/utils.ts
+async function validate(p, v) {
+  if (typeof p === "string" || typeof p === "number") {
+    if (v === p)
+      return true;
+  }
+  if (typeof p === "function")
+    return p(v);
+  if (p instanceof RegExp)
+    return p.test(v);
+  return false;
+}
+__name(validate, "validate");
+function getTag(Model) {
+  return Model.prototype?.__TAG__;
+}
+__name(getTag, "getTag");
+
 // src/helper.ts
 function getBind(Model) {
   const instance = new Model();
@@ -385,8 +437,8 @@ async function plainToClass(Model, input, options = {}) {
 __name(plainToClass, "plainToClass");
 function classToValue(instance) {
   const data = {};
-  const exposeVar = getExposeKey(instance);
-  for (const item of exposeVar)
+  const exposeVars = getExposeKey(instance);
+  for (const item of exposeVars)
     data[item] = instance[item];
   return data;
 }
@@ -437,7 +489,7 @@ __name(getProperty, "getProperty");
 // src/custom/decorator.ts
 function Watcher(eventName, options) {
   return (obj, key) => {
-    setModalVar(obj, key);
+    setModelVar(obj, key);
     regisHandler(obj, key, {
       init(instance) {
         getProperty("watcher")?.({
@@ -451,6 +503,32 @@ function Watcher(eventName, options) {
   };
 }
 __name(Watcher, "Watcher");
+function Effect(eventName, options) {
+  return (obj, key) => {
+    setModelVar(obj, key);
+    regisHandler(obj, key, {
+      init(instance) {
+        instance[`$_${key}`] = instance[key];
+        Object.defineProperty(instance, key, {
+          get() {
+            return instance[`$_${key}`];
+          },
+          set(v) {
+            instance[`$_${key}`] = v;
+            getProperty(`effect-${eventName}`)?.({
+              instance,
+              key,
+              value: v,
+              options
+            });
+            return true;
+          }
+        });
+      }
+    });
+  };
+}
+__name(Effect, "Effect");
 function Storage(storeKey) {
   return (target, key) => {
     let tag;
@@ -458,7 +536,7 @@ function Storage(storeKey) {
       init(target);
       tag = storeKey || target.__TAG__;
       const uniTag = Symbol(tag);
-      setModalVar(target, uniTag);
+      setModelVar(target, uniTag);
       regisHandler(target, uniTag, {
         init: (instance) => {
           getProperty("storage")?.({
@@ -472,7 +550,7 @@ function Storage(storeKey) {
       init(target.prototype);
       tag = storeKey || `${target.prototype.__TAG__}_${key}`;
       const uniTag = Symbol(tag);
-      setModalVar(target.prototype, uniTag);
+      setModelVar(target.prototype, uniTag);
       regisHandler(target.prototype, uniTag, {
         init: (instance) => {
           getProperty("storage")?.({
@@ -492,6 +570,7 @@ __name(Storage, "Storage");
   Bind,
   Clear,
   DataMap,
+  Effect,
   Empty,
   Err,
   Expose,
@@ -511,17 +590,20 @@ __name(Storage, "Storage");
   getBind,
   getExposeKey,
   getHandler,
-  getIgnoreKey,
   getInitEvent,
   getModelState,
+  getOwnExposeKey,
+  getOwnHandler,
+  getOwnIgnoreKey,
+  getOwnInitEvent,
+  getOwnModelState,
+  getOwnState,
   getProperty,
   getState,
   getTag,
   init,
   injectProperty,
   isPhecda,
-  mergeOptions,
-  mergeState,
   plainToClass,
   regisHandler,
   regisInitEvent,
@@ -529,7 +611,8 @@ __name(Storage, "Storage");
   registerAsync,
   setExposeKey,
   setIgnoreKey,
-  setModalVar,
+  setModelVar,
+  setState,
   snapShot,
   to,
   validate