1.0.0

.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

.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 organization for gulp. TypeScript ready!
 
 ## Status
 [![Coverage Status](https://coveralls.io/repos/github/pushrocks/taskbuffer/badge.svg?branch=master)](https://coveralls.io/github/pushrocks/taskbuffer?branch=master)
@@ -12,7 +12,7 @@ npm install taskbuffer --save
 
 ## Concepts 
 
-#### Task
+### 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)
@@ -27,6 +27,30 @@ npm install taskbuffer --save
 * 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.
 
-#### Taskchain
-* Multiple Tasks can be combined in a bigger task using a Taskchain. Taskchain extends Task.
+### 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

@@ -1,2 +1,5 @@
-export * from "./taskbuffer.classes";
+export { Task } 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,10 +1,12 @@
 "use strict";
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-/// <reference path="./typings/main.d.ts" />
-__export(require("./taskbuffer.classes"));
+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;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7QUFBQSw0Q0FBNEM7QUFDNUMsaUJBQWMsc0JBQXNCLENBQUMsRUFBQTtBQUVyQyx5QkFBeUI7QUFDekIsUUFBTyw4QkFBOEIsQ0FBQyxDQUFEIiwiZmlsZSI6ImluZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOlsiLy8vIDxyZWZlcmVuY2UgcGF0aD1cIi4vdHlwaW5ncy9tYWluLmQudHNcIiAvPlxyXG5leHBvcnQgKiBmcm9tIFwiLi90YXNrYnVmZmVyLmNsYXNzZXNcIjtcclxuXHJcbi8vIGltcG9ydCBmb3IgbmFtaW5nIG9ubHlcclxuaW1wb3J0IFwiLi90YXNrYnVmZmVyLmNsYXNzZXMuaGVscGVyc1wiIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsd0NBQW1CLDJCQUEyQixDQUFDO0FBQXZDLDhDQUF1QztBQUMvQyw2Q0FBd0IsZ0NBQWdDLENBQUM7QUFBakQsNkRBQWlEO0FBQ3pELGdEQUEyQixtQ0FBbUMsQ0FBQztBQUF2RCxzRUFBdUQ7QUFDL0QsNkNBQXdCLGdDQUFnQyxDQUFDO0FBQWpELDZEQUFpRDtBQUV6RCx5QkFBeUI7QUFDekIsUUFBTyw4QkFBOEIsQ0FBQyxDQUFEIn0=

dist/taskbuffer.classes.d.ts

@@ -1,2 +0,0 @@
-export * from "./taskbuffer.classes.task";
-export * from "./taskbuffer.classes.taskchain";

dist/taskbuffer.classes.helpers.d.ts

@@ -1,9 +1,10 @@
-import { Task } from "./taskbuffer.classes";
-export declare let emptyTaskFunction: () => any;
+/// <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?: {
     touchedTasksArray: Task[];
-}) => any;
+}) => plugins.Q.Promise<{}>;
 export declare let runBufferedTask: (taskArg: Task) => void;
-export declare let updateTaskStatus: (taskArg: any, statusArg: string) => void;

dist/taskbuffer.classes.js

@@ -1,8 +0,0 @@
-"use strict";
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-__export(require("./taskbuffer.classes.task"));
-__export(require("./taskbuffer.classes.taskchain"));
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRhc2tidWZmZXIuY2xhc3Nlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBQUEsaUJBQWMsMkJBQ2QsQ0FBQyxFQUR3QztBQUN6QyxpQkFBYyxnQ0FDZCxDQUFDLEVBRDZDIiwiZmlsZSI6InRhc2tidWZmZXIuY2xhc3Nlcy5qcyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL3Rhc2tidWZmZXIuY2xhc3Nlcy50YXNrXCJcclxuZXhwb3J0ICogZnJvbSBcIi4vdGFza2J1ZmZlci5jbGFzc2VzLnRhc2tjaGFpblwiXHJcbiJdfQ==

dist/taskbuffer.classes.task.d.ts

@@ -1,7 +1,13 @@
+/// <reference types="q" />
+import * as plugins from "./taskbuffer.plugins";
+export interface ITaskFunction {
+    (): PromiseLike<any>;
+}
 export declare class Task {
     name: string;
     task: any;
     running: boolean;
+    runningBuffered: boolean;
     idle: boolean;
     buffered: boolean;
     bufferCounter: number;
@@ -11,15 +17,24 @@ export declare class Task {
     preTask: Task;
     afterTask: Task;
     constructor(optionsArg: {
-        taskFunction: any;
+        taskFunction: ITaskFunction;
         preTask?: Task;
         afterTask?: Task;
         buffered?: boolean;
         bufferMax?: number;
         name?: string;
     });
-    trigger(): any;
-    triggerUnBuffered(): any;
-    triggerBuffered(): any;
+    /**
+     * trigger the task. Will trigger buffered if this.buffered is true
+     */
+    trigger(): plugins.Q.Promise<{}>;
+    /**
+     * trigger task unbuffered.
+     */
+    triggerUnBuffered(): plugins.Q.Promise<{}>;
+    /**
+     * trigger task buffered.
+     */
+    triggerBuffered(): plugins.Q.Promise<{}>;
     state: string;
 }

dist/taskbuffer.classes.taskchain.d.ts

@@ -1,4 +1,4 @@
-import { Task } from "./taskbuffer.classes";
+import { Task } from "./taskbuffer.classes.task";
 export declare class Taskchain extends Task {
     taskArray: Task[];
     private _oraObject;

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

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

dist/taskbuffer.plugins.d.ts

@@ -1,3 +1,5 @@
+import "typings-global";
 export import beautylog = require("beautylog");
-export declare let Q: any;
-export declare let lodash: any;
+export import Q = require("q");
+export import lodash = require("lodash");
+export import rxjs = require("rxjs");

dist/taskbuffer.plugins.js

@@ -1,7 +1,7 @@
 "use strict";
-/// <reference path="./typings/main.d.ts" />
+require("typings-global");
 exports.beautylog = require("beautylog");
 exports.Q = require("q");
 exports.lodash = require("lodash");
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRhc2tidWZmZXIucGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsNENBQTRDO0FBQzlCLGlCQUFTLFdBQVcsV0FBVyxDQUFDLENBQUM7QUFDcEMsU0FBQyxHQUFHLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNqQixjQUFNLEdBQUUsT0FBTyxDQUFDLFFBQVEsQ0FBQyxDQUFDIiwiZmlsZSI6InRhc2tidWZmZXIucGx1Z2lucy5qcyIsInNvdXJjZXNDb250ZW50IjpbIi8vLyA8cmVmZXJlbmNlIHBhdGg9XCIuL3R5cGluZ3MvbWFpbi5kLnRzXCIgLz5cclxuZXhwb3J0IGltcG9ydCBiZWF1dHlsb2cgPSByZXF1aXJlKFwiYmVhdXR5bG9nXCIpO1xyXG5leHBvcnQgbGV0IFEgPSByZXF1aXJlKFwicVwiKTtcclxuZXhwb3J0IGxldCBsb2Rhc2g9IHJlcXVpcmUoXCJsb2Rhc2hcIik7XHJcbiJdfQ==
+exports.rxjs = require("rxjs");
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5wbHVnaW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvdGFza2J1ZmZlci5wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxRQUFPLGdCQUNQLENBQUMsQ0FEc0I7QUFDVCxpQkFBUyxXQUFXLFdBQVcsQ0FBQyxDQUFDO0FBQ2pDLFNBQUMsV0FBVyxHQUFHLENBQUMsQ0FBQztBQUNqQixjQUFNLFdBQVUsUUFBUSxDQUFDLENBQUM7QUFDMUIsWUFBSSxXQUFXLE1BQU0sQ0FBQyxDQUFDIn0=

npmextra.json

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

npmts.json

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

package.json

@@ -1,8 +1,9 @@
 {
   "name": "taskbuffer",
-  "version": "0.1.0",
-  "description": "manage triggers and execution of tasks with promises",
+  "version": "1.0.0",
+  "description": "Flexible task organization for gulp. TypeScript ready!",
   "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
   "scripts": {
     "test": "(npmts)"
   },
@@ -23,14 +24,17 @@
   },
   "homepage": "https://github.com/pushrocks/taskbuffer#readme",
   "dependencies": {
-    "beautylog": "^5.0.0",
-    "lodash": "^4.12.0",
-    "projectinfo": "1.0.1",
+    "@types/lodash": "^0.0.28",
+    "@types/q": "^0.0.27",
+    "beautylog": "^5.0.18",
+    "lodash": "^4.14.1",
     "q": "^1.4.1",
-    "rx": "^4.1.0"
+    "rxjs": "^5.0.0-beta.10",
+    "typings-global": "^1.0.6"
   },
   "devDependencies": {
-    "should": "^8.3.1",
-    "npmts": "^5.1.5"
+    "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,eAAe,CAAC,CAAC;AAC1C,IAAI,OAAO,GAAG,OAAO,CAAC,4BAA4B,CAAC,CAAC;AACpD,IAAI,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AAC/B,QAAQ,CAAC,YAAY,EAAC;IAClB,QAAQ,CAAC,SAAS,EAAC;QACf,IAAI,QAAQ,CAAC;QACb,EAAE,CAAC,0CAA0C,EAAC;YAC1C,QAAQ,GAAG,UAAU,CAAC,IAAI,EAAE,CAAC;QACjC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,qCAAqC,EAAC;YACrC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAChD,CAAC,CAAC,CAAC;QACH,EAAE,CAAC,uBAAuB,EAAC;YACvB,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA,CAAC;gBAChB,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;YACjD,CAAC;QACL,CAAC,CAAC,CAAC;QACH,EAAE,CAAC,sDAAsD,EAAC;YACtD,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAC3C,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC;QACvC,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;AACP,CAAC,CAAC,CAAC"}

test/test.ts

@@ -1,21 +1,22 @@
-/// <reference path="../ts/typings/main.d.ts" />
+import "typings-test";
 import taskbuffer = require("../dist/index");
 let should = require("should");
-let plugins = {
-    q: require("q")
-}
+import q = require("q")
 
 // setup some testData to work with
 let testTask:taskbuffer.Task;
 let testTaskFunction = function(){
-    let done = plugins.q.defer();
+    let done = q.defer();
     console.log("main function executed!")
     done.resolve();
     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
 });
@@ -56,29 +57,74 @@ describe("taskbuffer",function(){
             new taskbuffer.Task({
                 name:"task1",
                 taskFunction:function(){
-                    let done = plugins.q.defer();
-                    console.log("Task1 run");
-                    done.resolve();
+                    let done = q.defer();
+                    setTimeout(done.resolve,2000);
                     return done.promise;
                 }
             }),
             new taskbuffer.Task({
                 name:"task2",
                 taskFunction: function(){
-                    let done = plugins.q.defer();
-                    console.log("Task2 run");
-                    done.resolve();
+                    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(){
+        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){
+            this.timeout("7000");
+            let testTaskparallel = new taskbuffer.Taskparallel({
+                taskArray:[task1,task2,task3]
+            });
+            testTaskparallel.trigger().then(() => {
+                done();
+            });
+        })
+    })
 });

ts/index.ts

@@ -1,5 +1,7 @@
-/// <reference path="./typings/main.d.ts" />
-export * from "./taskbuffer.classes";
+export {Task} from "./taskbuffer.classes.task";
+export {Taskchain} from "./taskbuffer.classes.taskchain";
+export {Taskparallel} from "./taskbuffer.classes.taskparallel";
+export {Taskspace} from "./taskbuffer.classes.taskspace";
 
 // import for naming only
 import "./taskbuffer.classes.helpers"

ts/taskbuffer.classes.helpers.ts

@@ -1,8 +1,7 @@
-/// <reference path="./typings/main.d.ts" />
 import plugins = require("./taskbuffer.plugins");
-import {Task} from "./taskbuffer.classes"
+import {Task,ITaskFunction} from "./taskbuffer.classes.task";
 
-export let emptyTaskFunction = function(){
+export let emptyTaskFunction:ITaskFunction = function(){
     let done = plugins.Q.defer();
     done.resolve();
     return done.promise;
@@ -32,8 +31,8 @@ export let isTaskTouched = (taskArg:Task, touchedTasksArray:Task[]):boolean => {
 
 export let runTask = function(taskArg:Task,optionsArg:{touchedTasksArray:Task[]} = {touchedTasksArray:[]}){
     let done = plugins.Q.defer();
-    updateTaskStatus(taskArg,"running");
-    done.promise.then(function(){updateTaskStatus(taskArg,"idle")})
+    taskArg.running = true;
+    done.promise.then(function(){taskArg.running = false});
     let localDeferred = plugins.Q.defer();
     let touchedTasksArray:Task[];
     if(optionsArg.touchedTasksArray){
@@ -74,24 +73,12 @@ export let runTask = function(taskArg:Task,optionsArg:{touchedTasksArray:Task[]}
 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 let updateTaskStatus = (taskArg,statusArg:string) => {
-    switch (statusArg) {
-        case "running":
-            taskArg.running = true;
-            taskArg.idle = false;
-            break;
-        case "idle":
-            taskArg.running = false;
-            taskArg.idle = true;
-            break;
-        default:
-            throw new Error("status not recognised");
-    }
-}
+};

ts/taskbuffer.classes.task.ts

@@ -1,40 +1,47 @@
-/// <reference path="./typings/main.d.ts" />
 import * as plugins from "./taskbuffer.plugins"
 import * as helpers from "./taskbuffer.classes.helpers"
 
+
+export interface ITaskFunction {
+    ():PromiseLike<any>;
+}
+
 export class Task {
     name:string;
     task:any;
-    running:boolean;
-    idle:boolean;
-    buffered:boolean;
+    running:boolean = false;
+    runningBuffered:boolean = false;
+    idle:boolean = true;
+    buffered:boolean = false;
     bufferCounter:number;
-    bufferMax:number;
-    private _counterTriggerAbsolute:number;
+    bufferMax:number = 1;
+    private _counterTriggerAbsolute:number = 0;
     private _state:string;
     preTask:Task;
     afterTask:Task;
 
     constructor(optionsArg:{
-        taskFunction:any,
+        taskFunction:ITaskFunction,
         preTask?:Task,
         afterTask?:Task,
         buffered?:boolean,
         bufferMax?:number,
         name?:string
     }){
-        if (!optionsArg){optionsArg = {taskFunction:function(){}}}
         var options = optionsArg;
         this.task = optionsArg.taskFunction;
         this.preTask = options.preTask;
         this.afterTask = options.afterTask;
         this.running = false;
-        this.idle = true;
+        this.idle = !this.running && !this.runningBuffered;
         this.buffered = options.buffered;
         this.bufferMax = options.bufferMax;
         this.name = options.name;
     }
     
+    /**
+     * trigger the task. Will trigger buffered if this.buffered is true
+     */
     trigger(){
         let done = plugins.Q.defer();
         if(this.buffered) {
@@ -47,15 +54,25 @@ export class Task {
         };
         return done.promise;
     };
+
+    /**
+     * trigger task unbuffered.
+     */
     triggerUnBuffered(){
         return helpers.runTask(this);
     }
+    
+    /**
+     * trigger task buffered.
+     */
     triggerBuffered(){
         var done = plugins.Q.defer();
         if(!(this.bufferCounter >= this.bufferMax)){
             this.bufferCounter++
-        }
-        helpers.runBufferedTask(this);
+        };
+        if(!this.runningBuffered){
+            helpers.runBufferedTask(this);
+        };
         return done.promise;
     }
 

ts/taskbuffer.classes.taskchain.ts

@@ -1,35 +1,36 @@
-/// <reference path="./typings/main.d.ts" />
 import * as plugins from "./taskbuffer.plugins";
-import {Task} from "./taskbuffer.classes";
+import {Task} from "./taskbuffer.classes.task";
 import helpers = require("./taskbuffer.classes.helpers");
 
 export class Taskchain extends Task {
     taskArray:Task[];
-    private _oraObject;
+    private _oraObject:plugins.beautylog.Ora;
     constructor(optionsArg:{
         name?:string,
         log?:boolean,
         taskArray:Task[]
     }){
-        let options = plugins.lodash.assign(
+        let options = plugins.lodash.merge(
             {
-                name:"unnamed Task",
+                name:"unnamed Taskchain",
                 log:false
             },
             optionsArg,
             {
                 taskFunction: () => { // this is the function that gets executed when TaskChain is triggered
-                    console.log("running taskchain function");
                     let done = plugins.Q.defer(); // this is the starting Deferred object 
                     let taskCounter = 0;
                     let iterateTasks = () => {
                         if(typeof this.taskArray[taskCounter] != "undefined"){
+                            this._oraObject.text(this.name + " running: Task" + this.taskArray[taskCounter].name);
                             this.taskArray[taskCounter].trigger()
                                 .then(()=>{
+                                    plugins.beautylog.ok(this.taskArray[taskCounter].name);
                                     taskCounter++;
                                     iterateTasks();
                                 });     
                         } else {
+                            this._oraObject.endOk("Taskchain \"" + this.name +  "\" completed successfully");
                             done.resolve();
                         }
                     };
@@ -41,6 +42,9 @@ export class Taskchain extends Task {
         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);
@@ -55,14 +59,4 @@ export class Taskchain extends Task {
         this._oraObject.start(this.name + " running...");
         return helpers.runTask(this);
     }
-};
-
-let myTask = new Taskchain(
-    {
-        taskArray: [
-            new Task({
-                taskFunction:function(){}
-            })
-        ]
-    }
-);
+};

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,2 +0,0 @@
-export * from "./taskbuffer.classes.task"
-export * from "./taskbuffer.classes.taskchain"

ts/taskbuffer.plugins.ts

@@ -1,4 +1,5 @@
-/// <reference path="./typings/main.d.ts" />
+import "typings-global"
 export import beautylog = require("beautylog");
-export let Q = require("q");
-export let lodash= require("lodash");
+export import Q = require("q");
+export import lodash= require("lodash");
+export import rxjs = require("rxjs");

ts/typings.json

@@ -1,8 +0,0 @@
-{
-  "ambientDependencies": {
-    "colors": "github:DefinitelyTyped/DefinitelyTyped/colors/colors.d.ts",
-    "mocha": "github:Bartvds/tsd-deftools/typings/DefinitelyTyped/mocha/mocha.d.ts",
-    "node": "github:DefinitelyTyped/DefinitelyTyped/node/node.d.ts",
-    "should": "registry:dt/should#8.1.1+20160316155526"
-  }
-}