implemented execDelay

dist/taskbuffer.classes.helpers.d.ts

@@ -21,10 +21,8 @@ export declare class CycleCounter {
 export declare class BufferRunner {
     task: Task;
     bufferCounter: number;
-    bufferMax: number;
     running: boolean;
     constructor(taskArg: Task);
-    setBufferMax(bufferMaxArg: number): void;
     trigger(x: any): Promise<any>;
     private _run(x);
 }

dist/taskbuffer.classes.task.d.ts

@@ -6,6 +6,8 @@ export declare class Task {
     name: string;
     taskFunction: ITaskFunction;
     buffered: boolean;
+    bufferMax: number;
+    execDelay: number;
     preTask: Task;
     afterTask: Task;
     running: boolean;
@@ -14,11 +16,34 @@ export declare class Task {
     idle: boolean;
     private _state;
     constructor(optionsArg: {
+        /**
+         * the task function to run, must return promise
+         */
         taskFunction: ITaskFunction;
+        /**
+         * any other task to run before
+         */
         preTask?: Task;
+        /**
+         * any other task to run after
+         */
         afterTask?: Task;
+        /**
+         * wether this task should run buffered
+         */
         buffered?: boolean;
+        /**
+         * the maximum buffer
+         */
         bufferMax?: number;
+        /**
+         * the execution delay, before the task is executed
+         * only makes sense when running in buffered mode
+         */
+        execDelay?: number;
+        /**
+         * the name of the task
+         */
         name?: string;
     });
     /**

dist/taskbuffer.classes.task.js

@@ -10,14 +10,14 @@ class Task {
         this.cycleCounter = new helpers.CycleCounter(this);
         this.idle = true;
         this._state = 'ready';
-        let options = optionsArg;
         this.taskFunction = optionsArg.taskFunction;
-        this.preTask = options.preTask;
-        this.afterTask = options.afterTask;
+        this.preTask = optionsArg.preTask;
+        this.afterTask = optionsArg.afterTask;
         this.idle = !this.running;
-        this.buffered = options.buffered;
-        this.bufferRunner.setBufferMax(options.bufferMax);
-        this.name = options.name;
+        this.buffered = optionsArg.buffered;
+        this.bufferMax = optionsArg.bufferMax;
+        this.execDelay = optionsArg.execDelay;
+        this.name = optionsArg.name;
     }
     /**
      * trigger the task. Will trigger buffered if this.buffered is true
@@ -55,4 +55,4 @@ class Task {
     }
 }
 exports.Task = Task;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

ts/taskbuffer.classes.helpers.ts

@@ -28,12 +28,18 @@ export let isTaskTouched = (taskArg: Task, touchedTasksArray: Task[]): boolean =
   return result
 }
 
-export let runTask = function (taskArg: Task, optionsArg: { x?, touchedTasksArray?: Task[] }) {
+export let runTask = async (taskArg: Task, optionsArg: { x?, touchedTasksArray?: Task[] }) => {
   let done = plugins.q.defer()
 
+  // pay respect to execDelay
+  if (taskArg.execDelay) {
+    await plugins.smartdelay.delayFor(taskArg.execDelay)
+  }
+
   //  set running params
   taskArg.running = true
-  done.promise.then(function () { taskArg.running = false })
+
+  done.promise.then(async () => { taskArg.running = false })
 
   // handle options
   let options = plugins.lodash.merge(
@@ -75,7 +81,7 @@ export let runTask = function (taskArg: Task, optionsArg: { x?, touchedTasksArra
       console.log(err)
     })
   localDeferred.resolve()
-  return done.promise
+  return await done.promise
 }
 
 export interface cycleObject {
@@ -116,18 +122,13 @@ export class BufferRunner {
   task: Task
   // initialze by default
   bufferCounter: number = 0
-  bufferMax: number = 1
   running: boolean = false
   constructor(taskArg: Task) {
     this.task = taskArg
   }
 
-  setBufferMax (bufferMaxArg: number) {
-    this.bufferMax = bufferMaxArg
-  }
-
   trigger (x): Promise<any> {
-    if (!(this.bufferCounter >= this.bufferMax)) {
+    if (!(this.bufferCounter >= this.task.bufferMax)) {
       this.bufferCounter++
     }
     let returnPromise: Promise<any> = this.task.cycleCounter.getPromiseForCycle(this.bufferCounter + 1)

ts/taskbuffer.classes.task.ts

@@ -6,9 +6,15 @@ export interface ITaskFunction {
 }
 
 export class Task {
+  // man datory properties
   name: string
   taskFunction: ITaskFunction
   buffered: boolean
+
+  bufferMax: number
+  execDelay: number
+
+  // tasks to run before and after
   preTask: Task
   afterTask: Task
 
@@ -16,31 +22,55 @@ export class Task {
   running: boolean = false
   bufferRunner = new helpers.BufferRunner(this)
   cycleCounter = new helpers.CycleCounter(this)
+
   idle: boolean = true
   private _state: string = 'ready'
 
-  constructor (optionsArg: {
-    taskFunction: ITaskFunction,
-    preTask?: Task,
-    afterTask?: Task,
-    buffered?: boolean,
-    bufferMax?: number,
+  constructor(optionsArg: {
+    /**
+     * the task function to run, must return promise
+     */
+    taskFunction: ITaskFunction
+    /**
+     * any other task to run before
+     */
+    preTask?: Task
+    /**
+     * any other task to run after
+     */
+    afterTask?: Task
+    /**
+     * wether this task should run buffered
+     */
+    buffered?: boolean
+    /**
+     * the maximum buffer
+     */
+    bufferMax?: number
+    /**
+     * the execution delay, before the task is executed
+     * only makes sense when running in buffered mode
+     */
+    execDelay?: number
+    /**
+     * the name of the task
+     */
     name?: string
   }) {
-    let options = optionsArg
     this.taskFunction = optionsArg.taskFunction
-    this.preTask = options.preTask
-    this.afterTask = options.afterTask
+    this.preTask = optionsArg.preTask
+    this.afterTask = optionsArg.afterTask
     this.idle = !this.running
-    this.buffered = options.buffered
-    this.bufferRunner.setBufferMax(options.bufferMax)
-    this.name = options.name
+    this.buffered = optionsArg.buffered
+    this.bufferMax = optionsArg.bufferMax
+    this.execDelay = optionsArg.execDelay
+    this.name = optionsArg.name
   }
 
   /**
    * trigger the task. Will trigger buffered if this.buffered is true
    */
-  trigger (x?): Promise<any> {
+  trigger(x?): Promise<any> {
     if (this.buffered) {
       return this.triggerBuffered(x)
     } else {
@@ -51,21 +81,22 @@ export class Task {
   /**
    * trigger task unbuffered.
    */
-  triggerUnBuffered (x?): Promise<any> {
+  triggerUnBuffered(x?): Promise<any> {
     return helpers.runTask(this, { x: x })
   }
 
   /**
    * trigger task buffered.
    */
-  triggerBuffered (x?): Promise<any> {
+  triggerBuffered(x?): Promise<any> {
     return this.bufferRunner.trigger(x)
   }
 
-  get state (): string {
+  get state(): string {
     return this._state
   }
-  set state (stateArg: string) {
+
+  set state(stateArg: string) {
     if (stateArg === 'locked') {
       this._state = 'locked'
     } else {