fix(core): update

ts/taskbuffer.classes.task.ts

@@ -1,29 +1,142 @@
 import * as plugins from './taskbuffer.plugins';
 import * as helpers from './taskbuffer.classes.helpers';
+import { BufferRunner } from './taskbuffer.classes.bufferrunner';
+import { CycleCounter } from './taskbuffer.classes.cyclecounter';
 
 export interface ITaskFunction {
   (x?: any): PromiseLike<any>;
 }
 
-export class Task {
-  // man datory properties
-  name: string;
-  taskFunction: ITaskFunction;
-  buffered: boolean;
+export type TPreOrAfterTaskFunction = () => Task;
 
-  bufferMax: number;
-  execDelay: number;
+export class Task {
+  // STATIC
+  public static extractTask(preOrAfterTaskArg: Task | TPreOrAfterTaskFunction): Task {
+    switch(true) {
+      case (!preOrAfterTaskArg):
+        return null;
+      case (preOrAfterTaskArg instanceof Task):
+        return preOrAfterTaskArg as Task;
+      case typeof preOrAfterTaskArg === "function":
+        const taskFunction = preOrAfterTaskArg as TPreOrAfterTaskFunction;
+        return taskFunction();
+      default:
+        return null;
+    }
+  }
+
+
+  public static emptyTaskFunction: ITaskFunction = function(x) {
+    const done = plugins.smartpromise.defer();
+    done.resolve();
+    return done.promise;
+  };
+  
+  public static isTask = (taskArg: Task): boolean => {
+    if (taskArg instanceof Task && typeof taskArg.taskFunction === 'function') {
+      return true;
+    } else {
+      return false;
+    }
+  };
+  
+  public static isTaskTouched = (taskArg: Task | TPreOrAfterTaskFunction, touchedTasksArray: Task[]): boolean => {
+    const taskToCheck = Task.extractTask(taskArg);
+    let result = false;
+    for (const keyArg in touchedTasksArray) {
+      if (taskToCheck === touchedTasksArray[keyArg]) {
+        result = true;
+      }
+    }
+    return result;
+  };
+  
+  public static runTask = async (taskArg: Task | TPreOrAfterTaskFunction, optionsArg: { x?; touchedTasksArray?: Task[] }) => {
+    const taskToRun = Task.extractTask(taskArg);
+    const done = plugins.smartpromise.defer();
+  
+    // pay respect to execDelay
+    if (taskToRun.execDelay) {
+      await plugins.smartdelay.delayFor(taskToRun.execDelay);
+    }
+  
+    //  set running params
+    taskToRun.running = true;
+  
+    done.promise.then(async () => {
+      taskToRun.running = false;
+    });
+  
+    // handle options
+    const options = {
+      ...{ x: undefined, touchedTasksArray: [] },
+      ...optionsArg
+    };
+    const x = options.x;
+    const touchedTasksArray: Task[] = options.touchedTasksArray;
+  
+    touchedTasksArray.push(taskToRun);
+  
+    // run the task cascade
+    const localDeferred = plugins.smartpromise.defer();
+    localDeferred.promise
+      .then(() => {
+        // lets run any preTask
+        
+        if (taskToRun.preTask && !Task.isTaskTouched(taskToRun.preTask, touchedTasksArray)) {
+          return Task.runTask(taskToRun.preTask, { x, touchedTasksArray });
+        } else {
+          const done2 = plugins.smartpromise.defer();
+          done2.resolve(x);
+          return done2.promise;
+        }
+      })
+      .then(async x => {
+        // lets run the main task
+        try {
+          return await taskToRun.taskFunction(x);
+        } catch (e) {
+          console.log(e);
+        }
+      })
+      .then(x => {
+        if (taskToRun.afterTask && !Task.isTaskTouched(taskToRun.afterTask, touchedTasksArray)) {
+          return Task.runTask(taskToRun.afterTask, { x: x, touchedTasksArray: touchedTasksArray });
+        } else {
+          const done2 = plugins.smartpromise.defer();
+          done2.resolve(x);
+          return done2.promise;
+        }
+      })
+      .then(x => {
+        done.resolve(x);
+      })
+      .catch(err => {
+        console.log(err);
+      });
+    localDeferred.resolve();
+    return await done.promise;
+  }
+
+  // INSTANCE
+  // man datory properties
+  public name: string;
+  public taskFunction: ITaskFunction;
+  public buffered: boolean;
+
+  public bufferMax: number;
+  public execDelay: number;
 
   // tasks to run before and after
-  preTask: Task;
-  afterTask: Task;
+  public preTask: Task | TPreOrAfterTaskFunction;
+  public afterTask: Task | TPreOrAfterTaskFunction;
 
   // initialize by default
-  running: boolean = false;
-  bufferRunner = new helpers.BufferRunner(this);
-  cycleCounter = new helpers.CycleCounter(this);
+  public running: boolean = false;
+  public bufferRunner = new BufferRunner(this);
+  public cycleCounter = new CycleCounter(this);
 
-  idle: boolean = true;
+  public idle: boolean = true;
   private _state: string = 'ready';
 
   constructor(optionsArg: {
@@ -34,11 +147,11 @@ export class Task {
     /**
      * any other task to run before
      */
-    preTask?: Task;
+    preTask?: Task | TPreOrAfterTaskFunction;
     /**
      * any other task to run after
      */
-    afterTask?: Task;
+    afterTask?: Task | TPreOrAfterTaskFunction;
     /**
      * wether this task should run buffered
      */
@@ -70,7 +183,7 @@ export class Task {
   /**
    * trigger the task. Will trigger buffered if this.buffered is true
    */
-  trigger(x?): Promise<any> {
+  public trigger(x?): Promise<any> {
     if (this.buffered) {
       return this.triggerBuffered(x);
     } else {
@@ -81,14 +194,14 @@ export class Task {
   /**
    * trigger task unbuffered.
    */
-  triggerUnBuffered(x?): Promise<any> {
-    return helpers.runTask(this, { x: x });
+  public triggerUnBuffered(x?): Promise<any> {
+    return Task.runTask(this, { x: x });
   }
 
   /**
    * trigger task buffered.
    */
-  triggerBuffered(x?): Promise<any> {
+  public triggerBuffered(x?): Promise<any> {
     return this.bufferRunner.trigger(x);
   }