1.0.10

update from q to smartq

See merge request !1

.gitignore

@@ -1,7 +1,4 @@
-.idea/
 coverage/
-docs/
-ts/*.js
-ts/*.js.map
-ts/typings/
 node_modules
+pages/
+.nogit/

.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

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

.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,8 +1,22 @@
 # taskbuffer
-Flexible task organization for gulp. TypeScript ready!
+flexible task management. TypeScript ready!
 
-## Status
+## Availabililty
-[![Coverage Status](https://coveralls.io/repos/github/pushrocks/taskbuffer/badge.svg?branch=master)](https://coveralls.io/github/pushrocks/taskbuffer?branch=master)
+[![npm](https://push.rocks/assets/repo-button-npm.svg)](https://www.npmjs.com/package/taskbuffer)
+[![git](https://push.rocks/assets/repo-button-git.svg)](https://GitLab.com/pushrocks/taskbuffer)
+[![git](https://push.rocks/assets/repo-button-mirror.svg)](https://github.com/pushrocks/taskbuffer)
+[![docs](https://push.rocks/assets/repo-button-docs.svg)](https://pushrocks.gitlab.io/taskbuffer/)
+
+## Status for master
+[![build status](https://GitLab.com/pushrocks/taskbuffer/badges/master/build.svg)](https://GitLab.com/pushrocks/taskbuffer/commits/master)
+[![coverage report](https://GitLab.com/pushrocks/taskbuffer/badges/master/coverage.svg)](https://GitLab.com/pushrocks/taskbuffer/commits/master)
+[![npm downloads per month](https://img.shields.io/npm/dm/taskbuffer.svg)](https://www.npmjs.com/package/taskbuffer)
+[![Dependency Status](https://david-dm.org/pushrocks/taskbuffer.svg)](https://david-dm.org/pushrocks/taskbuffer)
+[![bitHound Dependencies](https://www.bithound.io/github/pushrocks/taskbuffer/badges/dependencies.svg)](https://www.bithound.io/github/pushrocks/taskbuffer/master/dependencies/npm)
+[![bitHound Code](https://www.bithound.io/github/pushrocks/taskbuffer/badges/code.svg)](https://www.bithound.io/github/pushrocks/taskbuffer)
+[![TypeScript](https://img.shields.io/badge/TypeScript-2.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
+[![node](https://img.shields.io/badge/node->=%206.x.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
+[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-standard-brightgreen.svg)](http://standardjs.com/)
 
 ## Install
 
@@ -40,7 +54,7 @@ npm install taskbuffer --save
 
 ### Usage
 We highly recommend TypeScript as this module supports **TypeScript intellisense**.
-```
+```javascript
 import * as taskbuffer from "taskbuffer";
 
 myTask = new taskbuffer.Task({
@@ -53,4 +67,6 @@ myTask = new taskbuffer.Task({
     // Use TypeScript for better understanding and code completion
   }
 })
-```
+```
+
+[![npm](https://push.rocks/assets/repo-header.svg)](https://push.rocks)

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

@@ -1,5 +1,4 @@
 "use strict";
-/// <reference path="./typings/main.d.ts" />
 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");
@@ -10,5 +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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEscUVBQTZEO0FBQXJELHlDQUFBLElBQUksQ0FBQTtBQUNaLCtFQUF5RDtBQUFqRCxtREFBQSxTQUFTLENBQUE7QUFDakIscUZBQStEO0FBQXZELHlEQUFBLFlBQVksQ0FBQTtBQUNwQiwrRUFBeUQ7QUFBakQsbURBQUEsU0FBUyxDQUFBO0FBRWpCLHlCQUF5QjtBQUN6Qix3Q0FBcUMifQ==
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSw0Q0FBNEM7QUFDNUMsd0NBQW1CLDJCQUEyQixDQUFDO0FBQXZDLDhDQUF1QztBQUMvQyw2Q0FBd0IsZ0NBQWdDLENBQUM7QUFBakQsNkRBQWlEO0FBQ3pELGdEQUEyQixtQ0FBbUMsQ0FBQztBQUF2RCxzRUFBdUQ7QUFDL0QsNkNBQXdCLGdDQUFnQyxDQUFDO0FBQWpELDZEQUFpRDtBQUV6RCx5QkFBeUI7QUFDekIsUUFBTyw4QkFBOEIsQ0FBQyxDQUFEIiwiZmlsZSI6ImluZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOlsiLy8vIDxyZWZlcmVuY2UgcGF0aD1cIi4vdHlwaW5ncy9tYWluLmQudHNcIiAvPlxyXG5leHBvcnQge1Rhc2t9IGZyb20gXCIuL3Rhc2tidWZmZXIuY2xhc3Nlcy50YXNrXCI7XHJcbmV4cG9ydCB7VGFza2NoYWlufSBmcm9tIFwiLi90YXNrYnVmZmVyLmNsYXNzZXMudGFza2NoYWluXCI7XHJcbmV4cG9ydCB7VGFza3BhcmFsbGVsfSBmcm9tIFwiLi90YXNrYnVmZmVyLmNsYXNzZXMudGFza3BhcmFsbGVsXCI7XHJcbmV4cG9ydCB7VGFza3NwYWNlfSBmcm9tIFwiLi90YXNrYnVmZmVyLmNsYXNzZXMudGFza3NwYWNlXCI7XHJcblxyXG4vLyBpbXBvcnQgZm9yIG5hbWluZyBvbmx5XHJcbmltcG9ydCBcIi4vdGFza2J1ZmZlci5jbGFzc2VzLmhlbHBlcnNcIiJdfQ==

dist/taskbuffer.classes.helpers.d.ts

@@ -1,9 +1,30 @@
-import { Task } from "./taskbuffer.classes.task";
+import plugins = require("./taskbuffer.plugins");
-export declare let emptyTaskFunction: () => any;
+import { Task, ITaskFunction } from "./taskbuffer.classes.task";
-export declare let isTask: (taskArg: any) => boolean;
+export declare let emptyTaskFunction: ITaskFunction;
+export declare let isTask: (taskArg: Task) => boolean;
 export declare let isTaskTouched: (taskArg: Task, touchedTasksArray: Task[]) => boolean;
-export declare let runTask: (taskArg: Task, optionsArg?: {
+export declare let runTask: (taskArg: Task, optionsArg: {
-    touchedTasksArray: Task[];
+    x?: any;
-}) => any;
+    touchedTasksArray?: Task[];
-export declare let runBufferedTask: (taskArg: Task) => void;
+}) => Promise<{}>;
-export declare let updateTaskStatus: (taskArg: any, statusArg: string) => 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): Promise<{}>;
+    informOfCycle(x: any): 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): Promise<any>;
+}

dist/taskbuffer.classes.task.d.ts

@@ -1,25 +1,37 @@
+import * as helpers from "./taskbuffer.classes.helpers";
+export interface ITaskFunction {
+    (x?: any): PromiseLike<any>;
+}
 export declare class Task {
     name: string;
-    task: any;
+    taskFunction: ITaskFunction;
-    running: boolean;
-    idle: boolean;
     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: any;
+        taskFunction: ITaskFunction;
         preTask?: Task;
         afterTask?: Task;
         buffered?: boolean;
         bufferMax?: number;
         name?: string;
     });
-    trigger(): any;
+    /**
-    triggerUnBuffered(): any;
+     * trigger the task. Will trigger buffered if this.buffered is true
-    triggerBuffered(): any;
+     */
+    trigger(x?: any): Promise<any>;
+    /**
+     * trigger task unbuffered.
+     */
+    triggerUnBuffered(x?: any): Promise<any>;
+    /**
+     * trigger task buffered.
+     */
+    triggerBuffered(x?: any): Promise<any>;
     state: string;
 }

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.taskparallel.js

@@ -1,32 +1,23 @@
 "use strict";
-var __extends = (this && this.__extends) || function (d, b) {
+const plugins = require("./taskbuffer.plugins");
-    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+const taskbuffer_classes_task_1 = require("./taskbuffer.classes.task");
-    function __() { this.constructor = d; }
+class Taskparallel extends taskbuffer_classes_task_1.Task {
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    constructor(optionsArg) {
-};
+        let options = plugins.lodash.merge(optionsArg, {
-/// <reference path="./typings/main.d.ts" />
+            taskFunction: () => {
-var plugins = require("./taskbuffer.plugins");
+                let done = plugins.q.defer();
-var taskbuffer_classes_task_1 = require("./taskbuffer.classes.task");
+                let promiseArray = []; // stores promises of all tasks, since they run in parallel
-var Taskparallel = (function (_super) {
+                this.taskArray.forEach(function (taskArg) {
-    __extends(Taskparallel, _super);
-    function Taskparallel(optionsArg) {
-        var _this = this;
-        var options = plugins.lodash.assign(optionsArg, {
-            taskFunction: function () {
-                var done = plugins.Q.defer();
-                var promiseArray; // stores promises of all tasks, since they run in parallel
-                _this.taskArray.forEach(function (taskArg) {
                     promiseArray.push(taskArg.trigger());
                 });
-                plugins.Q.all(promiseArray)
+                Promise.all(promiseArray)
                     .then(done.resolve);
                 return done.promise;
             }
         });
-        _super.call(this, options);
+        super(options);
+        this.taskArray = optionsArg.taskArray;
     }
-    return Taskparallel;
+}
-}(taskbuffer_classes_task_1.Task));
 exports.Taskparallel = Taskparallel;
-
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5jbGFzc2VzLnRhc2twYXJhbGxlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3Rhc2tidWZmZXIuY2xhc3Nlcy50YXNrcGFyYWxsZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLGdEQUErQztBQUUvQyx1RUFBZ0Q7QUFFaEQsa0JBQTBCLFNBQVEsOEJBQUk7SUFFbEMsWUFBWSxVQUVYO1FBQ0csSUFBSSxPQUFPLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQzlCLFVBQVUsRUFDVjtZQUNJLFlBQVksRUFBRTtnQkFDVixJQUFJLElBQUksR0FBRyxPQUFPLENBQUMsQ0FBQyxDQUFDLEtBQUssRUFBRSxDQUFDO2dCQUM3QixJQUFJLFlBQVksR0FBbUIsRUFBRSxDQUFDLENBQUMsMkRBQTJEO2dCQUNsRyxJQUFJLENBQUMsU0FBUyxDQUFDLE9BQU8sQ0FBQyxVQUFVLE9BQU87b0JBQ3BDLFlBQVksQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7Z0JBQ3pDLENBQUMsQ0FBQyxDQUFBO2dCQUNGLE9BQU8sQ0FBQyxHQUFHLENBQUMsWUFBWSxDQUFDO3FCQUNwQixJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDO2dCQUN4QixNQUFNLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQztZQUN4QixDQUFDO1NBQ0osQ0FDSixDQUFDO1FBQ0YsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ2YsSUFBSSxDQUFDLFNBQVMsR0FBRyxVQUFVLENBQUMsU0FBUyxDQUFDO0lBQzFDLENBQUM7Q0FDSjtBQXZCRCxvQ0F1QkMifQ==
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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

dist/taskbuffer.classes.taskspace.js

@@ -1,9 +1,5 @@
 "use strict";
-var Taskspace = (function () {
+class Taskspace {
-    function Taskspace() {
+}
-    }
-    return Taskspace;
-}());
 exports.Taskspace = Taskspace;
-
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5jbGFzc2VzLnRhc2tzcGFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3Rhc2tidWZmZXIuY2xhc3Nlcy50YXNrc3BhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUdBO0NBRUM7QUFGRCw4QkFFQyJ9
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRhc2tidWZmZXIuY2xhc3Nlcy50YXNrc3BhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUlBO0lBQUE7SUFFQSxDQUFDO0lBQUQsZ0JBQUM7QUFBRCxDQUZBLEFBRUMsSUFBQTtBQUZZLGlCQUFTLFlBRXJCLENBQUEiLCJmaWxlIjoidGFza2J1ZmZlci5jbGFzc2VzLnRhc2tzcGFjZS5qcyIsInNvdXJjZXNDb250ZW50IjpbIi8vLyA8cmVmZXJlbmNlIHBhdGg9XCIuL3R5cGluZ3MvbWFpbi5kLnRzXCIgLz5cclxuaW1wb3J0ICogYXMgcGx1Z2lucyBmcm9tIFwiLi90YXNrYnVmZmVyLnBsdWdpbnNcIlxyXG5pbXBvcnQgKiBhcyBoZWxwZXJzIGZyb20gXCIuL3Rhc2tidWZmZXIuY2xhc3Nlcy5oZWxwZXJzXCJcclxuXHJcbmV4cG9ydCBjbGFzcyBUYXNrc3BhY2Uge1xyXG4gICAgXHJcbn0iXX0=

dist/taskbuffer.plugins.d.ts

@@ -1,3 +1,6 @@
-export import beautylog = require("beautylog");
+import "typings-global";
-export declare let Q: any;
+import * as beautylog from "beautylog";
-export declare let lodash: any;
+import * as lodash from "lodash";
+import * as rxjs from "rxjs";
+import * as q from 'smartq';
+export { beautylog, lodash, rxjs, q };

dist/taskbuffer.plugins.js

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

npmextra.json

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

npmts.json

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

package.json

@@ -1,7 +1,7 @@
 {
   "name": "taskbuffer",
-  "version": "0.1.3",
+  "version": "1.0.10",
-  "description": "Flexible task organization for gulp. TypeScript ready!",
+  "description": "flexible task management. TypeScript ready!",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "scripts": {
@@ -9,29 +9,33 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/pushrocks/taskbuffer.git"
+    "url": "git+https://gitlab.com/pushrocks/taskbuffer.git"
   },
   "keywords": [
     "gulp",
-    "tasks",
+    "task",
-    "watch",
+    "buffer",
-    "buffer"
+    "TypeScript",
+    "push.rocks"
   ],
   "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": "^5.0.0",
+    "@types/lodash": "4.x.x",
-    "lodash": "^4.12.0",
+    "beautylog": "^6.0.0",
-    "projectinfo": "1.0.1",
+    "lodash": "^4.17.4",
     "q": "^1.4.1",
-    "rx": "^4.1.0"
+    "rxjs": "^5.0.3",
+    "smartq": "^1.0.2",
+    "typings-global": "^1.0.14"
   },
   "devDependencies": {
-    "should": "^8.3.1",
+    "npmts-g": "^6.0.0",
-    "npmts": "^5.1.5"
+    "should": "^11.1.2",
+    "typings-test": "^1.0.3"
   }
 }

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,83 +1,223 @@
-/// <reference path="../ts/typings/main.d.ts" />
+import "typings-test";
 import taskbuffer = require("../dist/index");
-let should = require("should");
+import should = require("should");
-let plugins = {
+import q = require("q")
-    q: require("q")
-}
 
 // setup some testData to work with
-let testTask:taskbuffer.Task;
+let testTask: taskbuffer.Task;
-let testTaskFunction = function(){
+let testTaskFunction = function () {
-    let done = plugins.q.defer();
+    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(){
+// some more tasks to wirj with
-        it("new Task() should return a new task",function(){
+let task1 = new taskbuffer.Task({
-            testTask = new taskbuffer.Task({taskFunction:testTaskFunction,preTask:testPreTask});
+    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);
+            should(testTask).be.instanceof(taskbuffer.Task);
         });
-        it("testTask.idle is true",function(){
+        it("testTask.idle is true", function () {
-            if (!testTask.idle){
+            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");
+            should(testTask.running).be.type("boolean");
-            testTask.running.should.be.false();
+            should(testTask.running).be.false();
         });
-        it("testTask.trigger() should return Promise",function(){
+        it("testTask.trigger() should return Promise", function () {
-            testTask.trigger().should.be.Promise();
+            should(testTask.trigger()).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){
+        it("should run a task without pre and afterTask", function (done) {
-            let localTestTask = new taskbuffer.Task({taskFunction:testTaskFunction});
+            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",
+                name: "task1",
-                taskFunction:function(){
+                taskFunction: function () {
-                    let done = plugins.q.defer();
+                    let done = q.defer();
-                    setTimeout(done.resolve,2000);
+                    setTimeout(done.resolve, 2000);
                     return done.promise;
                 }
             }),
             new taskbuffer.Task({
-                name:"task2",
+                name: "task2",
-                taskFunction: function(){
+                taskFunction: function () {
-                    let done = plugins.q.defer();
+                    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",
+                name: "Taskchain1",
-                taskArray:testTaskArray
+                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 flowTaskBuffered = new taskbuffer.Task({
+            taskFunction: (x:number) => {
+                let done = q.defer();
+                console.log("flowTask1");
+                console.log(x);
+                done.resolve(x);
+                return done.promise;
+            },
+            buffered:true,
+            bufferMax: 1
+        });
+
+        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 when buffered",function(done){
+            flowTaskBuffered.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,5 +1,4 @@
-/// <reference path="./typings/main.d.ts" />
+export {Task,ITaskFunction} from "./taskbuffer.classes.task";
-export {Task} 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,18 +1,17 @@
-/// <reference path="./typings/main.d.ts" />
 import plugins = require("./taskbuffer.plugins");
-import {Task} from "./taskbuffer.classes.task";
+import { Task, ITaskFunction } from "./taskbuffer.classes.task";
 
-export let emptyTaskFunction = function(){
+export let emptyTaskFunction: ITaskFunction = function (x) {
-    let done = plugins.Q.defer();
+    let done = plugins.q.defer();
     done.resolve();
     return done.promise;
 };
 
-export let isTask = function(taskArg):boolean{
+export let isTask = function (taskArg: Task): boolean {
-    if(
+    if (
         taskArg instanceof Task
-        && typeof taskArg.task === "function"
+        && typeof taskArg.taskFunction === "function"
-    ){
+    ) {
         return true;
     } else {
         return false;
@@ -20,78 +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){
+    for (let keyArg in touchedTasksArray) {
-        if(taskArg === touchedTasksArray[keyArg]){
+        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();
+    let done = plugins.q.defer();
-    updateTaskStatus(taskArg,"running");
+    
-    done.promise.then(function(){updateTaskStatus(taskArg,"idle")})
+    //  set running params
-    let localDeferred = plugins.Q.defer();
+    taskArg.running = true;
-    let touchedTasksArray:Task[];
+    done.promise.then(function () { taskArg.running = false });
-    if(optionsArg.touchedTasksArray){
+
-        touchedTasksArray = optionsArg.touchedTasksArray;
+    // handle options
-    } else {
+    let options = plugins.lodash.merge(
-        touchedTasksArray = [];
+        {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(() =>{
+        .then(() => {
-            if(taskArg.preTask && !isTaskTouched(taskArg.preTask,touchedTasksArray)){
+            if (taskArg.preTask && !isTaskTouched(taskArg.preTask, touchedTasksArray)) {
-                return runTask(taskArg.preTask,{touchedTasksArray:touchedTasksArray})
+                return runTask(taskArg.preTask, {x:x, touchedTasksArray: touchedTasksArray })
             } else {
-                let done2 = plugins.Q.defer();
+                let done2 = plugins.q.defer();
-                done2.resolve();
+                done2.resolve(x);
                 return done2.promise;
             }
         })
-        .then(() => {
+        .then(x => {
-            return taskArg.task();
+            return taskArg.taskFunction(x);
         })
-        .then(() => {
+        .then(x => {
-            if(taskArg.afterTask && !isTaskTouched(taskArg.afterTask,touchedTasksArray)){
+            if (taskArg.afterTask && !isTaskTouched(taskArg.afterTask, touchedTasksArray)) {
-                return runTask(taskArg.afterTask,{touchedTasksArray:touchedTasksArray})
+                return runTask(taskArg.afterTask, {x:x, touchedTasksArray: touchedTasksArray });
             } else {
-                let done2 = plugins.Q.defer();
+                let done2 = plugins.q.defer();
-                done2.resolve();
+                done2.resolve(x);
                 return done2.promise;
             }
         })
-        .then(() => {
+        .then(x => {
-            done.resolve();
+            done.resolve(x);
+        }).catch((err) => {
+            console.log(err);
         });
     localDeferred.resolve();
     return done.promise;
 };
 
-export let runBufferedTask = (taskArg:Task) => {
+
-    let recursiveBufferRunner = () => {
+export interface cycleObject {
-        if(taskArg.bufferCounter > 0){
+    cycleCounter:number,
-            taskArg.bufferCounter--;
+    deferred: plugins.q.Deferred<any>
-            runTask(taskArg)
+}
-                .then(recursiveBufferRunner);
+
-        }
+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(x){
+        let newCycleObjectArray:cycleObject[] = [];
+        this.cycleObjectArray.forEach(cycleObjectArg => {
+            cycleObjectArg.cycleCounter--;
+            if(cycleObjectArg.cycleCounter <= 0){
+                cycleObjectArg.deferred.resolve(x);
+            } else {
+                newCycleObjectArray.push(cycleObjectArg);
+            };
+        });
+        this.cycleObjectArray = newCycleObjectArray;
     }
 }
 
-export let updateTaskStatus = (taskArg,statusArg:string) => {
+export class BufferRunner {
-    switch (statusArg) {
+    task:Task;
-        case "running":
+    // initialze by default
-            taskArg.running = true;
+    bufferCounter:number = 0;
-            taskArg.idle = false;
+    bufferMax:number = 1;
-            break;
+    running:boolean = false;
-        case "idle":
+    constructor(taskArg: Task) {
-            taskArg.running = false;
+        this.task = taskArg;
-            taskArg.idle = true;
+    };
-            break;
+    private _run(x) {
-        default:
+        let recursiveBufferRunner = (x) => {
-            throw new Error("status not recognised");
+            if (this.bufferCounter >= 0) {
-    }
+                this.running = true;
-}
+                this.task.running = true;
+                runTask(this.task,{x:x})
+                    .then((x) => {
+                        this.bufferCounter--;
+                        this.task.cycleCounter.informOfCycle(x);
+                        recursiveBufferRunner(x);
+                    });
+            } else {
+                this.running = false;
+                this.task.running = false;
+            }
+        };
+        recursiveBufferRunner(x);
+    };
+    setBufferMax(bufferMaxArg:number){
+        this.bufferMax = bufferMaxArg;
+    };
+    trigger(x): Promise<any> {
+        if(!(this.bufferCounter >= this.bufferMax)){
+            this.bufferCounter++
+        };
+        let returnPromise:Promise<any> = this.task.cycleCounter.getPromiseForCycle(this.bufferCounter + 1);
+        if(!this.running){
+            this._run(x);
+        }
+        return returnPromise;
+    };
+};

ts/taskbuffer.classes.task.ts

@@ -1,62 +1,66 @@
-/// <reference path="./typings/main.d.ts" />
 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;
-    task:any;
+    taskFunction:ITaskFunction;
-    running:boolean;
-    idle:boolean;
     buffered:boolean;
-    bufferCounter:number;
-    bufferMax:number;
-    private _counterTriggerAbsolute:number;
-    private _state:string;
     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: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.taskFunction = optionsArg.taskFunction;
         this.preTask = options.preTask;
         this.afterTask = options.afterTask;
-        this.running = false;
+        this.idle = !this.running;
-        this.idle = true;
         this.buffered = options.buffered;
-        this.bufferMax = options.bufferMax;
+        this.bufferRunner.setBufferMax(options.bufferMax);
         this.name = options.name;
     }
     
-    trigger(){
+    /**
-        let done = plugins.Q.defer();
+     * trigger the task. Will trigger buffered if this.buffered is true
+     */
+    trigger(x?):Promise<any> {
         if(this.buffered) {
-            this.triggerBuffered()
+            return this.triggerBuffered(x)
-                .then(done.resolve);
         }
         else {
-            this.triggerUnBuffered()
+            return this.triggerUnBuffered(x);
-                .then(done.resolve);
         };
-        return done.promise;
     };
-    triggerUnBuffered(){
+
-        return helpers.runTask(this);
+    /**
+     * trigger task unbuffered.
+     */
+    triggerUnBuffered(x?):Promise<any>{
+        return helpers.runTask(this,{x:x});
     }
-    triggerBuffered(){
+    
-        var done = plugins.Q.defer();
+    /**
-        if(!(this.bufferCounter >= this.bufferMax)){
+     * trigger task buffered.
-            this.bufferCounter++
+     */
-        }
+    triggerBuffered(x?):Promise<any>{
-        helpers.runBufferedTask(this);
+        return this.bufferRunner.trigger(x);
-        return done.promise;
     }
 
     get state():string {
@@ -66,7 +70,7 @@ export class Task {
         if (stateArg == "locked"){
             this._state = "locked";
         } else {
-            plugins.beautylog.error("state type " + stateArg.blue + " could not be set");
+            plugins.beautylog.error("state type " + stateArg + " could not be set");
         }
     }
 }

ts/taskbuffer.classes.taskchain.ts

@@ -1,4 +1,3 @@
-/// <reference path="./typings/main.d.ts" />
 import * as plugins from "./taskbuffer.plugins";
 import {Task} from "./taskbuffer.classes.task";
 import helpers = require("./taskbuffer.classes.helpers");
@@ -7,35 +6,37 @@ 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.assign(
+        let options = plugins.lodash.merge(
             {
                 name:"unnamed Taskchain",
                 log:false
             },
             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 done = plugins.q.defer(); // this is the starting Deferred object 
-                    let taskCounter = 0;
+                    let taskCounter = 0; // counter for iterating async over the taskArray
-                    let iterateTasks = () => {
+                    let iterateTasks = (x) => {
                         if(typeof this.taskArray[taskCounter] != "undefined"){
                             this._oraObject.text(this.name + " running: Task" + this.taskArray[taskCounter].name);
-                            this.taskArray[taskCounter].trigger()
+                            this.taskArray[taskCounter].trigger(x)
-                                .then(()=>{
+                                .then((x)=>{
-                                    this._oraObject.log(this.taskArray[taskCounter].name,"ok");
+                                    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;
                 }
             }
@@ -43,6 +44,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);
@@ -53,8 +57,4 @@ export class Taskchain extends Task {
     shiftTask(){
         
     };
-    trigger(){
-        this._oraObject.start(this.name + " running...");
-        return helpers.runTask(this);
-    }
 };

ts/taskbuffer.classes.taskparallel.ts

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

ts/taskbuffer.classes.taskspace.ts

@@ -1,4 +1,3 @@
-/// <reference path="./typings/main.d.ts" />
 import * as plugins from "./taskbuffer.plugins"
 import * as helpers from "./taskbuffer.classes.helpers"
 

ts/taskbuffer.plugins.ts

@@ -1,4 +1,12 @@
-/// <reference path="./typings/main.d.ts" />
+import "typings-global"
-export import beautylog = require("beautylog");
+import * as beautylog from "beautylog"
-export let Q = require("q");
+import * as lodash from "lodash"
-export let lodash= require("lodash");
+import * as rxjs from "rxjs"
+import * as q from 'smartq'
+
+export {
+    beautylog,
+    lodash,
+    rxjs,
+    q
+}

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"
-  }
-}