phecda-core 1.6.0 → 2.0.0-alpha.0

package/dist/index.d.ts

@@ -12,6 +12,7 @@ interface PhecdaHandler {
     [key: string]: any;
 }
 interface Phecda {
+    prototype: any;
     _namespace: {
         __INIT_EVENT__: Set<PropertyKey>;
         __EXPOSE_VAR__: Set<PropertyKey>;
@@ -92,22 +93,26 @@ declare function Inject<K extends keyof PhecdaInjectData>(key: K): PhecdaInjectD
 
 declare function validate(p: RegExp | string | Function | Object | Number, v: any): Promise<any>;
 declare function getTag<M extends new (...args: any) => any>(Model: M): any;
-declare function mergeOptions(obj1: any, obj2?: any): any;
 
 declare function isPhecda(target: any): any;
 declare function init(target: Phecda): void;
 declare function regisInitEvent(target: Phecda, key: string): void;
-declare function getInitEvent(target: Phecda): string[];
-declare function setModalVar(target: Phecda, key: PropertyKey): void;
+declare function getOwnInitEvent(target: Phecda): string[];
+declare function getInitEvent(target: Phecda): PropertyKey[];
+declare function setModelVar(target: Phecda, key: PropertyKey): void;
 declare function setExposeKey(target: Phecda, key: PropertyKey): void;
 declare function setIgnoreKey(target: Phecda, key: PropertyKey): void;
-declare function getModelState(target: Phecda): string[];
-declare function getExposeKey(target: Phecda): string[];
-declare function getIgnoreKey(target: Phecda): string[];
+declare function getOwnModelState(target: Phecda): string[];
+declare function getModelState(target: Phecda): PropertyKey[];
+declare function getOwnExposeKey(target: Phecda): string[];
+declare function getExposeKey(target: Phecda): PropertyKey[];
+declare function getOwnIgnoreKey(target: Phecda): string[];
 declare function regisHandler(target: Phecda, key: PropertyKey, handler: PhecdaHandler): void;
-declare function getHandler(target: Phecda, key: PropertyKey): PhecdaHandler[];
-declare function mergeState(target: Phecda, key: PropertyKey, state: any): void;
-declare function getState(target: Phecda, key: PropertyKey): Object | undefined;
+declare function getOwnHandler(target: Phecda, key: PropertyKey): PhecdaHandler[];
+declare function getHandler(target: Phecda, key: PropertyKey): any[];
+declare function setState(target: Phecda, key: PropertyKey, state: Record<string, any>): void;
+declare function getOwnState(target: Phecda, key: PropertyKey): Object;
+declare function getState(target: Phecda, key: PropertyKey): any;
 declare function register(instance: Phecda): void;
 declare function registerAsync(instance: Phecda): Promise<void>;
 
@@ -118,6 +123,7 @@ declare function getProperty(key: string): any;
 declare function Watcher(eventName: keyof Events, options?: {
     once: boolean;
 }): (obj: any, key: string) => void;
+declare function Effect(eventName: string, options?: any): (obj: any, key: string) => void;
 declare function Storage(storeKey?: string): (target: any, key?: PropertyKey) => void;
 
-export { Assign, Bind, ClassValue, Clear, DataMap, Empty, Err, Events, Expose, Global, Ignore, Init, Inject, NameSpace, Phecda, PhecdaHandler, PhecdaInjectData, Pipe, Provide, Rule, Storage, Tag, UsePipeOptions, Watcher, activeInstance, addDecoToClass, classToValue, getBind, getExposeKey, getHandler, getIgnoreKey, getInitEvent, getModelState, getProperty, getState, getTag, init, injectProperty, isPhecda, mergeOptions, mergeState, plainToClass, regisHandler, regisInitEvent, register, registerAsync, setExposeKey, setIgnoreKey, setModalVar, snapShot, to, validate };
+export { Assign, Bind, ClassValue, Clear, DataMap, Effect, Empty, Err, Events, Expose, Global, Ignore, Init, Inject, NameSpace, Phecda, PhecdaHandler, PhecdaInjectData, Pipe, Provide, Rule, Storage, Tag, UsePipeOptions, Watcher, activeInstance, addDecoToClass, classToValue, getBind, getExposeKey, getHandler, getInitEvent, getModelState, getOwnExposeKey, getOwnHandler, getOwnIgnoreKey, getOwnInitEvent, getOwnModelState, getOwnState, getProperty, getState, getTag, init, injectProperty, isPhecda, plainToClass, regisHandler, regisInitEvent, register, registerAsync, setExposeKey, setIgnoreKey, setModelVar, setState, snapShot, to, validate };

package/dist/index.global.js

@@ -26,6 +26,7 @@ var Phecda = (() => {
     Bind: () => Bind,
     Clear: () => Clear,
     DataMap: () => DataMap,
+    Effect: () => Effect,
     Empty: () => Empty,
     Err: () => Err,
     Expose: () => Expose,
@@ -45,17 +46,20 @@ var Phecda = (() => {
     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,
@@ -63,58 +67,22 @@ var Phecda = (() => {
     registerAsync: () => registerAsync,
     setExposeKey: () => setExposeKey,
     setIgnoreKey: () => setIgnoreKey,
-    setModalVar: () => setModalVar,
+    setModelVar: () => setModelVar,
+    setState: () => setState,
     snapShot: () => snapShot,
     to: () => to,
     validate: () => validate
   });
 
-  // 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 @@ var Phecda = (() => {
     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 @@ var Phecda = (() => {
     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 @@ var Phecda = (() => {
       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 @@ var Phecda = (() => {
 
   // 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 @@ var Phecda = (() => {
   __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 @@ var Phecda = (() => {
   __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 @@ var Phecda = (() => {
   __name(Clear, "Clear");
   function Err(cb) {
     return (target, key) => {
-      setModalVar(target, key);
+      setModelVar(target, key);
       regisHandler(target, key, {
         error: cb
       });
@@ -281,7 +315,7 @@ var Phecda = (() => {
   __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 @@ var Phecda = (() => {
   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 @@ var Phecda = (() => {
   }
   __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 @@ var Phecda = (() => {
   __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 @@ var Phecda = (() => {
   // 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 @@ var Phecda = (() => {
     };
   }
   __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 @@ var Phecda = (() => {
         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 @@ var Phecda = (() => {
         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")?.({