now running correctly in buffered mode

ts/taskbuffer.classes.helpers.ts

@@ -1,17 +1,17 @@
 import plugins = require("./taskbuffer.plugins");
-import {Task,ITaskFunction} from "./taskbuffer.classes.task";
+import { Task, ITaskFunction } from "./taskbuffer.classes.task";
 
-export let emptyTaskFunction:ITaskFunction = function(){
+export let emptyTaskFunction: ITaskFunction = function () {
     let done = plugins.Q.defer();
     done.resolve();
     return done.promise;
 };
 
-export let isTask = function(taskArg):boolean{
-    if(
+export let isTask = function (taskArg): boolean {
+    if (
         taskArg instanceof Task
         && typeof taskArg.task === "function"
-    ){
+    ) {
         return true;
     } else {
         return false;
@@ -19,32 +19,32 @@ export let isTask = function(taskArg):boolean{
 };
 
 
-export let isTaskTouched = (taskArg:Task, touchedTasksArray:Task[]):boolean => {
+export let isTaskTouched = (taskArg: Task, touchedTasksArray: Task[]): boolean => {
     let result = false;
-    for (let keyArg in touchedTasksArray){
-        if(taskArg === touchedTasksArray[keyArg]){
+    for (let keyArg in touchedTasksArray) {
+        if (taskArg === touchedTasksArray[keyArg]) {
             result = true;
         }
     }
     return result;
 }
 
-export let runTask = function(taskArg:Task,optionsArg:{touchedTasksArray:Task[]} = {touchedTasksArray:[]}){
+export let runTask = function (taskArg: Task, optionsArg: { touchedTasksArray: Task[] } = { touchedTasksArray: [] }) {
     let done = plugins.Q.defer();
     taskArg.running = true;
-    done.promise.then(function(){taskArg.running = false});
+    done.promise.then(function () { taskArg.running = false });
     let localDeferred = plugins.Q.defer();
-    let touchedTasksArray:Task[];
-    if(optionsArg.touchedTasksArray){
+    let touchedTasksArray: Task[];
+    if (optionsArg.touchedTasksArray) {
         touchedTasksArray = optionsArg.touchedTasksArray;
     } else {
         touchedTasksArray = [];
     }
     touchedTasksArray.push(taskArg);
     localDeferred.promise
-        .then(() =>{
-            if(taskArg.preTask && !isTaskTouched(taskArg.preTask,touchedTasksArray)){
-                return runTask(taskArg.preTask,{touchedTasksArray:touchedTasksArray})
+        .then(() => {
+            if (taskArg.preTask && !isTaskTouched(taskArg.preTask, touchedTasksArray)) {
+                return runTask(taskArg.preTask, { touchedTasksArray: touchedTasksArray })
             } else {
                 let done2 = plugins.Q.defer();
                 done2.resolve();
@@ -55,8 +55,8 @@ export let runTask = function(taskArg:Task,optionsArg:{touchedTasksArray:Task[]}
             return taskArg.task();
         })
         .then(() => {
-            if(taskArg.afterTask && !isTaskTouched(taskArg.afterTask,touchedTasksArray)){
-                return runTask(taskArg.afterTask,{touchedTasksArray:touchedTasksArray})
+            if (taskArg.afterTask && !isTaskTouched(taskArg.afterTask, touchedTasksArray)) {
+                return runTask(taskArg.afterTask, { touchedTasksArray: touchedTasksArray })
             } else {
                 let done2 = plugins.Q.defer();
                 done2.resolve();
@@ -70,15 +70,79 @@ export let runTask = function(taskArg:Task,optionsArg:{touchedTasksArray:Task[]}
     return done.promise;
 };
 
-export let runBufferedTask = (taskArg:Task) => {
-    let recursiveBufferRunner = () => {
-        if(taskArg.bufferCounter > 0){
-            taskArg.runningBuffered = true;
-            taskArg.bufferCounter--;
-            runTask(taskArg)
-                .then(recursiveBufferRunner);
-        } else {
-            taskArg.runningBuffered = false;
-        }
+
+export interface cycleObject {
+    cycleCounter:number,
+    deferred:plugins.Q.Deferred<any>
+}
+
+export class CycleCounter {
+    task:Task;
+    cycleObjectArray:cycleObject[] = [];
+    constructor(taskArg:Task){
+        this.task = taskArg;
+    };
+    getPromiseForCycle(cycleCountArg:number){
+        let done = plugins.Q.defer();
+        let cycleObject:cycleObject = {
+            cycleCounter:cycleCountArg,
+            deferred:done
+        };
+        this.cycleObjectArray.push(cycleObject);
+        return done.promise;
+    };
+    informOfCycle(){
+        let newCycleObjectArray:cycleObject[] = [];
+        this.cycleObjectArray.forEach(cycleObjectArg => {
+            cycleObjectArg.cycleCounter--;
+            if(cycleObjectArg.cycleCounter <= 0){
+                cycleObjectArg.deferred.resolve();
+            } else {
+                newCycleObjectArray.push(cycleObjectArg);
+            };
+        });
+        this.cycleObjectArray = newCycleObjectArray;
     }
+}
+
+export class BufferRunner {
+    task:Task;
+    // initialze by default
+    bufferCounter:number = 0;
+    bufferMax:number = 1;
+    running:boolean = false;
+    constructor(taskArg: Task) {
+        this.task = taskArg;
+    };
+    private _run() {
+        let recursiveBufferRunner = () => {
+            if (this.bufferCounter >= 0) {
+                this.running = true;
+                this.task.running = true;
+                runTask(this.task)
+                    .then(() => {
+                        this.bufferCounter--;
+                        this.task.cycleCounter.informOfCycle();
+                        recursiveBufferRunner();
+                    });
+            } else {
+                this.running = false;
+                this.task.running = false;
+            }
+        };
+        recursiveBufferRunner();
+    };
+    setBufferMax(bufferMaxArg:number){
+        this.bufferMax = bufferMaxArg;
+    };
+    trigger(): PromiseLike<any> {
+        if(!(this.bufferCounter >= this.bufferMax)){
+            this.bufferCounter++
+        };
+        let returnPromise:PromiseLike<any> = this.task.cycleCounter.getPromiseForCycle(this.bufferCounter + 1);
+        if(!this.running){
+            this._run();
+        }
+        return returnPromise;
+    };
 };

ts/taskbuffer.classes.task.ts

@@ -9,17 +9,17 @@ export interface ITaskFunction {
 export class Task {
     name:string;
     task:any;
-    running:boolean = false;
-    runningBuffered:boolean = false;
-    idle:boolean = true;
-    buffered:boolean = false;
-    bufferCounter:number;
-    bufferMax:number = 1;
-    private _counterTriggerAbsolute:number = 0;
-    private _state:string;
+    buffered:boolean;
     preTask:Task;
     afterTask:Task;
 
+    // initialize by default
+    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,
@@ -32,10 +32,9 @@ export class Task {
         this.task = optionsArg.taskFunction;
         this.preTask = options.preTask;
         this.afterTask = options.afterTask;
-        this.running = false;
-        this.idle = !this.running && !this.runningBuffered;
+        this.idle = !this.running;
         this.buffered = options.buffered;
-        this.bufferMax = options.bufferMax;
+        this.bufferRunner.setBufferMax(options.bufferMax);
         this.name = options.name;
     }
     
@@ -58,22 +57,15 @@ export class Task {
     /**
      * trigger task unbuffered.
      */
-    triggerUnBuffered(){
+    triggerUnBuffered():PromiseLike<any>{
         return helpers.runTask(this);
     }
     
     /**
      * trigger task buffered.
      */
-    triggerBuffered(){
-        var done = plugins.Q.defer();
-        if(!(this.bufferCounter >= this.bufferMax)){
-            this.bufferCounter++
-        };
-        if(!this.runningBuffered){
-            helpers.runBufferedTask(this);
-        };
-        return done.promise;
+    triggerBuffered():PromiseLike<any>{
+        return this.bufferRunner.trigger();
     }
 
     get state():string {