phecda-core 1.6.0 → 2.0.0-alpha.0

package/dist/index.mjs

@@ -1,52 +1,15 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
-// 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(),
@@ -63,19 +26,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);
@@ -86,27 +62,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))
@@ -117,22 +120,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) {
@@ -156,7 +185,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]();
@@ -166,8 +195,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
     });
   };
@@ -175,7 +204,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,
@@ -200,7 +229,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
     });
@@ -213,7 +242,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;
@@ -233,7 +262,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);
@@ -267,6 +296,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();
@@ -317,8 +364,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;
 }
@@ -369,7 +416,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")?.({
@@ -383,6 +430,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;
@@ -390,7 +463,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")?.({
@@ -404,7 +477,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")?.({
@@ -423,6 +496,7 @@ export {
   Bind,
   Clear,
   DataMap,
+  Effect,
   Empty,
   Err,
   Expose,
@@ -442,17 +516,20 @@ export {
   getBind,
   getExposeKey,
   getHandler,
-  getIgnoreKey,
   getInitEvent,
   getModelState,
+  getOwnExposeKey,
+  getOwnHandler,
+  getOwnIgnoreKey,
+  getOwnInitEvent,
+  getOwnModelState,
+  getOwnState,
   getProperty,
   getState,
   getTag,
   init,
   injectProperty,
   isPhecda,
-  mergeOptions,
-  mergeState,
   plainToClass,
   regisHandler,
   regisInitEvent,
@@ -460,7 +537,8 @@ export {
   registerAsync,
   setExposeKey,
   setIgnoreKey,
-  setModalVar,
+  setModelVar,
+  setState,
   snapShot,
   to,
   validate

package/dist/preset/index.global.js

@@ -43,7 +43,9 @@ var Phecda = (() => {
 
   // src/core.ts
   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(),
@@ -55,12 +57,12 @@ var Phecda = (() => {
     }
   }
   __name(init, "init");
-  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);
@@ -80,7 +82,7 @@ var Phecda = (() => {
   // src/decorators.ts
   function Rule(rule, info, meta) {
     return (obj, key) => {
-      setModalVar(obj, key);
+      setModelVar(obj, key);
       regisHandler(obj, key, {
         rule,
         info,
@@ -91,7 +93,7 @@ var Phecda = (() => {
   __name(Rule, "Rule");
   function Pipe(v) {
     return (obj, key) => {
-      setModalVar(obj, key);
+      setModelVar(obj, key);
       regisHandler(obj, key, {
         async pipe(instance) {
           const tasks = v.value;

package/dist/preset/index.js

@@ -43,7 +43,9 @@ module.exports = __toCommonJS(preset_exports);
 
 // src/core.ts
 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(),
@@ -55,12 +57,12 @@ function init(target) {
   }
 }
 __name(init, "init");
-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);
@@ -80,7 +82,7 @@ __name(regisHandler, "regisHandler");
 // src/decorators.ts
 function Rule(rule, info, meta) {
   return (obj, key) => {
-    setModalVar(obj, key);
+    setModelVar(obj, key);
     regisHandler(obj, key, {
       rule,
       info,
@@ -91,7 +93,7 @@ function Rule(rule, info, meta) {
 __name(Rule, "Rule");
 function Pipe(v) {
   return (obj, key) => {
-    setModalVar(obj, key);
+    setModelVar(obj, key);
     regisHandler(obj, key, {
       async pipe(instance) {
         const tasks = v.value;

package/dist/preset/index.mjs

@@ -3,7 +3,9 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 
 // src/core.ts
 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(),
@@ -15,12 +17,12 @@ function init(target) {
   }
 }
 __name(init, "init");
-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);
@@ -40,7 +42,7 @@ __name(regisHandler, "regisHandler");
 // src/decorators.ts
 function Rule(rule, info, meta) {
   return (obj, key) => {
-    setModalVar(obj, key);
+    setModelVar(obj, key);
     regisHandler(obj, key, {
       rule,
       info,
@@ -51,7 +53,7 @@ function Rule(rule, info, meta) {
 __name(Rule, "Rule");
 function Pipe(v) {
   return (obj, key) => {
-    setModalVar(obj, key);
+    setModelVar(obj, key);
     regisHandler(obj, key, {
       async pipe(instance) {
         const tasks = v.value;

package/package.json

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