1.0.5

README.md

@@ -1,5 +1,5 @@
 # taskbuffer
-Flexible task organization for gulp. TypeScript ready!
+flexible task management. TypeScript ready!
 
 ## Status
 [![Coverage Status](https://coveralls.io/repos/github/pushrocks/taskbuffer/badge.svg?branch=master)](https://coveralls.io/github/pushrocks/taskbuffer?branch=master)

dist/index.d.ts

@@ -1,4 +1,4 @@
-export { Task } from "./taskbuffer.classes.task";
+export { Task, ITaskFunction } from "./taskbuffer.classes.task";
 export { Taskchain } from "./taskbuffer.classes.taskchain";
 export { Taskparallel } from "./taskbuffer.classes.taskparallel";
 export { Taskspace } from "./taskbuffer.classes.taskspace";

dist/index.js

@@ -9,4 +9,4 @@ var taskbuffer_classes_taskspace_1 = require("./taskbuffer.classes.taskspace");
 exports.Taskspace = taskbuffer_classes_taskspace_1.Taskspace;
 // import for naming only
 require("./taskbuffer.classes.helpers");
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsd0NBQW1CLDJCQUEyQixDQUFDO0FBQXZDLDhDQUF1QztBQUMvQyw2Q0FBd0IsZ0NBQWdDLENBQUM7QUFBakQsNkRBQWlEO0FBQ3pELGdEQUEyQixtQ0FBbUMsQ0FBQztBQUF2RCxzRUFBdUQ7QUFDL0QsNkNBQXdCLGdDQUFnQyxDQUFDO0FBQWpELDZEQUFpRDtBQUV6RCx5QkFBeUI7QUFDekIsUUFBTyw4QkFBOEIsQ0FBQyxDQUFEIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsd0NBQWlDLDJCQUEyQixDQUFDO0FBQXJELDhDQUFxRDtBQUM3RCw2Q0FBd0IsZ0NBQWdDLENBQUM7QUFBakQsNkRBQWlEO0FBQ3pELGdEQUEyQixtQ0FBbUMsQ0FBQztBQUF2RCxzRUFBdUQ7QUFDL0QsNkNBQXdCLGdDQUFnQyxDQUFDO0FBQWpELDZEQUFpRDtBQUV6RCx5QkFBeUI7QUFDekIsUUFBTyw4QkFBOEIsQ0FBQyxDQUFEIn0=

dist/taskbuffer.classes.helpers.d.ts

@@ -4,7 +4,28 @@ import { Task, ITaskFunction } from "./taskbuffer.classes.task";
 export declare let emptyTaskFunction: ITaskFunction;
 export declare let isTask: (taskArg: any) => boolean;
 export declare let isTaskTouched: (taskArg: Task, touchedTasksArray: Task[]) => boolean;
-export declare let runTask: (taskArg: Task, optionsArg?: {
-    touchedTasksArray: Task[];
+export declare let runTask: (taskArg: Task, optionsArg: {
+    x?: any;
+    touchedTasksArray?: Task[];
 }) => plugins.Q.Promise<{}>;
-export declare let runBufferedTask: (taskArg: Task) => void;
+export interface cycleObject {
+    cycleCounter: number;
+    deferred: plugins.Q.Deferred<any>;
+}
+export declare class CycleCounter {
+    task: Task;
+    cycleObjectArray: cycleObject[];
+    constructor(taskArg: Task);
+    getPromiseForCycle(cycleCountArg: number): plugins.Q.Promise<{}>;
+    informOfCycle(): void;
+}
+export declare class BufferRunner {
+    task: Task;
+    bufferCounter: number;
+    bufferMax: number;
+    running: boolean;
+    constructor(taskArg: Task);
+    private _run(x);
+    setBufferMax(bufferMaxArg: number): void;
+    trigger(x: any): PromiseLike<any>;
+}

dist/taskbuffer.classes.task.d.ts

@@ -1,21 +1,18 @@
-/// <reference types="q" />
-import * as plugins from "./taskbuffer.plugins";
+import * as helpers from "./taskbuffer.classes.helpers";
 export interface ITaskFunction {
-    (): PromiseLike<any>;
+    (x?: any): PromiseLike<any>;
 }
 export declare class Task {
     name: string;
-    task: any;
-    running: boolean;
-    runningBuffered: boolean;
-    idle: boolean;
+    taskFunction: ITaskFunction;
     buffered: boolean;
-    bufferCounter: number;
-    bufferMax: number;
-    private _counterTriggerAbsolute;
-    private _state;
     preTask: Task;
     afterTask: Task;
+    running: boolean;
+    bufferRunner: helpers.BufferRunner;
+    cycleCounter: helpers.CycleCounter;
+    idle: boolean;
+    private _state;
     constructor(optionsArg: {
         taskFunction: ITaskFunction;
         preTask?: Task;
@@ -27,14 +24,14 @@ export declare class Task {
     /**
      * trigger the task. Will trigger buffered if this.buffered is true
      */
-    trigger(): plugins.Q.Promise<{}>;
+    trigger(x?: any): PromiseLike<any>;
     /**
      * trigger task unbuffered.
      */
-    triggerUnBuffered(): plugins.Q.Promise<{}>;
+    triggerUnBuffered(x?: any): PromiseLike<any>;
     /**
      * trigger task buffered.
      */
-    triggerBuffered(): plugins.Q.Promise<{}>;
+    triggerBuffered(x?: any): PromiseLike<any>;
     state: string;
 }

dist/taskbuffer.classes.task.js

@@ -3,59 +3,45 @@ const plugins = require("./taskbuffer.plugins");
 const helpers = require("./taskbuffer.classes.helpers");
 class Task {
     constructor(optionsArg) {
+        // initialize by default
         this.running = false;
-        this.runningBuffered = false;
+        this.bufferRunner = new helpers.BufferRunner(this);
+        this.cycleCounter = new helpers.CycleCounter(this);
         this.idle = true;
-        this.buffered = false;
-        this.bufferMax = 1;
-        this._counterTriggerAbsolute = 0;
+        this._state = "ready";
         var options = optionsArg;
-        this.task = optionsArg.taskFunction;
+        this.taskFunction = 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;
     }
     /**
      * trigger the task. Will trigger buffered if this.buffered is true
      */
-    trigger() {
-        let done = plugins.Q.defer();
+    trigger(x) {
         if (this.buffered) {
-            this.triggerBuffered()
-                .then(done.resolve);
+            return this.triggerBuffered(x);
         }
         else {
-            this.triggerUnBuffered()
-                .then(done.resolve);
+            return this.triggerUnBuffered(x);
         }
         ;
-        return done.promise;
     }
     ;
     /**
      * trigger task unbuffered.
      */
-    triggerUnBuffered() {
-        return helpers.runTask(this);
+    triggerUnBuffered(x) {
+        return helpers.runTask(this, { x: x });
     }
     /**
      * 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(x) {
+        return this.bufferRunner.trigger(x);
     }
     get state() {
         return this._state;
@@ -70,4 +56,4 @@ class Task {
     }
 }
 exports.Task = Task;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

dist/taskbuffer.classes.taskchain.d.ts

@@ -3,12 +3,13 @@ export declare class Taskchain extends Task {
     taskArray: Task[];
     private _oraObject;
     constructor(optionsArg: {
+        taskArray: Task[];
         name?: string;
         log?: boolean;
-        taskArray: Task[];
+        buffered?: boolean;
+        bufferMax?: number;
     });
     addTask(taskArg: Task): void;
     removeTask(taskArg: Task): void;
     shiftTask(): void;
-    trigger(): any;
 }

dist/taskbuffer.classes.taskchain.js

@@ -1,32 +1,31 @@
 "use strict";
 const plugins = require("./taskbuffer.plugins");
 const taskbuffer_classes_task_1 = require("./taskbuffer.classes.task");
-const helpers = require("./taskbuffer.classes.helpers");
 class Taskchain extends taskbuffer_classes_task_1.Task {
     constructor(optionsArg) {
         let options = plugins.lodash.merge({
             name: "unnamed Taskchain",
             log: false
         }, optionsArg, {
-            taskFunction: () => {
+            taskFunction: (x) => {
                 let done = plugins.Q.defer(); // this is the starting Deferred object 
-                let taskCounter = 0;
-                let iterateTasks = () => {
+                let taskCounter = 0; // counter for iterating async over the taskArray
+                let iterateTasks = (x) => {
                     if (typeof this.taskArray[taskCounter] != "undefined") {
                         this._oraObject.text(this.name + " running: Task" + this.taskArray[taskCounter].name);
-                        this.taskArray[taskCounter].trigger()
-                            .then(() => {
+                        this.taskArray[taskCounter].trigger(x)
+                            .then((x) => {
                             plugins.beautylog.ok(this.taskArray[taskCounter].name);
                             taskCounter++;
-                            iterateTasks();
+                            iterateTasks(x);
                         });
                     }
                     else {
                         this._oraObject.endOk("Taskchain \"" + this.name + "\" completed successfully");
-                        done.resolve();
+                        done.resolve(x);
                     }
                 };
-                iterateTasks();
+                iterateTasks(x);
                 return done.promise;
             }
         });
@@ -49,11 +48,7 @@ class Taskchain extends taskbuffer_classes_task_1.Task {
     shiftTask() {
     }
     ;
-    trigger() {
-        this._oraObject.start(this.name + " running...");
-        return helpers.runTask(this);
-    }
 }
 exports.Taskchain = Taskchain;
 ;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package.json

@@ -1,7 +1,7 @@
 {
   "name": "taskbuffer",
-  "version": "1.0.0",
-  "description": "Flexible task organization for gulp. TypeScript ready!",
+  "version": "1.0.5",
+  "description": "flexible task management. TypeScript ready!",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "scripts": {
@@ -9,7 +9,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/pushrocks/taskbuffer.git"
+    "url": "git+https://gitlab.com/pushrocks/taskbuffer.git"
   },
   "keywords": [
     "gulp",
@@ -20,9 +20,9 @@
   "author": "Lossless GmbH",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/pushrocks/taskbuffer/issues"
+    "url": "https://gitlab.com/pushrocks/taskbuffer/issues"
   },
-  "homepage": "https://github.com/pushrocks/taskbuffer#readme",
+  "homepage": "https://gitlab.com/pushrocks/taskbuffer#readme",
   "dependencies": {
     "@types/lodash": "^0.0.28",
     "@types/q": "^0.0.27",

test/test.ts

@@ -1,130 +1,202 @@
 import "typings-test";
 import taskbuffer = require("../dist/index");
-let should = require("should");
+import should = require("should");
 import q = require("q")
 
 // setup some testData to work with
-let testTask:taskbuffer.Task;
-let testTaskFunction = function(){
+let testTask: taskbuffer.Task;
+let testTaskFunction = function () {
     let done = q.defer();
     console.log("main function executed!")
     done.resolve();
     return done.promise;
-}
+};
+
+let testTaskFunctionTimeout = function () {
+    let done = q.defer();
+    console.log("main function started!");
+    setTimeout(() => {
+        console.log("main function ended!");
+        done.resolve();
+    },2000);
+    return done.promise;
+};
+
 let testPreTask = new taskbuffer.Task({
-    taskFunction:function(){
+    taskFunction: function () {
         let done = q.defer();
         console.log("preTask executed");
         done.resolve();
         return done.promise;
     },
-    preTask:testTask
+    preTask: testTask
 });
 
-describe("taskbuffer",function(){
-    describe(".Task",function(){
-        it("new Task() should return a new task",function(){
-            testTask = new taskbuffer.Task({taskFunction:testTaskFunction,preTask:testPreTask});
+
+// some more tasks to wirj with
+let task1 = new taskbuffer.Task({
+    name: "Task 1",
+    taskFunction: () => {
+        let done = q.defer();
+        console.log("Task1 started");
+        setTimeout(() => {
+            console.log("Task1 executed");
+            done.resolve();
+        }, 5000)
+        return done.promise;
+    }
+});
+let task2 = new taskbuffer.Task({
+    name: "Task 1",
+    taskFunction: () => {
+        let done = q.defer();
+        console.log("Task2 started");
+        setTimeout(() => {
+            console.log("Task2 executed");
+            done.resolve();
+        }, 5000)
+        return done.promise;
+    }
+});
+let task3 = new taskbuffer.Task({
+    name: "Task 3",
+    taskFunction: () => {
+        let done = q.defer();
+        console.log("Task3 started");
+        setTimeout(() => {
+            console.log("Task3 executed");
+            done.resolve();
+        }, 5000)
+        return done.promise;
+    }
+});
+
+// the actual tests
+describe("taskbuffer", function () {
+    describe(".Task", function () {
+        it("new Task() should return a new task", function () {
+            testTask = new taskbuffer.Task({ taskFunction: testTaskFunction, preTask: testPreTask });
         });
-        it("testTask should be and instance of Task",function(){
+        it("testTask should be and instance of Task", function () {
             testTask.should.be.instanceof(taskbuffer.Task);
         });
-        it("testTask.idle is true",function(){
-            if (!testTask.idle){
+        it("testTask.idle is true", function () {
+            if (!testTask.idle) {
                 throw new Error("testTask.idle is not true");
             }
-            
+
         });
-        it("testTask.running is type boolean and initially false",function(){
+        it("testTask.running is type boolean and initially false", function () {
             testTask.running.should.be.type("boolean");
             testTask.running.should.be.false();
         });
-        it("testTask.trigger() should return Promise",function(){
+        it("testTask.trigger() should return Promise", function () {
             testTask.trigger().should.be.Promise();
         });
-        it("testTask.trigger() returned Promise should be fullfilled",function(done){
+        it("testTask.trigger() returned Promise should be fullfilled", function (done) {
             testTask.trigger()
                 .then(done);
         });
-        it("should run a task without pre and afterTask",function(done){
-            let localTestTask = new taskbuffer.Task({taskFunction:testTaskFunction});
+        it("should run a task without pre and afterTask", function (done) {
+            let localTestTask = new taskbuffer.Task({ taskFunction: testTaskFunction });
             localTestTask.trigger().then(done);
         });
+
+        it("should run buffered", function (done) {
+            this.timeout(10000);
+            let localTestTask = new taskbuffer.Task({
+                taskFunction: testTaskFunctionTimeout,
+                buffered:true,
+                bufferMax:2
+            });
+            localTestTask.trigger();
+            localTestTask.trigger();
+            localTestTask.trigger();
+            localTestTask.trigger().then(() => {
+                done();
+            })
+        });
     });
-    describe("Taskchain",function(){
+    describe("Taskchain", function () {
         let testTaskchain;
         let testTaskArray = [
             new taskbuffer.Task({
-                name:"task1",
-                taskFunction:function(){
+                name: "task1",
+                taskFunction: function () {
                     let done = q.defer();
-                    setTimeout(done.resolve,2000);
+                    setTimeout(done.resolve, 2000);
                     return done.promise;
                 }
             }),
             new taskbuffer.Task({
-                name:"task2",
-                taskFunction: function(){
+                name: "task2",
+                taskFunction: function () {
                     let done = q.defer();
-                    setTimeout(done.resolve,2000);
+                    setTimeout(done.resolve, 2000);
                     return done.promise;
                 }
             }),
         ];
-        it("should run tasks in sequence",function(done){
+        it("should run tasks in sequence", function (done) {
             this.timeout(5000);
             testTaskchain = new taskbuffer.Taskchain({
-                name:"Taskchain1",
-                taskArray:testTaskArray
+                name: "Taskchain1",
+                taskArray: testTaskArray
             });
             testTaskchain.trigger().then(done);
         });
     });
-    describe("taskparallel",function(){
-        let task1 = new taskbuffer.Task({
-            name:"Task 1",
-            taskFunction: () => {
-                let done = q.defer();
-                console.log("Task1 started");
-                setTimeout(() => {
-                    console.log("Task1 executed");
-                    done.resolve();
-                },5000)
-                return done.promise;
-            }
-        });
-        let task2 = new taskbuffer.Task({
-            name:"Task 1",
-            taskFunction: () => {
-                let done = q.defer();
-                console.log("Task2 started");
-                setTimeout(() => {
-                    console.log("Task2 executed");
-                    done.resolve();
-                },5000)
-                return done.promise;
-            }
-        });
-        let task3 = new taskbuffer.Task({
-            name:"Task 3",
-            taskFunction: () => {
-                let done = q.defer();
-                console.log("Task3 started");
-                setTimeout(() => {
-                    console.log("Task3 executed");
-                    done.resolve();
-                },5000)
-                return done.promise;
-            }
-        });
-        it("should run in Parallel",function(done){
+    describe("taskparallel", function () {
+        it("should run in Parallel", function (done) {
             this.timeout("7000");
             let testTaskparallel = new taskbuffer.Taskparallel({
-                taskArray:[task1,task2,task3]
+                taskArray: [task1, task2, task3]
             });
             testTaskparallel.trigger().then(() => {
                 done();
             });
         })
+    });
+    describe("some flowtests",function(){
+        let flowTask1 = new taskbuffer.Task({
+            taskFunction: (x:number) => {
+                let done = q.defer();
+                console.log("flowTask1");
+                console.log(x);
+                done.resolve(x);
+                return done.promise;
+            }
+        });
+        let flowTask2 = new taskbuffer.Task({
+            taskFunction: (x:number) => {
+                let done = q.defer();
+                console.log("flowTask2");
+                console.log(x);
+                done.resolve(x);
+                return done.promise;
+            },
+            preTask:flowTask1
+        });
+        let flowTask3 = new taskbuffer.Taskchain({
+            taskArray:[flowTask1,flowTask2];
+        });
+        it("should let a value flow through a task",function(done){
+            flowTask1.trigger(12).then((x) => {
+                should.equal(x,12);
+                done();
+            }).catch(done);
+        });
+        it("should let a values flow between tasks",function(done){
+            flowTask2.trigger(12).then((x) => {
+                should.equal(x,12);
+                done();
+            }).catch(done);
+        });
+        it("should let a values flow between tasks in Taskchain",function(done){
+            flowTask3.trigger(12).then((x) => {
+                should.equal(x,12);
+                done();
+            }).catch(done);
+        });
     })
 });

ts/index.ts

@@ -1,4 +1,4 @@
-export {Task} from "./taskbuffer.classes.task";
+export {Task,ITaskFunction} from "./taskbuffer.classes.task";
 export {Taskchain} from "./taskbuffer.classes.taskchain";
 export {Taskparallel} from "./taskbuffer.classes.taskparallel";
 export {Taskspace} from "./taskbuffer.classes.taskspace";

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 (x) {
     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,66 +19,139 @@ 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: {x?, touchedTasksArray?: Task[] }) {
     let done = plugins.Q.defer();
+    
+    //  set running params
     taskArg.running = true;
-    done.promise.then(function(){taskArg.running = false});
-    let localDeferred = plugins.Q.defer();
-    let touchedTasksArray:Task[];
-    if(optionsArg.touchedTasksArray){
-        touchedTasksArray = optionsArg.touchedTasksArray;
-    } else {
-        touchedTasksArray = [];
-    }
+    done.promise.then(function () { taskArg.running = false });
+
+    // handle options
+    let options = plugins.lodash.merge(
+        {x:undefined,touchedTasksArray: []},
+        optionsArg
+    )
+    let x = options.x;
+    let touchedTasksArray: Task[] = options.touchedTasksArray;
+    
     touchedTasksArray.push(taskArg);
+    
+    // run the task cascade
+    let localDeferred = plugins.Q.defer();
     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, {x:x, touchedTasksArray: touchedTasksArray })
             } else {
                 let done2 = plugins.Q.defer();
-                done2.resolve();
+                done2.resolve(x);
                 return done2.promise;
             }
         })
-        .then(() => {
-            return taskArg.task();
+        .then(x => {
+            return taskArg.taskFunction(x);
         })
-        .then(() => {
-            if(taskArg.afterTask && !isTaskTouched(taskArg.afterTask,touchedTasksArray)){
-                return runTask(taskArg.afterTask,{touchedTasksArray:touchedTasksArray})
+        .then(x => {
+            if (taskArg.afterTask && !isTaskTouched(taskArg.afterTask, touchedTasksArray)) {
+                return runTask(taskArg.afterTask, {x:x, touchedTasksArray: touchedTasksArray });
             } else {
                 let done2 = plugins.Q.defer();
-                done2.resolve();
+                done2.resolve(x);
                 return done2.promise;
             }
         })
-        .then(() => {
-            done.resolve();
+        .then(x => {
+            done.resolve(x);
+        }).catch((err) => {
+            console.log(err);
         });
     localDeferred.resolve();
     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(x) {
+        let recursiveBufferRunner = (x) => {
+            if (this.bufferCounter >= 0) {
+                this.running = true;
+                this.task.running = true;
+                runTask(this.task,{x:x})
+                    .then((x) => {
+                        this.bufferCounter--;
+                        this.task.cycleCounter.informOfCycle();
+                        recursiveBufferRunner(x);
+                    });
+            } else {
+                this.running = false;
+                this.task.running = false;
+            }
+        };
+        recursiveBufferRunner(x);
+    };
+    setBufferMax(bufferMaxArg:number){
+        this.bufferMax = bufferMaxArg;
+    };
+    trigger(x): 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(x);
+        }
+        return returnPromise;
+    };
 };

ts/taskbuffer.classes.task.ts

@@ -3,23 +3,23 @@ import * as helpers from "./taskbuffer.classes.helpers"
 
 
 export interface ITaskFunction {
-    ():PromiseLike<any>;
+    (x?:any):PromiseLike<any>;
 }
 
 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;
+    taskFunction:ITaskFunction;
+    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,
@@ -29,51 +29,39 @@ export class Task {
         name?:string
     }){
         var options = optionsArg;
-        this.task = optionsArg.taskFunction;
+        this.taskFunction = 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;
     }
     
     /**
      * trigger the task. Will trigger buffered if this.buffered is true
      */
-    trigger(){
-        let done = plugins.Q.defer();
+    trigger(x?):PromiseLike<any> {
         if(this.buffered) {
-            this.triggerBuffered()
-                .then(done.resolve);
+            return this.triggerBuffered(x)
         }
         else {
-            this.triggerUnBuffered()
-                .then(done.resolve);
+            return this.triggerUnBuffered(x);
         };
-        return done.promise;
     };
 
     /**
      * trigger task unbuffered.
      */
-    triggerUnBuffered(){
-        return helpers.runTask(this);
+    triggerUnBuffered(x?):PromiseLike<any>{
+        return helpers.runTask(this,{x:x});
     }
     
     /**
      * 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(x?):PromiseLike<any>{
+        return this.bufferRunner.trigger(x);
     }
 
     get state():string {

ts/taskbuffer.classes.taskchain.ts

@@ -6,9 +6,11 @@ export class Taskchain extends Task {
     taskArray:Task[];
     private _oraObject:plugins.beautylog.Ora;
     constructor(optionsArg:{
+        taskArray:Task[],
         name?:string,
         log?:boolean,
-        taskArray:Task[]
+        buffered?:boolean,
+        bufferMax?:number
     }){
         let options = plugins.lodash.merge(
             {
@@ -17,24 +19,24 @@ export class Taskchain extends Task {
             },
             optionsArg,
             {
-                taskFunction: () => { // this is the function that gets executed when TaskChain is triggered
+                taskFunction: (x:any) => { // this is the function that gets executed when TaskChain is triggered
                     let done = plugins.Q.defer(); // this is the starting Deferred object 
-                    let taskCounter = 0;
-                    let iterateTasks = () => {
+                    let taskCounter = 0; // counter for iterating async over the taskArray
+                    let iterateTasks = (x) => {
                         if(typeof this.taskArray[taskCounter] != "undefined"){
                             this._oraObject.text(this.name + " running: Task" + this.taskArray[taskCounter].name);
-                            this.taskArray[taskCounter].trigger()
-                                .then(()=>{
+                            this.taskArray[taskCounter].trigger(x)
+                                .then((x)=>{
                                     plugins.beautylog.ok(this.taskArray[taskCounter].name);
                                     taskCounter++;
-                                    iterateTasks();
+                                    iterateTasks(x);
                                 });     
                         } else {
                             this._oraObject.endOk("Taskchain \"" + this.name +  "\" completed successfully");
-                            done.resolve();
+                            done.resolve(x);
                         }
                     };
-                    iterateTasks();
+                    iterateTasks(x);
                     return done.promise;
                 }
             }
@@ -55,8 +57,4 @@ export class Taskchain extends Task {
     shiftTask(){
         
     };
-    trigger(){
-        this._oraObject.start(this.name + " running...");
-        return helpers.runTask(this);
-    }
 };