feature afterEffects

.husky/pre-commit

@@ -1,4 +1,4 @@
 #!/usr/bin/env sh
 . "$(dirname -- "$0")/_/husky.sh"
 
-yarn lint-staged
+#yarn lint-staged

packages/core-v1/index.ts

@@ -2,8 +2,8 @@
 export {Slice} from './lib/Slice';
 export {Bite} from './lib/Bite';
 export {Script} from './lib/Script';
+export {EffectiveScript} from './lib/interfaces/EffectiveScript';
 export {useSystem, type System} from './lib/System';
-export {configureRoot} from './lib/configureRoot';
 export {getTriggerAndStatus, getActionType} from './lib/utils';
 export type {
   UpdateOnType,

packages/core-v1/lib/AfterEffects.ts

@@ -0,0 +1,95 @@
+import { getTriggerAndStatus } from "./utils";
+import { UpdateOnType } from "./types";
+
+/**
+ * 
+ * key object (__ISALL__: boolean)
+ * other keys are statuses from array
+ * value of status keys or __ISALL__ key are biteNames array (to which trigger __afterEffects__ event)
+ */
+
+/*
+** 
+*/
+
+export class AfterEffects {
+    private finalMap: any = {};
+    private removeCheckMap: any = {};
+    constructor(private getCurrentTask: () => {type: string, payload: string}) {}
+
+    public handleAfterEffect = (dispather: (action) => void) => {
+        const currentTask = this.getCurrentTask();
+        const dispatchPayload = currentTask;
+        if(currentTask) {
+            const {trigger, status} = getTriggerAndStatus(currentTask.type);
+            if(this.finalMap[trigger]) {
+                for( let key in this.finalMap[trigger]) {
+                    if(this.finalMap[trigger][key] === '_ALLSTATUSES_') {
+                        setTimeout(()=> {
+                            dispather({
+                                type: `${key}/__AFTEREFFECTS__`,
+                                payload: dispatchPayload
+                            })
+                        })
+                    }
+                    else if(this.finalMap[trigger][key] === status ) {
+                        setTimeout(()=> {
+                            dispather({
+                                type: `${key}/__AFTEREFFECTS__`,
+                                payload: dispatchPayload
+                            })})
+                    }
+                    else if(this.finalMap[trigger][key].includes(status)) {
+                        setTimeout(() => {
+                            dispather({
+                                type: `${key}/__AFTEREFFECTS__`,
+                                payload: dispatchPayload
+                            })
+                        })  
+                    }
+                }
+            }
+            //TODO
+        }
+        //check if current task has after effects
+        //if is => dispatch after effects
+
+    }   
+
+    public removeAfterEffect = (biteName:string) => {
+        if(this.removeCheckMap[biteName]) {
+            for(let r of this.removeCheckMap[biteName]) {
+                if(typeof r === 'string') {
+                    delete this.finalMap[r][biteName]
+                }
+                else {
+                    const objectkey = Object.keys(r)[0];
+                    delete this.finalMap[objectkey][biteName]
+                }
+            }
+        }
+        delete this.removeCheckMap[biteName]
+    }
+
+    public  addAfterEffect = <Tr>(updateOn: UpdateOnType<Tr>, biteName: string) => {
+
+        //add to remove map array
+        this.removeCheckMap[biteName] = updateOn;
+        for (let uo of updateOn) {  
+            if(!this.finalMap[uo]) {
+                this.finalMap[uo] = {}
+            }
+            if(typeof uo === 'string') {
+                this.finalMap[uo][biteName] = '_ALLSTATUSES_'
+            }
+            else {
+                const objectkey = Object.keys(uo)[0];
+                const objectValues = uo[objectkey];
+                this.finalMap[objectkey][biteName] = objectValues;
+            }
+        }
+        console.log(this.finalMap);
+        console.log(this.removeCheckMap);
+
+    }
+}

packages/core-v1/lib/System.ts

@@ -1,5 +1,6 @@
-import {TaskQueue} from './TaskQueue';
-import type {SystemConfig} from './types';
+import { AfterEffects } from "./AfterEffects";
+import { TaskQueue } from "./TaskQueue";
+import { SystemConfig } from "./types";
 
 interface ProcessorOpts {
   propagate: boolean;
@@ -19,16 +20,19 @@ export class System {
   };
 
   public taksQueue: TaskQueue;
+  public afterEffects: AfterEffects;
 
   constructor() {
-    this.taksQueue = new TaskQueue();
+      this.taksQueue = new TaskQueue()
+      this.afterEffects = new AfterEffects(() => this.taksQueue.getCurrentTask())
   }
 
   public setConfig(conf: SystemConfig) {
     this.config = conf;
   }
 
-  public afterHandlers: Array<any> = [];
+
+  //public afterHandlers: Array<any> = []
 
   public context: {[triggerer: string]: any} = {};
 

packages/core-v1/lib/createMiddleware.ts

@@ -8,6 +8,8 @@ import {matchInitTrigger} from './processor/matchInitTrigger';
 import {matchUpdateTrigger} from './processor/matchUpdateTrigger';
 import {prepareOpts} from './processor/prepareInstanceOpts';
 import {useSystem} from './System';
+import { AfterEffects } from './processor/lifecycle/AfterEffects';
+import { getTriggerAndStatus } from './utils';
 
 export const makeProcMiddleware = (
   configs,
@@ -35,11 +37,11 @@ export const makeProcMiddleware = (
 
     if (instance) {
       onInit(instance, actionPayload);
+      if(instance.afterEffects) {
+        system.afterEffects.addAfterEffect(initConfig.config.watchScope, initConfig.trigger)
+      }
     }
 
-    if (instance?.watchAfter) {
-      system.afterHandlers.push(() => instance.watchAfter);
-    }
   };
 
   const handleUpdate = (store, action, skipUpdate) => {
@@ -79,6 +81,7 @@ export const makeProcMiddleware = (
       opts,
     } = action;
     const isBiteHit = matchBiteName(configs, actionType);
+    const { trigger, status } = getTriggerAndStatus(actionType);
     const ignore =
       sliceConfig?.ignoreExternal &&
       (sliceConfig.ignoreExternal === 'ignoreAll' ||
@@ -92,7 +95,17 @@ export const makeProcMiddleware = (
 
     handleInit(store, actionType, actionPayload, opts?.noInit);
 
-    const forceStopPropagate = handleUpdate(store, action, opts?.noUpdate);
+    let  forceStopPropagate = handleUpdate(store, action, opts?.noUpdate);
+
+    if(status === '__AFTEREFFECTS__' && isBiteHit) {
+      forceStopPropagate  = true;
+      const afInstances = getInstance(configs[trigger], trigger, system);
+      if(afInstances) {
+        afInstances.forEach( afi => 
+          AfterEffects(afi, action, sliceName)
+        )
+      }
+    }
     const processorOpts = system.getProcessorInfo(action.type);
 
     system.resolveWait(action.type, actionPayload);

packages/core-v1/lib/interfaces/EffectiveScript.ts

@@ -0,0 +1,19 @@
+import { WatchArgsType,ScriptOptsType, InitArgsType, TriggerPhaseKeys} from "../types";
+
+
+export abstract class EffectiveScript<RTg, RSt, Bitename extends keyof RTg, PhK extends TriggerPhaseKeys<RTg, Bitename>, Inj=unknown> {
+
+    constructor (opts) {
+        this.opts = opts
+    }    
+
+    protected opts: ScriptOptsType<RTg, RSt, Bitename, Inj>;
+
+    abstract watch?(args: WatchArgsType<RTg, Bitename>): void
+
+    abstract afterEffects?(args: WatchArgsType<RTg, Bitename>): void
+
+    abstract init(args: InitArgsType<RTg, Bitename, PhK>): void
+
+
+}

packages/core-v1/lib/processor/createProcessorInstance.ts

@@ -63,3 +63,32 @@ function refreshingMode(system, config, opt, actionType) {
 
   return newInstance; //.init(actionPayload);
 }
+
+///on init instance  => add to system configure {trigger => []}
+///on drop instance => remove from system's map
+// for s of config.config.watchScope,  
+// s.
+//
+/**
+ * store.subscribe(() => {
+ *    /// call for check => 
+ *    const currentTask = system.taskQueue.currentTask
+ *    const afterEffectsMap = system.afterEffectsMap
+ *    if(match(currentTask, afterEffectsMap)) {
+ *      store.dispatch({
+ *          type: biteName/__AFTER_EFFECTS__, 
+ *          payload: {
+ *            taskTrigger: 
+ *            taskStatus:
+ *            taskPayload:
+ *            taskSourceBite:
+ *            taskSourceSlice:
+ *          }
+ *      })
+ *    }
+ * })
+ * 
+ * 
+ * 
+ * 
+ */

packages/core-v1/lib/processor/lifecycle/AfterEffects.ts

@@ -0,0 +1,20 @@
+import { getTriggerAndStatus } from "../../utils";
+
+export function AfterEffects (instance, action, sliceName) {
+    const actionPayload = action.payload;
+    const effectType = actionPayload.type;
+    const effectPayload = actionPayload.payload;
+    if(instance.afterEffects) {
+        const { trigger, status } = getTriggerAndStatus(effectType);
+        const afterEffectsArgs = {
+            payload: effectPayload,
+            trigger,
+            status,
+            source: action.source,
+            sourceSlice: sliceName,
+          };
+          instance.afterEffects(afterEffectsArgs)
+
+    }
+
+}

packages/core-v1/lib/processor/opts/drop.ts

@@ -4,6 +4,7 @@ export function Drop(system, config) {
   const actionType = getActionType(config.trigger, config.config.initOn);
 
   return () => {
+    system.afterEffects.removeAfterEffect(config.trigger)
     system.downProcess(actionType);
   };
-}
+}

packages/core-v1/lib/processor/opts/setState.ts

@@ -0,0 +1,20 @@
+import { getActionType } from '../../utils';
+
+export function SetState(store, config, system, uid, sourceSlice) {
+
+  return (status, args) => {
+    const process = system.findProcessByUid(uid);
+    if (process.length) {
+        store.dispatch({
+          type: getActionType(config.trigger, status),
+          payload: args,
+          source: `${config.trigger}:${uid}`,
+          sourceSlice,
+          opts: {
+            noInit: true,
+            noUpdate: true,
+          },
+      });
+    }
+  };
+}

packages/core-v1/lib/processor/opts/setStateNoEffect.ts

@@ -0,0 +1,22 @@
+
+import { getActionType } from '../../utils';
+
+export function SetStateNoEffect(store, config, system, uid, sourceSlice) {
+
+  return (status, args) => {
+    const process = system.findProcessByUid(uid);
+    if (process.length) {
+        store.dispatch({
+          type: getActionType(config.trigger, status),
+          payload: args,
+          source: `${config.trigger}:${uid}`,
+          sourceSlice,
+          opts: {
+            notEffect: true,
+            noInit: true,
+            noUpdate: true,
+          },
+      });
+    }
+  };
+}

packages/core-v1/lib/processor/prepareInstanceOpts.ts

@@ -2,20 +2,23 @@ import {v4} from 'uuid';
 import {Drop} from './opts/drop';
 import {SetStatus} from './opts/setStatus';
 import {Trigger} from './opts/trigger';
-
+//
 // import { Save } from './opts/save';
 // import { TriggerOnly } from './opts/triggerOnly';
-import {Wait} from './opts/wait';
-import {Hook} from './opts/hook';
-import {Bind} from './opts/bind';
+import { Wait } from './opts/wait';
+import { Hook } from './opts/hook';
+import { Bind } from './opts/bind';
+import { SetStateNoEffect } from './opts/setStateNoEffect';
+import { SetState } from './opts/setState';
 
 export function prepareOpts(config, store, system, sliceName, injected) {
   const processUid = v4();
   const trigger = Trigger(store, config, system, processUid, sliceName);
 
   const setStatus = SetStatus(store, config, system, processUid, sliceName);
   //const save = Save(store, config, system, processUid);
-  //const triggerOnly = TriggerOnly(store, config, system, processUid);
+  const setStateNoEffect = SetStateNoEffect(store, config, system, processUid, sliceName);
+  const setState = SetState(store, config, system, processUid, sliceName);
   const drop = Drop(system, config);
   //const state = store.getState();
   const getCurrentState = store.getState;
@@ -39,6 +42,8 @@ export function prepareOpts(config, store, system, sliceName, injected) {
     injected,
     addOpts: config.config.addOpts,
     bind,
+    setState,
+    setStateNoEffect,
     catchStatus: (status, args) => {
       if (status === args.status && config.trigger === args.trigger) {
         return {