1.0.4

.gitignore

@@ -1,5 +1,6 @@
 .idea/
 coverage/
+docs/
 ts/*.js
 ts/*.js.map
 ts/typings/

.gitlab-ci.yml

@@ -0,0 +1,36 @@
+image: hosttoday/ht-docker-node:npmts
+
+stages:
+- test
+- release
+
+testLEGACY:
+  stage: test
+  script:
+    - npmci test legacy
+  tags:
+    - docker
+
+testLTS:
+  stage: test
+  script:
+    - npmci test lts
+  tags:
+    - docker
+    
+testSTABLE:
+  stage: test
+  script:
+    - npmci test stable
+  tags:
+    - docker
+
+release:
+  stage: release
+  environment: npmjs-com_registry
+  script:
+    - npmci publish
+  only:
+    - tags
+  tags:
+    - docker

.npmignore

@@ -0,0 +1,5 @@
+.idea/
+docs/
+coverage/
+ts/
+node_modules/

.travis.yml

@@ -1,11 +0,0 @@
-language: node_js
-node_js:
-- stable
-deploy:
-  provider: npm
-  email: npm@lossless.digital
-  api_key:
-    secure: NejErc2+ohEEH8DecYcx6/2oSdEQQBRzlOwTMxQBftHdIkvziwOcCerqCJtrXuzalqAofVCcVisunWIXZmxfIBGV6mJVauCIp5KzH4JUhYzLym33p9MSphjlPNfsI6nKkW0LAgOMjkJGuHLqU3oskvBqYyh8m3NuCna5mNwm8lo5WGckzHSwdsmhnb839WhlZbmQc6M6WW6Ir7bbxX9ZOmNUYUWH6VdXfPBxoXN3nO21pXKt7Zg8/nU7IkF+VEUVfYNlR3xUiocWemuBFxjtsfoliQ/y/oGL7ccQ7OeE4PxSu+xNUpYYVipkQcRtyWDKCwJp4R2DNTj/ikOHH+BEFOBDG8qYxwf37Ju0jFybzslAEJLy5gl4bFjiZNA8ldUXY5ubJb56iZTNSbMU0lmXw+qKvIoyVY/1JAE5lzFGVA6nDdiUGAEOg/ajzAC3gjFU2QS2Wvncz3dky0k/2INBVUwmmAvAMazl5XkvHtQ3Wzb+Fc8TXWflqBDF0okySoJzlY13pm/OtOHipiqEyUCnqaUUwJtLIb6tHOPzxZKlWLCem7y84cDlxQSbLVItbArOJFHdr66sp/U/FqYAtWeLdbkhjCENFwzR9kYtEyEl+QWLTckO1/lVF4xJLh6drfhQ66CwF5bfqr5xIS08mnKuYBfJOA4/wV4bQFPhtYm7Oi8=
-  on:
-    tags: true
-    repo: pushrocks/taskbuffer

README.md

@@ -1,5 +1,5 @@
 # taskbuffer
-Flexible task organization for gulp.
+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)
@@ -8,4 +8,49 @@ Flexible task organization for gulp.
 
 ```sh
 npm install taskbuffer --save
+```
+
+## Concepts 
+
+### class `Task`
+* A Task in its most simple form is a function that is executed when the task runs.
+* A Task can have a **preTask** and an **afterTask**
+  (those are run before or after the main function whenever the task is called)
+* A Task can be buffered.
+  That means it can be called multiple times in a very short time.
+  However execution happens in line:
+  meaning execution of the task's main function is on halt until the previous task call has finished.
+  You can set bufferMax number, which is the max number of buffered task calls.
+  Any additional calls will then be truncated
+* Task.trigger() and Task.triggerBuffered() always return a Promise
+  which is fullfilled once the related task call has completed.
+* Task.triggered() is an Observable stream that emits events every time a task call is called and every time a call is completed.
+* Task is compatible to gulp streams.
+
+### class `TaskChain`
+* TaskChain extends Task.
+* Multiple Tasks can be combined in a bigger task using a TaskChain.
+* While the tasks are async in themselve, TaskChain **runs Tasks serialized** (one after the other)
+* that means that tasks can rely on each other and 
+
+### class `TaskParallel`
+* TaskParallel extends Task.
+* like TaskChain, however **tasks run in parallel**
+* Tasks cannot rely on each other.
+
+### Usage
+We highly recommend TypeScript as this module supports **TypeScript intellisense**.
+```
+import * as taskbuffer from "taskbuffer";
+
+myTask = new taskbuffer.Task({
+  preTask: someOtherTask // optional, don't worry loops are prevented
+  afterTask: someOtherTask // optional, don't worry loops are prevented
+  name:"myTask1",
+  taskFunction:() => {
+    // do some stuff and return promise
+    // pass on any data through promise resolution
+    // Use TypeScript for better understanding and code completion
+  }
+})
 ```

dist/index.d.ts

@@ -0,0 +1,5 @@
+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";
+import "./taskbuffer.classes.helpers";

dist/index.js

@@ -1,9 +1,12 @@
-#!/usr/bin/env node
-
-var task = require("./taskbuffer.task");
-var taskbuffer = {
-    task: task
-};
-module.exports = taskbuffer;
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLElBQU8sSUFBSSxXQUFXLG1CQUFtQixDQUFDLENBQUM7QUFHM0MsSUFBSSxVQUFVLEdBQUc7SUFDYixJQUFJLEVBQUUsSUFBSTtDQUNiLENBQUM7QUFFRixpQkFBUyxVQUFVLENBQUMiLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzQ29udGVudCI6WyIvLy8gPHJlZmVyZW5jZSBwYXRoPVwiLi90eXBpbmdzL21haW4uZC50c1wiIC8+XG5pbXBvcnQgcGx1Z2lucyA9IHJlcXVpcmUoXCIuL3Rhc2tidWZmZXIucGx1Z2luc1wiKTtcbmltcG9ydCBjbGFzc2VzID0gcmVxdWlyZShcIi4vdGFza2J1ZmZlci5jbGFzc2VzXCIpO1xuaW1wb3J0IHRhc2sgPSByZXF1aXJlKFwiLi90YXNrYnVmZmVyLnRhc2tcIik7XG5pbXBvcnQgdGFza2NoYWluID0gcmVxdWlyZShcIi4vdGFza2J1ZmZlci50YXNrY2hhaW5cIik7XG5cbnZhciB0YXNrYnVmZmVyID0ge1xuICAgIHRhc2s6IHRhc2tcbn07XG5cbmV4cG9ydCA9IHRhc2tidWZmZXI7Il0sInNvdXJjZVJvb3QiOiIvc291cmNlLyJ9
+"use strict";
+var taskbuffer_classes_task_1 = require("./taskbuffer.classes.task");
+exports.Task = taskbuffer_classes_task_1.Task;
+var taskbuffer_classes_taskchain_1 = require("./taskbuffer.classes.taskchain");
+exports.Taskchain = taskbuffer_classes_taskchain_1.Taskchain;
+var taskbuffer_classes_taskparallel_1 = require("./taskbuffer.classes.taskparallel");
+exports.Taskparallel = taskbuffer_classes_taskparallel_1.Taskparallel;
+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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsd0NBQWlDLDJCQUEyQixDQUFDO0FBQXJELDhDQUFxRDtBQUM3RCw2Q0FBd0IsZ0NBQWdDLENBQUM7QUFBakQsNkRBQWlEO0FBQ3pELGdEQUEyQixtQ0FBbUMsQ0FBQztBQUF2RCxzRUFBdUQ7QUFDL0QsNkNBQXdCLGdDQUFnQyxDQUFDO0FBQWpELDZEQUFpRDtBQUV6RCx5QkFBeUI7QUFDekIsUUFBTyw4QkFBOEIsQ0FBQyxDQUFEIn0=

dist/taskbuffer.classes.helpers.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="q" />
+import plugins = require("./taskbuffer.plugins");
+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: {
+    x?: any;
+    touchedTasksArray?: Task[];
+}) => plugins.Q.Promise<{}>;
+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.js

@@ -1,52 +0,0 @@
-#!/usr/bin/env node
-
-var __extends = (this && this.__extends) || function (d, b) {
-    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
-    function __() { this.constructor = d; }
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-};
-/// <reference path="./typings/main.d.ts" />
-var plugins = require("./taskbuffer.plugins");
-var Task = (function () {
-    function Task(taskArg, optionsArg) {
-        this.task = taskArg;
-    }
-    Task.prototype.trigger = function () {
-        this.preTask.task()
-            .then(this.task)
-            .then(this.afterTask.task);
-    };
-    ;
-    Task.prototype.triggerBuffered = function () {
-        var done = plugins.Q.defer();
-    };
-    Object.defineProperty(Task.prototype, "state", {
-        get: function () {
-            return this._state;
-        },
-        set: function (stateArg) {
-            if (stateArg == "locked") {
-                this._state = "locked";
-            }
-            else {
-                plugins.beautylog.error("state type");
-            }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    return Task;
-})();
-exports.Task = Task;
-var TaskChain = (function (_super) {
-    __extends(TaskChain, _super);
-    function TaskChain(taskArrayArg) {
-        _super.call(this, {
-            task: function () { }
-        });
-    }
-    return TaskChain;
-})(Task);
-exports.TaskChain = TaskChain;
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRhc2tidWZmZXIuY2xhc3Nlcy50cyJdLCJuYW1lcyI6WyJUYXNrIiwiVGFzay5jb25zdHJ1Y3RvciIsIlRhc2sudHJpZ2dlciIsIlRhc2sudHJpZ2dlckJ1ZmZlcmVkIiwiVGFzay5zdGF0ZSIsIlRhc2tDaGFpbiIsIlRhc2tDaGFpbi5jb25zdHJ1Y3RvciJdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSw0Q0FBNEM7QUFDNUMsSUFBTyxPQUFPLFdBQVcsc0JBQXNCLENBQUMsQ0FBQztBQUNqRDtJQVVJQSxjQUFZQSxPQUFPQSxFQUFDQSxVQUEyQ0E7UUFDM0RDLElBQUlBLENBQUNBLElBQUlBLEdBQUdBLE9BQU9BLENBQUNBO0lBQ3hCQSxDQUFDQTtJQUNERCxzQkFBT0EsR0FBUEE7UUFDSUUsSUFBSUEsQ0FBQ0EsT0FBT0EsQ0FBQ0EsSUFBSUEsRUFBRUE7YUFDZEEsSUFBSUEsQ0FBQ0EsSUFBSUEsQ0FBQ0EsSUFBSUEsQ0FBQ0E7YUFDZkEsSUFBSUEsQ0FBQ0EsSUFBSUEsQ0FBQ0EsU0FBU0EsQ0FBQ0EsSUFBSUEsQ0FBQ0EsQ0FBQ0E7SUFDbkNBLENBQUNBOztJQUNERiw4QkFBZUEsR0FBZkE7UUFDSUcsSUFBSUEsSUFBSUEsR0FBR0EsT0FBT0EsQ0FBQ0EsQ0FBQ0EsQ0FBQ0EsS0FBS0EsRUFBRUEsQ0FBQ0E7SUFDakNBLENBQUNBO0lBRURILHNCQUFJQSx1QkFBS0E7YUFBVEE7WUFDSUksTUFBTUEsQ0FBQ0EsSUFBSUEsQ0FBQ0EsTUFBTUEsQ0FBQ0E7UUFDdkJBLENBQUNBO2FBQ0RKLFVBQVVBLFFBQWVBO1lBQ3JCSSxFQUFFQSxDQUFDQSxDQUFDQSxRQUFRQSxJQUFJQSxRQUFRQSxDQUFDQSxDQUFBQSxDQUFDQTtnQkFDdEJBLElBQUlBLENBQUNBLE1BQU1BLEdBQUdBLFFBQVFBLENBQUNBO1lBQzNCQSxDQUFDQTtZQUFDQSxJQUFJQSxDQUFDQSxDQUFDQTtnQkFDSkEsT0FBT0EsQ0FBQ0EsU0FBU0EsQ0FBQ0EsS0FBS0EsQ0FBQ0EsWUFBWUEsQ0FBRUEsQ0FBQ0E7WUFDM0NBLENBQUNBO1FBQ0xBLENBQUNBOzs7T0FQQUo7SUFRTEEsV0FBQ0E7QUFBREEsQ0FoQ0EsQUFnQ0NBLElBQUE7QUFoQ1ksWUFBSSxPQWdDaEIsQ0FBQTtBQUVEO0lBQStCSyw2QkFBSUE7SUFDL0JBLG1CQUFZQSxZQUFtQkE7UUFDM0JDLGtCQUFNQTtZQUNGQSxJQUFJQSxFQUFDQSxjQUFXLENBQUM7U0FDcEJBLENBQUNBLENBQUNBO0lBQ1BBLENBQUNBO0lBQ0xELGdCQUFDQTtBQUFEQSxDQU5BLEFBTUNBLEVBTjhCLElBQUksRUFNbEM7QUFOWSxpQkFBUyxZQU1yQixDQUFBIiwiZmlsZSI6InRhc2tidWZmZXIuY2xhc3Nlcy5qcyIsInNvdXJjZXNDb250ZW50IjpbIi8vLyA8cmVmZXJlbmNlIHBhdGg9XCIuL3R5cGluZ3MvbWFpbi5kLnRzXCIgLz5cbmltcG9ydCBwbHVnaW5zID0gcmVxdWlyZShcIi4vdGFza2J1ZmZlci5wbHVnaW5zXCIpO1xuZXhwb3J0IGNsYXNzIFRhc2sge1xuICAgIHRhc2s6YW55O1xuICAgIGlkbGU6Ym9vbGVhbjtcbiAgICBidWZmZXJlZDpib29sZWFuO1xuICAgIGJ1ZmZlcmVkRm9yY2VkOmJvb2xlYW47XG4gICAgcnVubmluZzpib29sZWFuO1xuICAgIHByaXZhdGUgX3N0YXRlOnN0cmluZztcbiAgICBwcmVUYXNrOlRhc2s7XG4gICAgYWZ0ZXJUYXNrOlRhc2s7XG5cbiAgICBjb25zdHJ1Y3Rvcih0YXNrQXJnLG9wdGlvbnNBcmc/OntwcmVUYXNrPzpUYXNrLGFmdGVyVGFzaz86VGFza30pe1xuICAgICAgICB0aGlzLnRhc2sgPSB0YXNrQXJnO1xuICAgIH1cbiAgICB0cmlnZ2VyKCl7XG4gICAgICAgIHRoaXMucHJlVGFzay50YXNrKClcbiAgICAgICAgICAgIC50aGVuKHRoaXMudGFzaylcbiAgICAgICAgICAgIC50aGVuKHRoaXMuYWZ0ZXJUYXNrLnRhc2spO1xuICAgIH07XG4gICAgdHJpZ2dlckJ1ZmZlcmVkKCl7XG4gICAgICAgIHZhciBkb25lID0gcGx1Z2lucy5RLmRlZmVyKCk7XG4gICAgfVxuXG4gICAgZ2V0IHN0YXRlKCk6c3RyaW5nIHtcbiAgICAgICAgcmV0dXJuIHRoaXMuX3N0YXRlO1xuICAgIH1cbiAgICBzZXQgc3RhdGUoc3RhdGVBcmc6c3RyaW5nKXtcbiAgICAgICAgaWYgKHN0YXRlQXJnID09IFwibG9ja2VkXCIpe1xuICAgICAgICAgICAgdGhpcy5fc3RhdGUgPSBcImxvY2tlZFwiO1xuICAgICAgICB9IGVsc2Uge1xuICAgICAgICAgICAgcGx1Z2lucy5iZWF1dHlsb2cuZXJyb3IoXCJzdGF0ZSB0eXBlXCIgKTtcbiAgICAgICAgfVxuICAgIH1cbn1cblxuZXhwb3J0IGNsYXNzIFRhc2tDaGFpbiBleHRlbmRzIFRhc2sge1xuICAgIGNvbnN0cnVjdG9yKHRhc2tBcnJheUFyZzpUYXNrW10pe1xuICAgICAgICBzdXBlcih7XG4gICAgICAgICAgICB0YXNrOmZ1bmN0aW9uKCl7fVxuICAgICAgICB9KTtcbiAgICB9XG59Il0sInNvdXJjZVJvb3QiOiIvc291cmNlLyJ9

dist/taskbuffer.classes.task.d.ts

@@ -0,0 +1,37 @@
+import * as helpers from "./taskbuffer.classes.helpers";
+export interface ITaskFunction {
+    (x?: any): PromiseLike<any>;
+}
+export declare class Task {
+    name: string;
+    taskFunction: ITaskFunction;
+    buffered: boolean;
+    preTask: Task;
+    afterTask: Task;
+    running: boolean;
+    bufferRunner: helpers.BufferRunner;
+    cycleCounter: helpers.CycleCounter;
+    idle: boolean;
+    private _state;
+    constructor(optionsArg: {
+        taskFunction: ITaskFunction;
+        preTask?: Task;
+        afterTask?: Task;
+        buffered?: boolean;
+        bufferMax?: number;
+        name?: string;
+    });
+    /**
+     * trigger the task. Will trigger buffered if this.buffered is true
+     */
+    trigger(x?: any): PromiseLike<any>;
+    /**
+     * trigger task unbuffered.
+     */
+    triggerUnBuffered(x?: any): PromiseLike<any>;
+    /**
+     * trigger task buffered.
+     */
+    triggerBuffered(x?: any): PromiseLike<any>;
+    state: string;
+}

dist/taskbuffer.classes.task.js

@@ -0,0 +1,59 @@
+"use strict";
+const plugins = require("./taskbuffer.plugins");
+const helpers = require("./taskbuffer.classes.helpers");
+class Task {
+    constructor(optionsArg) {
+        // initialize by default
+        this.running = false;
+        this.bufferRunner = new helpers.BufferRunner(this);
+        this.cycleCounter = new helpers.CycleCounter(this);
+        this.idle = true;
+        this._state = "ready";
+        var options = optionsArg;
+        this.taskFunction = optionsArg.taskFunction;
+        this.preTask = options.preTask;
+        this.afterTask = options.afterTask;
+        this.idle = !this.running;
+        this.buffered = options.buffered;
+        this.bufferRunner.setBufferMax(options.bufferMax);
+        this.name = options.name;
+    }
+    /**
+     * trigger the task. Will trigger buffered if this.buffered is true
+     */
+    trigger(x) {
+        if (this.buffered) {
+            return this.triggerBuffered(x);
+        }
+        else {
+            return this.triggerUnBuffered(x);
+        }
+        ;
+    }
+    ;
+    /**
+     * trigger task unbuffered.
+     */
+    triggerUnBuffered(x) {
+        return helpers.runTask(this, { x: x });
+    }
+    /**
+     * trigger task buffered.
+     */
+    triggerBuffered(x) {
+        return this.bufferRunner.trigger(x);
+    }
+    get state() {
+        return this._state;
+    }
+    set state(stateArg) {
+        if (stateArg == "locked") {
+            this._state = "locked";
+        }
+        else {
+            plugins.beautylog.error("state type " + stateArg.blue + " could not be set");
+        }
+    }
+}
+exports.Task = Task;
+//# sourceMappingURL=data:application/json;base64,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

dist/taskbuffer.classes.taskchain.d.ts

@@ -0,0 +1,15 @@
+import { Task } from "./taskbuffer.classes.task";
+export declare class Taskchain extends Task {
+    taskArray: Task[];
+    private _oraObject;
+    constructor(optionsArg: {
+        taskArray: Task[];
+        name?: string;
+        log?: boolean;
+        buffered?: boolean;
+        bufferMax?: number;
+    });
+    addTask(taskArg: Task): void;
+    removeTask(taskArg: Task): void;
+    shiftTask(): void;
+}

dist/taskbuffer.classes.taskchain.js

@@ -0,0 +1,54 @@
+"use strict";
+const plugins = require("./taskbuffer.plugins");
+const taskbuffer_classes_task_1 = require("./taskbuffer.classes.task");
+class Taskchain extends taskbuffer_classes_task_1.Task {
+    constructor(optionsArg) {
+        let options = plugins.lodash.merge({
+            name: "unnamed Taskchain",
+            log: false
+        }, optionsArg, {
+            taskFunction: (x) => {
+                let done = plugins.Q.defer(); // this is the starting Deferred object 
+                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(x)
+                            .then((x) => {
+                            plugins.beautylog.ok(this.taskArray[taskCounter].name);
+                            taskCounter++;
+                            iterateTasks(x);
+                        });
+                    }
+                    else {
+                        this._oraObject.endOk("Taskchain \"" + this.name + "\" completed successfully");
+                        done.resolve(x);
+                    }
+                };
+                iterateTasks(x);
+                return done.promise;
+            }
+        });
+        super(options);
+        this.taskArray = optionsArg.taskArray;
+        this._oraObject = new plugins.beautylog.Ora("Taskchain idle", "blue");
+        if (optionsArg.log === true) {
+            this._oraObject.start();
+        }
+        ;
+    }
+    addTask(taskArg) {
+        this.taskArray.push(taskArg);
+    }
+    ;
+    removeTask(taskArg) {
+        //TODO
+    }
+    ;
+    shiftTask() {
+    }
+    ;
+}
+exports.Taskchain = Taskchain;
+;
+//# sourceMappingURL=data:application/json;base64,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

dist/taskbuffer.classes.taskparallel.d.ts

@@ -0,0 +1,7 @@
+import { Task } from "./taskbuffer.classes.task";
+export declare class Taskparallel extends Task {
+    taskArray: Task[];
+    constructor(optionsArg: {
+        taskArray: Task[];
+    });
+}

dist/taskbuffer.classes.taskparallel.js

@@ -0,0 +1,23 @@
+"use strict";
+const plugins = require("./taskbuffer.plugins");
+const taskbuffer_classes_task_1 = require("./taskbuffer.classes.task");
+class Taskparallel extends taskbuffer_classes_task_1.Task {
+    constructor(optionsArg) {
+        let options = plugins.lodash.merge(optionsArg, {
+            taskFunction: () => {
+                let done = plugins.Q.defer();
+                let promiseArray = []; // stores promises of all tasks, since they run in parallel
+                this.taskArray.forEach(function (taskArg) {
+                    promiseArray.push(taskArg.trigger());
+                });
+                plugins.Q.all(promiseArray)
+                    .then(done.resolve);
+                return done.promise;
+            }
+        });
+        super(options);
+        this.taskArray = optionsArg.taskArray;
+    }
+}
+exports.Taskparallel = Taskparallel;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5jbGFzc2VzLnRhc2twYXJhbGxlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3Rhc2tidWZmZXIuY2xhc3Nlcy50YXNrcGFyYWxsZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE1BQVksT0FBTyxXQUFNLHNCQUN6QixDQUFDLENBRDhDO0FBRS9DLDBDQUFxQiwyQkFFckIsQ0FBQyxDQUYrQztBQUVoRCwyQkFBa0MsOEJBQUk7SUFFbEMsWUFBWSxVQUVYO1FBQ0csSUFBSSxPQUFPLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQzlCLFVBQVUsRUFDVjtZQUNJLFlBQVksRUFBRTtnQkFDVixJQUFJLElBQUksR0FBRyxPQUFPLENBQUMsQ0FBQyxDQUFDLEtBQUssRUFBRSxDQUFDO2dCQUM3QixJQUFJLFlBQVksR0FBc0IsRUFBRSxDQUFDLENBQUMsMkRBQTJEO2dCQUNyRyxJQUFJLENBQUMsU0FBUyxDQUFDLE9BQU8sQ0FBQyxVQUFVLE9BQU87b0JBQ3BDLFlBQVksQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7Z0JBQ3pDLENBQUMsQ0FBQyxDQUFBO2dCQUNGLE9BQU8sQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLFlBQVksQ0FBQztxQkFDdEIsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztnQkFDeEIsTUFBTSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUM7WUFDeEIsQ0FBQztTQUNKLENBQ0osQ0FBQztRQUNGLE1BQU0sT0FBTyxDQUFDLENBQUM7UUFDZixJQUFJLENBQUMsU0FBUyxHQUFHLFVBQVUsQ0FBQyxTQUFTLENBQUM7SUFDMUMsQ0FBQztBQUNMLENBQUM7QUF2Qlksb0JBQVksZUF1QnhCLENBQUEifQ==

dist/taskbuffer.classes.taskspace.d.ts

@@ -0,0 +1,2 @@
+export declare class Taskspace {
+}

dist/taskbuffer.classes.taskspace.js

@@ -0,0 +1,5 @@
+"use strict";
+class Taskspace {
+}
+exports.Taskspace = Taskspace;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5jbGFzc2VzLnRhc2tzcGFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3Rhc2tidWZmZXIuY2xhc3Nlcy50YXNrc3BhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUdBO0FBRUEsQ0FBQztBQUZZLGlCQUFTLFlBRXJCLENBQUEifQ==

dist/taskbuffer.plugins.d.ts

@@ -0,0 +1,5 @@
+import "typings-global";
+export import beautylog = require("beautylog");
+export import Q = require("q");
+export import lodash = require("lodash");
+export import rxjs = require("rxjs");

dist/taskbuffer.plugins.js

@@ -1,10 +1,7 @@
-#!/usr/bin/env node
-
-/// <reference path="./typings/main.d.ts" />
-var plugins = {
-    beautylog: require("beautylog"),
-    Q: require("q")
-};
-module.exports = plugins;
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRhc2tidWZmZXIucGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSw0Q0FBNEM7QUFDNUMsSUFBSSxPQUFPLEdBQUc7SUFDVixTQUFTLEVBQUUsT0FBTyxDQUFDLFdBQVcsQ0FBQztJQUMvQixDQUFDLEVBQUUsT0FBTyxDQUFDLEdBQUcsQ0FBQztDQUNsQixDQUFDO0FBQ0YsaUJBQVMsT0FBTyxDQUFDIiwiZmlsZSI6InRhc2tidWZmZXIucGx1Z2lucy5qcyIsInNvdXJjZXNDb250ZW50IjpbIi8vLyA8cmVmZXJlbmNlIHBhdGg9XCIuL3R5cGluZ3MvbWFpbi5kLnRzXCIgLz5cbnZhciBwbHVnaW5zID0ge1xuICAgIGJlYXV0eWxvZzogcmVxdWlyZShcImJlYXV0eWxvZ1wiKSxcbiAgICBROiByZXF1aXJlKFwicVwiKVxufTtcbmV4cG9ydCA9IHBsdWdpbnM7XG4iXSwic291cmNlUm9vdCI6Ii9zb3VyY2UvIn0=
+"use strict";
+require("typings-global");
+exports.beautylog = require("beautylog");
+exports.Q = require("q");
+exports.lodash = require("lodash");
+exports.rxjs = require("rxjs");
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5wbHVnaW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvdGFza2J1ZmZlci5wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxRQUFPLGdCQUNQLENBQUMsQ0FEc0I7QUFDVCxpQkFBUyxXQUFXLFdBQVcsQ0FBQyxDQUFDO0FBQ2pDLFNBQUMsV0FBVyxHQUFHLENBQUMsQ0FBQztBQUNqQixjQUFNLFdBQVUsUUFBUSxDQUFDLENBQUM7QUFDMUIsWUFBSSxXQUFXLE1BQU0sQ0FBQyxDQUFDIn0=

dist/taskbuffer.promisechain.js

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-
-/// <reference path="./typings/main.d.ts" /> 
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRhc2tidWZmZXIucHJvbWlzZWNoYWluLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDRDQUE0QyIsImZpbGUiOiJ0YXNrYnVmZmVyLnByb21pc2VjaGFpbi5qcyIsInNvdXJjZXNDb250ZW50IjpbIi8vLyA8cmVmZXJlbmNlIHBhdGg9XCIuL3R5cGluZ3MvbWFpbi5kLnRzXCIgLz4iXSwic291cmNlUm9vdCI6Ii9zb3VyY2UvIn0=

dist/taskbuffer.task.js

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-
-/// <reference path="./typings/main.d.ts" />
-var classes = require("./taskbuffer.classes");
-var task = function (taskArg, options) {
-    var task = taskArg;
-    return new classes.Task(task, options);
-};
-module.exports = task;
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRhc2tidWZmZXIudGFzay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSw0Q0FBNEM7QUFDNUMsSUFBTyxPQUFPLFdBQVcsc0JBQXNCLENBQUMsQ0FBQztBQUNqRCxJQUFJLElBQUksR0FBRyxVQUFTLE9BQU8sRUFBQyxPQUFRO0lBQ2hDLElBQUksSUFBSSxHQUFHLE9BQU8sQ0FBQTtJQUNsQixNQUFNLENBQUMsSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksRUFBQyxPQUFPLENBQUMsQ0FBQztBQUMxQyxDQUFDLENBQUM7QUFDRixpQkFBUyxJQUFJLENBQUMiLCJmaWxlIjoidGFza2J1ZmZlci50YXNrLmpzIiwic291cmNlc0NvbnRlbnQiOlsiLy8vIDxyZWZlcmVuY2UgcGF0aD1cIi4vdHlwaW5ncy9tYWluLmQudHNcIiAvPlxuaW1wb3J0IGNsYXNzZXMgPSByZXF1aXJlKFwiLi90YXNrYnVmZmVyLmNsYXNzZXNcIik7XG52YXIgdGFzayA9IGZ1bmN0aW9uKHRhc2tBcmcsb3B0aW9ucz8pe1xuICAgIHZhciB0YXNrID0gdGFza0FyZ1xuICAgIHJldHVybiBuZXcgY2xhc3Nlcy5UYXNrKHRhc2ssb3B0aW9ucyk7XG59O1xuZXhwb3J0ID0gdGFzazsiXSwic291cmNlUm9vdCI6Ii9zb3VyY2UvIn0=

dist/taskbuffer.taskchain.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-
-/// <reference path="./typings/main.d.ts" />
-var classes = require("./taskbuffer.classes");
-var taskChain = function (taskArrayArg) {
-    return new classes.TaskChain(taskArrayArg);
-};
-module.exports = taskChain;
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRhc2tidWZmZXIudGFza2NoYWluLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDRDQUE0QztBQUM1QyxJQUFPLE9BQU8sV0FBVyxzQkFBc0IsQ0FBQyxDQUFDO0FBQ2pELElBQUksU0FBUyxHQUFHLFVBQVMsWUFBMkI7SUFFaEQsTUFBTSxDQUFDLElBQUksT0FBTyxDQUFDLFNBQVMsQ0FBQyxZQUFZLENBQUMsQ0FBQztBQUMvQyxDQUFDLENBQUM7QUFDRixpQkFBUyxTQUFTLENBQUMiLCJmaWxlIjoidGFza2J1ZmZlci50YXNrY2hhaW4uanMiLCJzb3VyY2VzQ29udGVudCI6WyIvLy8gPHJlZmVyZW5jZSBwYXRoPVwiLi90eXBpbmdzL21haW4uZC50c1wiIC8+XG5pbXBvcnQgY2xhc3NlcyA9IHJlcXVpcmUoXCIuL3Rhc2tidWZmZXIuY2xhc3Nlc1wiKTtcbnZhciB0YXNrQ2hhaW4gPSBmdW5jdGlvbih0YXNrQXJyYXlBcmc6Y2xhc3Nlcy5UYXNrW10pe1xuXG4gICAgcmV0dXJuIG5ldyBjbGFzc2VzLlRhc2tDaGFpbih0YXNrQXJyYXlBcmcpO1xufTtcbmV4cG9ydCA9IHRhc2tDaGFpbjtcbiJdLCJzb3VyY2VSb290IjoiL3NvdXJjZS8ifQ==

npmextra.json

@@ -0,0 +1,5 @@
+{
+  "npmts":{
+    "mode":"default"
+  }
+}

npmts.json

@@ -1,4 +0,0 @@
-{
-  "mode":"default",
-  "coveralls":true
-}

package.json

@@ -1,14 +1,15 @@
 {
   "name": "taskbuffer",
-  "version": "0.0.1",
-  "description": "manage triggers and execution of tasks with promises",
+  "version": "1.0.4",
+  "description": "flexible task management. TypeScript ready!",
   "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
   "scripts": {
     "test": "(npmts)"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/pushrocks/taskbuffer.git"
+    "url": "git+https://gitlab.com/pushrocks/taskbuffer.git"
   },
   "keywords": [
     "gulp",
@@ -19,15 +20,21 @@
   "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": {
-    "beautylog": "^2.1.1",
-    "npmts": "^3.0.2",
-    "q": "^1.4.1"
+    "@types/lodash": "^0.0.28",
+    "@types/q": "^0.0.27",
+    "beautylog": "^5.0.18",
+    "lodash": "^4.14.1",
+    "q": "^1.4.1",
+    "rxjs": "^5.0.0-beta.10",
+    "typings-global": "^1.0.6"
   },
   "devDependencies": {
-    "should": "^8.2.2"
+    "npmts-g": "^5.2.8",
+    "should": "^10.0.0",
+    "typings-test": "^1.0.1"
   }
 }

test/test.d.ts

@@ -0,0 +1 @@
+import "typings-test";

test/test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"test.js","sourceRoot":"","sources":["test.ts"],"names":[],"mappings":"AAAA,gDAAgD;AAChD,IAAI,UAAU,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAC7C,QAAQ,CAAC,iBAAiB,EAAC;IACvB,QAAQ,CAAC,OAAO,EAAC;QACb,EAAE,CAAC,0BAA0B,EAAC;YAC1B,IAAI,MAAM,GAAG,UAAU,CAAC,IAAI,EAAE,CAAC;QACnC,CAAC,CAAC,CAAA;IACN,CAAC,CAAC,CAAC;AACP,CAAC,CAAC,CAAC"}

test/test.ts

@@ -1,9 +1,202 @@
-/// <reference path="../ts/typings/main.d.ts" />
-var taskbuffer = require("../dist/index.js");
-describe("taskbuffer.task",function(){
-    describe(".task",function(){
-        it("should return a new task",function(){
-            var myTask = taskbuffer.task();
+import "typings-test";
+import taskbuffer = require("../dist/index");
+import should = require("should");
+import q = require("q")
+
+// setup some testData to work with
+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 () {
+        let done = q.defer();
+        console.log("preTask executed");
+        done.resolve();
+        return done.promise;
+    },
+    preTask: testTask
+});
+
+
+// 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 () {
+            testTask.should.be.instanceof(taskbuffer.Task);
+        });
+        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 () {
+            testTask.running.should.be.type("boolean");
+            testTask.running.should.be.false();
+        });
+        it("testTask.trigger() should return Promise", function () {
+            testTask.trigger().should.be.Promise();
+        });
+        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 });
+            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 () {
+        let testTaskchain;
+        let testTaskArray = [
+            new taskbuffer.Task({
+                name: "task1",
+                taskFunction: function () {
+                    let done = q.defer();
+                    setTimeout(done.resolve, 2000);
+                    return done.promise;
+                }
+            }),
+            new taskbuffer.Task({
+                name: "task2",
+                taskFunction: function () {
+                    let done = q.defer();
+                    setTimeout(done.resolve, 2000);
+                    return done.promise;
+                }
+            }),
+        ];
+        it("should run tasks in sequence", function (done) {
+            this.timeout(5000);
+            testTaskchain = new taskbuffer.Taskchain({
+                name: "Taskchain1",
+                taskArray: testTaskArray
+            });
+            testTaskchain.trigger().then(done);
+        });
+    });
+    describe("taskparallel", function () {
+        it("should run in Parallel", function (done) {
+            this.timeout("7000");
+            let testTaskparallel = new taskbuffer.Taskparallel({
+                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,11 +1,7 @@
-/// <reference path="./typings/main.d.ts" />
-import plugins = require("./taskbuffer.plugins");
-import classes = require("./taskbuffer.classes");
-import task = require("./taskbuffer.task");
-import taskchain = require("./taskbuffer.taskchain");
+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";
 
-var taskbuffer = {
-    task: task
-};
-
-export = taskbuffer;
+// import for naming only
+import "./taskbuffer.classes.helpers"

ts/taskbuffer.classes.helpers.ts

@@ -0,0 +1,155 @@
+import plugins = require("./taskbuffer.plugins");
+import { Task, ITaskFunction } from "./taskbuffer.classes.task";
+
+export let emptyTaskFunction: ITaskFunction = function (x) {
+    let done = plugins.Q.defer();
+    done.resolve();
+    return done.promise;
+};
+
+export let isTask = function (taskArg): boolean {
+    if (
+        taskArg instanceof Task
+        && typeof taskArg.task === "function"
+    ) {
+        return true;
+    } else {
+        return false;
+    }
+};
+
+
+export let isTaskTouched = (taskArg: Task, touchedTasksArray: Task[]): boolean => {
+    let result = false;
+    for (let keyArg in touchedTasksArray) {
+        if (taskArg === touchedTasksArray[keyArg]) {
+            result = true;
+        }
+    }
+    return result;
+}
+
+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 });
+
+    // 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, {x:x, touchedTasksArray: touchedTasksArray })
+            } else {
+                let done2 = plugins.Q.defer();
+                done2.resolve(x);
+                return done2.promise;
+            }
+        })
+        .then(x => {
+            return taskArg.taskFunction(x);
+        })
+        .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(x);
+                return done2.promise;
+            }
+        })
+        .then(x => {
+            done.resolve(x);
+        });
+    localDeferred.resolve();
+    return done.promise;
+};
+
+
+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

@@ -0,0 +1,77 @@
+import * as plugins from "./taskbuffer.plugins"
+import * as helpers from "./taskbuffer.classes.helpers"
+
+
+export interface ITaskFunction {
+    (x?:any):PromiseLike<any>;
+}
+
+export class Task {
+    name: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,
+        afterTask?:Task,
+        buffered?:boolean,
+        bufferMax?:number,
+        name?:string
+    }){
+        var options = optionsArg;
+        this.taskFunction = optionsArg.taskFunction;
+        this.preTask = options.preTask;
+        this.afterTask = options.afterTask;
+        this.idle = !this.running;
+        this.buffered = options.buffered;
+        this.bufferRunner.setBufferMax(options.bufferMax);
+        this.name = options.name;
+    }
+    
+    /**
+     * trigger the task. Will trigger buffered if this.buffered is true
+     */
+    trigger(x?):PromiseLike<any> {
+        if(this.buffered) {
+            return this.triggerBuffered(x)
+        }
+        else {
+            return this.triggerUnBuffered(x);
+        };
+    };
+
+    /**
+     * trigger task unbuffered.
+     */
+    triggerUnBuffered(x?):PromiseLike<any>{
+        return helpers.runTask(this,{x:x});
+    }
+    
+    /**
+     * trigger task buffered.
+     */
+    triggerBuffered(x?):PromiseLike<any>{
+        return this.bufferRunner.trigger(x);
+    }
+
+    get state():string {
+        return this._state;
+    }
+    set state(stateArg:string){
+        if (stateArg == "locked"){
+            this._state = "locked";
+        } else {
+            plugins.beautylog.error("state type " + stateArg.blue + " could not be set");
+        }
+    }
+}

ts/taskbuffer.classes.taskchain.ts

@@ -0,0 +1,60 @@
+import * as plugins from "./taskbuffer.plugins";
+import {Task} from "./taskbuffer.classes.task";
+import helpers = require("./taskbuffer.classes.helpers");
+
+export class Taskchain extends Task {
+    taskArray:Task[];
+    private _oraObject:plugins.beautylog.Ora;
+    constructor(optionsArg:{
+        taskArray:Task[],
+        name?:string,
+        log?:boolean,
+        buffered?:boolean,
+        bufferMax?:number
+    }){
+        let options = plugins.lodash.merge(
+            {
+                name:"unnamed Taskchain",
+                log:false
+            },
+            optionsArg,
+            {
+                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; // 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(x)
+                                .then((x)=>{
+                                    plugins.beautylog.ok(this.taskArray[taskCounter].name);
+                                    taskCounter++;
+                                    iterateTasks(x);
+                                });     
+                        } else {
+                            this._oraObject.endOk("Taskchain \"" + this.name +  "\" completed successfully");
+                            done.resolve(x);
+                        }
+                    };
+                    iterateTasks(x);
+                    return done.promise;
+                }
+            }
+        );
+        super(options);
+        this.taskArray = optionsArg.taskArray;
+        this._oraObject = new plugins.beautylog.Ora("Taskchain idle","blue");
+        if(optionsArg.log === true){
+            this._oraObject.start();
+        };
+    }
+    addTask(taskArg:Task){
+        this.taskArray.push(taskArg);
+    };
+    removeTask(taskArg:Task){
+        //TODO
+    };
+    shiftTask(){
+        
+    };
+};

ts/taskbuffer.classes.taskparallel.ts

@@ -0,0 +1,29 @@
+import * as plugins from "./taskbuffer.plugins"
+import * as helpers from "./taskbuffer.classes.helpers"
+import { Task } from "./taskbuffer.classes.task"
+
+export class Taskparallel extends Task {
+    taskArray: Task[];
+    constructor(optionsArg: {
+        taskArray: Task[]
+    }){
+        let options = plugins.lodash.merge(
+            optionsArg,
+            {
+                taskFunction: () => {
+                    let done = plugins.Q.defer();
+                    let promiseArray:PromiseLike<any>[] = []; // stores promises of all tasks, since they run in parallel
+                    this.taskArray.forEach(function (taskArg) {
+                        promiseArray.push(taskArg.trigger());
+                    })
+                    plugins.Q.all(promiseArray)
+                        .then(done.resolve);
+                    return done.promise;
+                }
+            }
+        );
+        super(options);
+        this.taskArray = optionsArg.taskArray;
+    }
+}
+

ts/taskbuffer.classes.taskspace.ts

@@ -0,0 +1,6 @@
+import * as plugins from "./taskbuffer.plugins"
+import * as helpers from "./taskbuffer.classes.helpers"
+
+export class Taskspace {
+    
+}

ts/taskbuffer.classes.ts

@@ -1,43 +0,0 @@
-/// <reference path="./typings/main.d.ts" />
-import plugins = require("./taskbuffer.plugins");
-export class Task {
-    task:any;
-    idle:boolean;
-    buffered:boolean;
-    bufferedForced:boolean;
-    running:boolean;
-    private _state:string;
-    preTask:Task;
-    afterTask:Task;
-
-    constructor(taskArg,optionsArg?:{preTask?:Task,afterTask?:Task}){
-        this.task = taskArg;
-    }
-    trigger(){
-        this.preTask.task()
-            .then(this.task)
-            .then(this.afterTask.task);
-    };
-    triggerBuffered(){
-        var done = plugins.Q.defer();
-    }
-
-    get state():string {
-        return this._state;
-    }
-    set state(stateArg:string){
-        if (stateArg == "locked"){
-            this._state = "locked";
-        } else {
-            plugins.beautylog.error("state type" );
-        }
-    }
-}
-
-export class TaskChain extends Task {
-    constructor(taskArrayArg:Task[]){
-        super({
-            task:function(){}
-        });
-    }
-}

ts/taskbuffer.plugins.ts

@@ -1,6 +1,5 @@
-/// <reference path="./typings/main.d.ts" />
-var plugins = {
-    beautylog: require("beautylog"),
-    Q: require("q")
-};
-export = plugins;
+import "typings-global"
+export import beautylog = require("beautylog");
+export import Q = require("q");
+export import lodash= require("lodash");
+export import rxjs = require("rxjs");

ts/taskbuffer.promisechain.ts

@@ -1 +0,0 @@
-/// <reference path="./typings/main.d.ts" />

ts/taskbuffer.task.ts

@@ -1,7 +0,0 @@
-/// <reference path="./typings/main.d.ts" />
-import classes = require("./taskbuffer.classes");
-var task = function(taskArg,options?){
-    var task = taskArg
-    return new classes.Task(task,options);
-};
-export = task;

ts/taskbuffer.taskchain.ts

@@ -1,7 +0,0 @@
-/// <reference path="./typings/main.d.ts" />
-import classes = require("./taskbuffer.classes");
-var taskChain = function(taskArrayArg:classes.Task[]){
-
-    return new classes.TaskChain(taskArrayArg);
-};
-export = taskChain;

ts/typings.json

@@ -1,7 +0,0 @@
-{
-  "ambientDependencies": {
-    "node": "github:DefinitelyTyped/DefinitelyTyped/node/node.d.ts",
-    "mocha": "github:Bartvds/tsd-deftools/typings/DefinitelyTyped/mocha/mocha.d.ts",
-    "colors": "github:DefinitelyTyped/DefinitelyTyped/colors/colors.d.ts"
-  }
-}