2.0.16

update from q to smartq

See merge request !1

.gitignore

@@ -1,7 +1,22 @@
-.idea/
+.nogit/
+
+# artifacts
 coverage/
-docs/
-ts/*.js
-ts/*.js.map
-ts/typings/
-node_modules
+public/
+pages/
+
+# installs
+node_modules/
+
+# caches
+.yarn/
+.cache/
+.rpt2_cache
+
+# builds
+dist/
+dist_web/
+dist_serve/
+dist_ts_web/
+
+# custom

.gitlab-ci.yml

@@ -1,36 +1,119 @@
-image: hosttoday/ht-docker-node:npmts
+# gitzone ci_default
+image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+
+cache:
+  paths:
+  - .npmci_cache/
+  key: "$CI_BUILD_STAGE"
 
 stages:
+- security
 - test
 - release
+- metadata
 
-testLEGACY:
-  stage: test
+# ====================
+# security stage
+# ====================
+mirror:
+  stage: security
   script:
-    - npmci test legacy
+  - npmci git mirror
   tags:
-    - docker
+  - docker
+  - notpriv
 
-testLTS:
+snyk:
+  stage: security
+  script:
+    - npmci npm prepare
+    - npmci command npm install -g snyk
+    - npmci command npm install --ignore-scripts
+    - npmci command snyk test
+  tags:
+  - docker
+  - notpriv
+
+# ====================
+# test stage
+# ====================
+
+testStable:
   stage: test
   script:
-    - npmci test lts
+  - npmci npm prepare
+  - npmci node install stable
+  - npmci npm install
+  - npmci npm test
+  coverage: /\d+.?\d+?\%\s*coverage/
   tags:
-    - docker
-    
-testSTABLE:
+  - docker
+  - priv
+
+testBuild:
   stage: test
   script:
-    - npmci test stable
+  - npmci npm prepare
+  - npmci node install lts
+  - npmci npm install
+  - npmci command npm run build
+  coverage: /\d+.?\d+?\%\s*coverage/
   tags:
-    - docker
+  - docker
+  - notpriv
 
 release:
   stage: release
-  environment: npmjs-com_registry
   script:
-    - npmci publish
+  - npmci node install lts
+  - npmci npm publish
+  only:
+  - tags
+  tags:
+  - docker
+  - notpriv
+
+# ====================
+# metadata stage
+# ====================
+codequality:
+  stage: metadata
+  allow_failure: true
+  script:
+    - npmci command npm install -g tslint typescript
+    - npmci npm install
+    - npmci command "tslint -c tslint.json ./ts/**/*.ts"
+  tags:
+  - docker
+  - priv
+
+trigger:
+  stage: metadata
+  script:
+  - npmci trigger
+  only:
+  - tags
+  tags:
+  - docker
+  - notpriv
+
+pages:
+  image: hosttoday/ht-docker-dbase:npmci
+  services:
+   - docker:stable-dind
+  stage: metadata
+  script:
+    - npmci command npm install -g @gitzone/tsdoc
+    - npmci npm prepare
+    - npmci npm install
+    - npmci command tsdoc
+  tags:
+    - docker
+    - notpriv
   only:
     - tags
-  tags:
-    - docker
+  artifacts:
+    expire_in: 1 week
+    paths:
+    - public
+  allow_failure: true

.npmignore

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

README.md

@@ -1,56 +0,0 @@
-# taskbuffer
-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)
-
-## Install
-
-```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

@@ -1,5 +0,0 @@
-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,12 +0,0 @@
-"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

@@ -1,31 +0,0 @@
-/// <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.task.d.ts

@@ -1,37 +0,0 @@
-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

@@ -1,59 +0,0 @@
-"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

@@ -1,15 +0,0 @@
-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

@@ -1,54 +0,0 @@
-"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

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

dist/taskbuffer.classes.taskparallel.js

@@ -1,23 +0,0 @@
-"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

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

dist/taskbuffer.classes.taskspace.js

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

dist/taskbuffer.plugins.d.ts

@@ -1,5 +0,0 @@
-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,7 +0,0 @@
-"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=

npmextra.json

@@ -1,5 +1,17 @@
 {
-  "npmts":{
-    "mode":"default"
+  "npmci": {
+    "npmGlobalTools": [],
+    "npmAccessLevel": "public",
+    "npmRegistryUrl": "registry.npmjs.org"
+  },
+  "gitzone": {
+    "module": {
+      "githost": "gitlab.com",
+      "gitscope": "pushrocks",
+      "gitrepo": "taskbuffer",
+      "shortDescription": "flexible task management. TypeScript ready!",
+      "npmPackagename": "@pushrocks/taskbuffer",
+      "license": "MIT"
+    }
   }
 }

package.json

@@ -1,11 +1,13 @@
 {
-  "name": "taskbuffer",
-  "version": "1.0.5",
+  "name": "@pushrocks/taskbuffer",
+  "version": "2.0.16",
+  "private": false,
   "description": "flexible task management. TypeScript ready!",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "scripts": {
-    "test": "(npmts)"
+    "test": "(tstest test/)",
+    "build": "(tsbuild)"
   },
   "repository": {
     "type": "git",
@@ -13,9 +15,10 @@
   },
   "keywords": [
     "gulp",
-    "tasks",
-    "watch",
-    "buffer"
+    "task",
+    "buffer",
+    "TypeScript",
+    "push.rocks"
   ],
   "author": "Lossless GmbH",
   "license": "MIT",
@@ -24,17 +27,31 @@
   },
   "homepage": "https://gitlab.com/pushrocks/taskbuffer#readme",
   "dependencies": {
-    "@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"
+    "@pushrocks/lik": "^3.0.13",
+    "@pushrocks/smartdelay": "^2.0.6",
+    "@pushrocks/smartlog": "^2.0.21",
+    "@pushrocks/smartpromise": "^3.0.6",
+    "@types/cron": "^1.7.1",
+    "cron": "^1.7.2",
+    "rxjs": "^6.5.3"
   },
   "devDependencies": {
-    "npmts-g": "^5.2.8",
-    "should": "^10.0.0",
-    "typings-test": "^1.0.1"
-  }
+    "@gitzone/tsbuild": "^2.1.17",
+    "@gitzone/tstest": "^1.0.28",
+    "@pushrocks/tapbundle": "^3.2.0",
+    "@types/node": "^12.12.14",
+    "tslint": "^5.20.1",
+    "tslint-config-prettier": "^1.18.0"
+  },
+  "files": [
+    "ts/*",
+    "ts_web/*",
+    "dist/*",
+    "dist_web/*",
+    "dist_ts_web/*",
+    "assets/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ]
 }

readme.md

@@ -0,0 +1,52 @@
+# @pushrocks/taskbuffer
+flexible task management. TypeScript ready!
+
+## Availabililty and Links
+* [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/taskbuffer)
+* [gitlab.com (source)](https://gitlab.com/pushrocks/taskbuffer)
+* [github.com (source mirror)](https://github.com/pushrocks/taskbuffer)
+* [docs (typedoc)](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/@pushrocks/taskbuffer.svg)](https://www.npmjs.com/package/@pushrocks/taskbuffer)
+[![Known Vulnerabilities](https://snyk.io/test/npm/@pushrocks/taskbuffer/badge.svg)](https://snyk.io/test/npm/@pushrocks/taskbuffer)
+[![TypeScript](https://img.shields.io/badge/TypeScript->=%203.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+[![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-prettier-ff69b4.svg)](https://prettier.io/)
+
+## Usage
+
+We highly recommend TypeScript as this module supports **TypeScript intellisense**.
+
+```javascript
+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",
+  buffered: true, // optional
+  bufferMax: 3, // optional, call qeues greater than this are truncated
+  execDelay: 1000, // optional, time in ms to wait before executing task call
+  taskFunction:() => {
+    // do some stuff and return promise
+    // pass on any data through promise resolution
+    // Use TypeScript for better understanding and code completion
+  }
+})
+```
+
+For further information read the linked docs at the top of this README.
+
+> MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
+
+[![repo-footer](https://pushrocks.gitlab.io/assets/repo-footer.svg)](https://push.rocks)
+
+For further information read the linked docs at the top of this readme.
+
+> MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
+| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
+
+[![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)

test/test.1.task.ts

@@ -0,0 +1,115 @@
+import { expect, tap } from '@pushrocks/tapbundle';
+import taskbuffer = require('../ts/index');
+
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartdelay from '@pushrocks/smartdelay';
+
+// setup some testData to work with
+let testTask: taskbuffer.Task;
+
+let testPreTask = new taskbuffer.Task({
+  taskFunction: async () => {
+    console.log('preTask executed');
+  },
+  preTask: testTask
+});
+
+// some more tasks to test with
+let task1Counter = 0; // how often task 1 is being executed
+let task1 = new taskbuffer.Task({
+  name: 'Task 1',
+  taskFunction: () => {
+    let done = smartpromise.defer();
+    console.log('Task1 started');
+    setTimeout(() => {
+      task1Counter++;
+      console.log('Task1 executed');
+      done.resolve();
+    }, 5000);
+    return done.promise;
+  }
+});
+
+let task2 = new taskbuffer.Task({
+  name: 'Task 1',
+  taskFunction: async () => {
+    const done = smartpromise.defer();
+    console.log('Task2 started');
+    setTimeout(() => {
+      console.log('Task2 executed');
+      done.resolve();
+    }, 5000);
+    await done.promise;
+  }
+});
+
+let task3 = new taskbuffer.Task({
+  name: 'Task 3',
+  taskFunction: () => {
+    let done = smartpromise.defer();
+    console.log('Task3 started');
+    setTimeout(() => {
+      console.log('Task3 executed');
+      done.resolve();
+    }, 5000);
+    return done.promise;
+  }
+});
+
+tap.test('new Task() should return a new task', async () => {
+  testTask = new taskbuffer.Task({
+    taskFunction: async () => {
+      console.log('executed twice');
+    },
+    preTask: testPreTask
+  });
+});
+
+tap.test('expect testTask to be an instance of Task', async () => {
+  expect(testTask).to.be.instanceof(taskbuffer.Task);
+});
+
+tap.test('expect testTask.idle is true', async () => {
+  if (!testTask.idle) {
+    throw new Error('testTask.idle is not true');
+  }
+});
+
+tap.test('testTask.running should be of type boolean and initially false', async () => {
+  expect(testTask.running).to.be.a('boolean');
+  // tslint:disable-next-line:no-unused-expression
+  expect(testTask.running).to.be.false;
+});
+
+tap.test('testTask.trigger() should return Promise', async () => {
+  expect(testTask.trigger()).to.be.instanceof(Promise);
+});
+
+tap.test('testTask.trigger() returned Promise should be fullfilled', async () => {
+  await testTask.trigger();
+});
+
+tap.test('expect to run a task without pre and afterTask errorless', async () => {
+  let localTestTask = new taskbuffer.Task({
+    taskFunction: async () => {
+      console.log('only once');
+    }
+  });
+  await localTestTask.trigger();
+});
+
+tap.test('expect task to run in buffered mode', async () => {
+  let localTestTask = new taskbuffer.Task({
+    taskFunction: async () => {
+      await smartdelay.delayFor(3000);
+    },
+    buffered: true,
+    bufferMax: 2
+  });
+  localTestTask.trigger();
+  localTestTask.trigger();
+  localTestTask.trigger();
+  await localTestTask.trigger();
+});
+
+tap.start();

test/test.2.taskchain.ts

@@ -0,0 +1,48 @@
+import { expect, tap } from '@pushrocks/tapbundle';
+import taskbuffer = require('../ts/index');
+
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartdelay from '@pushrocks/smartdelay';
+
+let task1Executed = false;
+const task1 = new taskbuffer.Task({
+  taskFunction: async () => {
+    await smartdelay.delayFor(2000);
+    task1Executed = true;
+  }
+});
+
+let task2Executed = false;
+const task2 = new taskbuffer.Task({
+  taskFunction: async () => {
+    await smartdelay.delayFor(2000);
+    task2Executed = true;
+  }
+});
+
+let task3Executed = false;
+const task3 = new taskbuffer.Task({
+  taskFunction: async () => {
+    await smartdelay.delayFor(2000);
+    task3Executed = true;
+  }
+});
+
+tap.test('expect run tasks in sequence', async () => {
+  const testTaskchain = new taskbuffer.Taskchain({
+    name: 'Taskchain1',
+    taskArray: [task1, task2, task3]
+  });
+  const testPromise = testTaskchain.trigger();
+  await smartdelay.delayFor(2100);
+  // tslint:disable-next-line:no-unused-expression
+  expect(task1Executed).to.be.true;
+  // tslint:disable-next-line:no-unused-expression
+  expect(task2Executed).to.be.false;
+  await smartdelay.delayFor(2100);
+  // tslint:disable-next-line:no-unused-expression
+  expect(task2Executed).to.be.true;
+  await testPromise;
+});
+
+tap.start();

test/test.3.taskparallel.ts

@@ -0,0 +1,36 @@
+import { expect, tap } from '@pushrocks/tapbundle';
+import taskbuffer = require('../ts/index');
+import * as smartdelay from '@pushrocks/smartdelay';
+
+let task1Executed = false;
+const task1 = new taskbuffer.Task({
+  taskFunction: async () => {
+    await smartdelay.delayFor(2000);
+    task1Executed = true;
+  }
+});
+
+let task2Executed = false;
+const task2 = new taskbuffer.Task({
+  taskFunction: async () => {
+    await smartdelay.delayFor(2000);
+    task2Executed = true;
+  }
+});
+
+let task3Executed = false;
+const task3 = new taskbuffer.Task({
+  taskFunction: async () => {
+    await smartdelay.delayFor(2000);
+    task3Executed = true;
+  }
+});
+
+tap.test('expect run in Parallel', async () => {
+  const testTaskparallel = new taskbuffer.Taskparallel({
+    taskArray: [task1, task2, task3]
+  });
+  await testTaskparallel.trigger();
+});
+
+tap.start();

test/test.4.taskmanager.ts

@@ -0,0 +1,42 @@
+import { expect, tap } from '@pushrocks/tapbundle';
+import taskbuffer = require('../ts/index');
+
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartdelay from '@pushrocks/smartdelay';
+
+let myTaskManager: taskbuffer.TaskManager;
+let taskRunCounter = 0;
+const taskDone = smartpromise.defer();
+
+tap.test('should create an instance of TaskManager', async () => {
+  myTaskManager = new taskbuffer.TaskManager();
+  expect(myTaskManager).to.be.instanceof(taskbuffer.TaskManager);
+});
+
+tap.test('should run the task as expected', async () => {
+  let referenceBoolean = false;
+  myTaskManager.addTask(
+    new taskbuffer.Task({
+      name: 'myTask',
+      taskFunction: async () => {
+        console.log('Task executed!');
+        referenceBoolean = true;
+        taskRunCounter++;
+        if (taskRunCounter === 10) {
+          taskDone.resolve();
+        }
+      }
+    })
+  );
+  await myTaskManager.triggerTaskByName('myTask');
+  // tslint:disable-next-line:no-unused-expression
+  expect(referenceBoolean).to.be.true;
+});
+
+tap.test('should schedule task', async () => {
+  myTaskManager.scheduleTaskByName('myTask', '* * * * * *');
+  await taskDone.promise;
+  myTaskManager.descheduleTaskByName('myTask');
+});
+
+tap.start();

test/test.5.task.paramflow.ts

@@ -0,0 +1,64 @@
+import { expect, tap } from '@pushrocks/tapbundle';
+import taskbuffer = require('../ts/index');
+
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartdelay from '@pushrocks/smartdelay';
+
+const flowTask1 = new taskbuffer.Task({
+  taskFunction: (x: number) => {
+    const done = smartpromise.defer();
+    console.log('flowTask1');
+    console.log(x);
+    done.resolve(x);
+    return done.promise;
+  }
+});
+
+const flowTaskBuffered = new taskbuffer.Task({
+  taskFunction: (x: number) => {
+    const done = smartpromise.defer();
+    console.log('flowTask1');
+    console.log(x);
+    done.resolve(x);
+    return done.promise;
+  },
+  buffered: true,
+  bufferMax: 1
+});
+
+const flowTask2 = new taskbuffer.Task({
+  taskFunction: (x: number) => {
+    const done = smartpromise.defer();
+    console.log('flowTask2');
+    console.log(x);
+    done.resolve(x);
+    return done.promise;
+  },
+  preTask: flowTask1
+});
+
+const flowTask3 = new taskbuffer.Taskchain({
+  taskArray: [flowTask1, flowTask2]
+});
+
+tap.test('should let a value flow through a task', async () => {
+  const result = await flowTask1.trigger(12);
+  expect(result).to.equal(12);
+});
+
+tap.test('expect values to flow between tasks', async () => {
+  const result = await flowTask2.trigger(12);
+  expect(result).to.equal(12);
+});
+
+tap.test('expect values to flow between tasks when buffered', async () => {
+  const result = await flowTaskBuffered.trigger(12);
+  expect(result).to.equal(12);
+});
+
+tap.test('expect values to flow between tasks in Taskchain', async () => {
+  const result = await flowTask3.trigger(12);
+  expect(result).to.equal(12);
+});
+
+tap.start();

test/test.6.taskonce.ts

@@ -0,0 +1,28 @@
+import { expect, tap } from '@pushrocks/tapbundle';
+
+import * as taskbuffer from '../ts/index';
+
+let myNumber = 0;
+let myTaskOnce: taskbuffer.TaskOnce;
+
+tap.test('should create a valid instance of TaskOnce', async () => {
+  myTaskOnce = new taskbuffer.TaskOnce({
+    taskFunction: async () => {
+      myNumber++;
+    }
+  });
+  expect(myTaskOnce).to.be.instanceof(taskbuffer.TaskOnce);
+});
+
+tap.test('myNumber should still be 0', async () => {
+  expect(myNumber).to.equal(0);
+});
+
+tap.test('myTaskOnce should trigger once', async () => {
+  await myTaskOnce.trigger();
+  await myTaskOnce.trigger();
+  await myTaskOnce.trigger();
+  expect(myNumber).to.equal(1);
+});
+
+tap.start();

test/test.7.taskloop.ts

@@ -0,0 +1,51 @@
+import { tap, expect } from '@pushrocks/tapbundle';
+
+import * as taskbuffer from  '../ts';
+
+let preTask: taskbuffer.Task;
+let afterTask: taskbuffer.Task;
+
+let mainTask: taskbuffer.Task;
+
+tap.test('should create tasks', async () => {
+  preTask = new taskbuffer.Task({
+    name: 'myPreTask',
+    taskFunction: async () => {
+      console.log('pretask executed :)');
+      return 'hi';
+    }
+  });
+  afterTask = new taskbuffer.Task({
+    name: 'myAfterTask',
+    taskFunction: async (x) => {
+      if (x === 'hi') {
+        console.log('afterTask: values get passed along alright');
+      }
+      console.log('afterTask executed :)');
+      return x;
+    },
+    preTask,
+    afterTask
+  });
+
+  mainTask = new taskbuffer.Task({
+    name: 'mainTask',
+    taskFunction: async (x) => {
+      if (x === 'hi') {
+        console.log('mainTask: values get passed along alright');
+      }
+      console.log('afterTask executed :)');
+      return x;
+    },
+    preTask: () => {
+      return preTask;
+    },
+    afterTask
+  });
+});
+
+tap.test('should execute the mainTask', async () => {
+  await mainTask.trigger();
+});
+
+tap.start();

test/test.d.ts

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

test/test.ts

@@ -1,202 +0,0 @@
-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,7 +1,8 @@
-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";
+export { Task, ITaskFunction } from './taskbuffer.classes.task';
+export { Taskchain } from './taskbuffer.classes.taskchain';
+export { Taskparallel } from './taskbuffer.classes.taskparallel';
+export { TaskManager } from './taskbuffer.classes.taskmanager';
+export { TaskOnce } from './taskbuffer.classes.taskonce';
 
 // import for naming only
-import "./taskbuffer.classes.helpers"
+import './taskbuffer.classes.helpers';

ts/taskbuffer.classes.bufferrunner.ts

@@ -0,0 +1,42 @@
+import { Task } from "./taskbuffer.classes.task";
+
+export class BufferRunner {
+  public task: Task;
+  // initialze by default
+  public bufferCounter: number = 0;
+  public running: boolean = false;
+  constructor(taskArg: Task) {
+    this.task = taskArg;
+  }
+
+  public trigger(x): Promise<any> {
+    if (!(this.bufferCounter >= this.task.bufferMax)) {
+      this.bufferCounter++;
+    }
+    const returnPromise: Promise<any> = this.task.cycleCounter.getPromiseForCycle(
+      this.bufferCounter + 1
+    );
+    if (!this.running) {
+      this._run(x);
+    }
+    return returnPromise;
+  }
+
+  private _run(x) {
+    const recursiveBufferRunner = x => {
+      if (this.bufferCounter >= 0) {
+        this.running = true;
+        this.task.running = true;
+        Task.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);
+  }
+}

ts/taskbuffer.classes.cyclecounter.ts

@@ -0,0 +1,36 @@
+import * as plugins from './taskbuffer.plugins';
+import { Task } from './taskbuffer.classes.task';
+
+export interface ICycleObject {
+  cycleCounter: number;
+  deferred: plugins.smartpromise.Deferred<any>;
+}
+
+export class CycleCounter {
+  public task: Task;
+  public cycleObjectArray: ICycleObject[] = [];
+  constructor(taskArg: Task) {
+    this.task = taskArg;
+  }
+  public getPromiseForCycle(cycleCountArg: number) {
+    const done = plugins.smartpromise.defer();
+    const cycleObject: ICycleObject = {
+      cycleCounter: cycleCountArg,
+      deferred: done
+    };
+    this.cycleObjectArray.push(cycleObject);
+    return done.promise;
+  }
+  public informOfCycle(x) {
+    const newCycleObjectArray: ICycleObject[] = [];
+    this.cycleObjectArray.forEach(cycleObjectArg => {
+      cycleObjectArg.cycleCounter--;
+      if (cycleObjectArg.cycleCounter <= 0) {
+        cycleObjectArg.deferred.resolve(x);
+      } else {
+        newCycleObjectArray.push(cycleObjectArg);
+      }
+    });
+    this.cycleObjectArray = newCycleObjectArray;
+  }
+}

ts/taskbuffer.classes.helpers.ts

@@ -1,157 +1,5 @@
-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;
-    }
-};
+import plugins = require('./taskbuffer.plugins');
+import { Task, ITaskFunction } from './taskbuffer.classes.task';
 
 
-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);
-        }).catch((err) => {
-            console.log(err);
-        });
-    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

@@ -1,77 +1,219 @@
-import * as plugins from "./taskbuffer.plugins"
-import * as helpers from "./taskbuffer.classes.helpers"
-
+import * as plugins from './taskbuffer.plugins';
+import * as helpers from './taskbuffer.classes.helpers';
+import { BufferRunner } from './taskbuffer.classes.bufferrunner';
+import { CycleCounter } from './taskbuffer.classes.cyclecounter';
 
 export interface ITaskFunction {
-    (x?:any):PromiseLike<any>;
+  (x?: any): PromiseLike<any>;
 }
 
+export type TPreOrAfterTaskFunction = () => Task;
+
 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;
+  // STATIC
+  public static extractTask(preOrAfterTaskArg: Task | TPreOrAfterTaskFunction): Task {
+    switch(true) {
+      case (!preOrAfterTaskArg):
+        return null;
+      case (preOrAfterTaskArg instanceof Task):
+        return preOrAfterTaskArg as Task;
+      case typeof preOrAfterTaskArg === "function":
+        const taskFunction = preOrAfterTaskArg as TPreOrAfterTaskFunction;
+        return taskFunction();
+      default:
+        return null;
     }
-    
-    /**
-     * 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);
-        };
+  }
+
+
+  public static emptyTaskFunction: ITaskFunction = function(x) {
+    const done = plugins.smartpromise.defer();
+    done.resolve();
+    return done.promise;
+  };
+  
+  public static isTask = (taskArg: Task): boolean => {
+    if (taskArg instanceof Task && typeof taskArg.taskFunction === 'function') {
+      return true;
+    } else {
+      return false;
+    }
+  };
+  
+  public static isTaskTouched = (taskArg: Task | TPreOrAfterTaskFunction, touchedTasksArray: Task[]): boolean => {
+    const taskToCheck = Task.extractTask(taskArg);
+    let result = false;
+    for (const keyArg in touchedTasksArray) {
+      if (taskToCheck === touchedTasksArray[keyArg]) {
+        result = true;
+      }
+    }
+    return result;
+  };
+  
+  public static runTask = async (taskArg: Task | TPreOrAfterTaskFunction, optionsArg: { x?; touchedTasksArray?: Task[] }) => {
+    const taskToRun = Task.extractTask(taskArg);
+    const done = plugins.smartpromise.defer();
+  
+    // pay respect to execDelay
+    if (taskToRun.execDelay) {
+      await plugins.smartdelay.delayFor(taskToRun.execDelay);
+    }
+  
+    //  set running params
+    taskToRun.running = true;
+  
+    done.promise.then(async () => {
+      taskToRun.running = false;
+    });
+  
+    // handle options
+    const options = {
+      ...{ x: undefined, touchedTasksArray: [] },
+      ...optionsArg
     };
-
-    /**
-     * 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";
+    const x = options.x;
+    const touchedTasksArray: Task[] = options.touchedTasksArray;
+  
+    touchedTasksArray.push(taskToRun);
+  
+    // run the task cascade
+    const localDeferred = plugins.smartpromise.defer();
+    localDeferred.promise
+      .then(() => {
+        // lets run any preTask
+        
+        if (taskToRun.preTask && !Task.isTaskTouched(taskToRun.preTask, touchedTasksArray)) {
+          return Task.runTask(taskToRun.preTask, { x, touchedTasksArray });
         } else {
-            plugins.beautylog.error("state type " + stateArg.blue + " could not be set");
+          const done2 = plugins.smartpromise.defer();
+          done2.resolve(x);
+          return done2.promise;
         }
+      })
+      .then(async x => {
+        // lets run the main task
+        try {
+          return await taskToRun.taskFunction(x);
+        } catch (e) {
+          console.log(e);
+        }
+      })
+      .then(x => {
+        if (taskToRun.afterTask && !Task.isTaskTouched(taskToRun.afterTask, touchedTasksArray)) {
+          return Task.runTask(taskToRun.afterTask, { x: x, touchedTasksArray: touchedTasksArray });
+        } else {
+          const done2 = plugins.smartpromise.defer();
+          done2.resolve(x);
+          return done2.promise;
+        }
+      })
+      .then(x => {
+        done.resolve(x);
+      })
+      .catch(err => {
+        console.log(err);
+      });
+    localDeferred.resolve();
+    return await done.promise;
+  }
+
+  // INSTANCE
+  // man datory properties
+  public name: string;
+  public taskFunction: ITaskFunction;
+  public buffered: boolean;
+
+  public bufferMax: number;
+  public execDelay: number;
+
+  // tasks to run before and after
+  public preTask: Task | TPreOrAfterTaskFunction;
+  public afterTask: Task | TPreOrAfterTaskFunction;
+
+  // initialize by default
+  public running: boolean = false;
+  public bufferRunner = new BufferRunner(this);
+  public cycleCounter = new CycleCounter(this);
+
+  public idle: boolean = true;
+  private _state: string = 'ready';
+
+  constructor(optionsArg: {
+    /**
+     * the task function to run, must return promise
+     */
+    taskFunction: ITaskFunction;
+    /**
+     * any other task to run before
+     */
+    preTask?: Task | TPreOrAfterTaskFunction;
+    /**
+     * any other task to run after
+     */
+    afterTask?: Task | TPreOrAfterTaskFunction;
+    /**
+     * wether this task should run buffered
+     */
+    buffered?: boolean;
+    /**
+     * the maximum buffer
+     */
+    bufferMax?: number;
+    /**
+     * the execution delay, before the task is executed
+     * only makes sense when running in buffered mode
+     */
+    execDelay?: number;
+    /**
+     * the name of the task
+     */
+    name?: string;
+  }) {
+    this.taskFunction = optionsArg.taskFunction;
+    this.preTask = optionsArg.preTask;
+    this.afterTask = optionsArg.afterTask;
+    this.idle = !this.running;
+    this.buffered = optionsArg.buffered;
+    this.bufferMax = optionsArg.bufferMax;
+    this.execDelay = optionsArg.execDelay;
+    this.name = optionsArg.name;
+  }
+
+  /**
+   * trigger the task. Will trigger buffered if this.buffered is true
+   */
+  public trigger(x?): Promise<any> {
+    if (this.buffered) {
+      return this.triggerBuffered(x);
+    } else {
+      return this.triggerUnBuffered(x);
     }
-}
+  }
+
+  /**
+   * trigger task unbuffered.
+   */
+  public triggerUnBuffered(x?): Promise<any> {
+    return Task.runTask(this, { x: x });
+  }
+
+  /**
+   * trigger task buffered.
+   */
+  public triggerBuffered(x?): Promise<any> {
+    return this.bufferRunner.trigger(x);
+  }
+
+  get state(): string {
+    return this._state;
+  }
+
+  set state(stateArg: string) {
+    if (stateArg === 'locked') {
+      this._state = 'locked';
+    } else {
+      plugins.smartlog.defaultLogger.log('error', 'state type ' + stateArg + ' could not be set');
+    }
+  }
+}

ts/taskbuffer.classes.taskchain.ts

@@ -1,60 +1,58 @@
-import * as plugins from "./taskbuffer.plugins";
-import {Task} from "./taskbuffer.classes.task";
-import helpers = require("./taskbuffer.classes.helpers");
+// TaskChain chains tasks
+// and extends Task
+
+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;
-                }
+  taskArray: Task[];
+  constructor(optionsArg: {
+    taskArray: Task[];
+    name?: string;
+    log?: boolean;
+    buffered?: boolean;
+    bufferMax?: number;
+  }) {
+    let options = {
+      ...{
+        name: 'unnamed Taskchain',
+        log: false
+      },
+      ...optionsArg,
+      ...{
+        taskFunction: (x: any) => {
+          // this is the function that gets executed when TaskChain is triggered
+          let done = plugins.smartpromise.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') {
+              console.log(this.name + ' running: Task' + this.taskArray[taskCounter].name);
+              this.taskArray[taskCounter].trigger(x).then(x => {
+                plugins.smartlog.defaultLogger.log('info', this.taskArray[taskCounter].name);
+                taskCounter++;
+                iterateTasks(x);
+              });
+            } else {
+              console.log('Taskchain "' + this.name + '" completed successfully');
+              done.resolve(x);
             }
-        );
-        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);
+          };
+          iterateTasks(x);
+          return done.promise;
+        }
+      }
     };
-    removeTask(taskArg:Task){
-        //TODO
-    };
-    shiftTask(){
-        
-    };
-};
+    super(options);
+    this.taskArray = optionsArg.taskArray;
+  }
+  addTask(taskArg: Task) {
+    this.taskArray.push(taskArg);
+  }
+  removeTask(taskArg: Task) {
+    // TODO:
+  }
+  shiftTask() {
+    // TODO:
+  }
+}

ts/taskbuffer.classes.taskmanager.ts

@@ -0,0 +1,109 @@
+import * as plugins from './taskbuffer.plugins';
+import { Task } from './taskbuffer.classes.task';
+
+export interface ICronJob {
+  cronString: string;
+  taskNameArg: string;
+  job: any;
+}
+
+export class TaskManager {
+  public taskMap = new plugins.lik.Objectmap<Task>();
+  private cronJobMap = new plugins.lik.Objectmap<ICronJob>();
+  
+  constructor() {
+    // nothing here
+  }
+
+  /**
+   * checks if a task is already present
+   * @param taskNameArg
+   */
+  public getTaskByName(taskNameArg): Task {
+    return this.taskMap.find(itemArg => {
+      return itemArg.name === taskNameArg;
+    });
+  }
+
+  /**
+   * adds a Task to the TaskManager
+   * @param taskArg
+   */
+  public addTask(taskArg: Task): void {
+    if (!taskArg.name) {
+      throw new Error('taskArg needs a name to be added to taskManager');
+    }
+    this.taskMap.add(taskArg);
+  }
+
+  /**
+   * adds and schedules a task at once
+   * @param taskArg
+   * @param cronStringArg
+   */
+  public addAndScheduleTask(taskArg: Task, cronStringArg: string) {
+    this.addTask(taskArg);
+    const taskName = taskArg.name;
+    this.scheduleTaskByName(taskName, cronStringArg);
+  }
+
+  /**
+   * triggers a task in the TaskManagerByName
+   * @param taskNameArg
+   */
+  public triggerTaskByName(taskNameArg: string): Promise<any> {
+    const taskToTrigger = this.getTaskByName(taskNameArg);
+    if (!taskToTrigger) {
+      throw new Error(`There is no task with the name of ${taskNameArg}`);
+    }
+    return taskToTrigger.trigger();
+  }
+
+  public async triggerTask(task: Task) {
+    return task.trigger();
+  }
+
+  /**
+   * schedules the task by name
+   * @param taskNameArg
+   */
+  public scheduleTaskByName(taskNameArg: string, cronStringArg: string) {
+    const taskToSchedule = this.getTaskByName(taskNameArg);
+    const job = new plugins.cron.CronJob({
+      cronTime: cronStringArg,
+      onTick: () => {
+        this.triggerTaskByName(taskNameArg);
+      },
+      start: true
+    });
+    this.cronJobMap.add({
+      taskNameArg: taskToSchedule.name,
+      cronString: cronStringArg,
+      job
+    });
+  }
+
+  /**
+   * deschedules a task by name
+   * @param taskNameArg 
+   */
+  public descheduleTaskByName(taskNameArg: string) {
+    const descheduledCron = this.cronJobMap.findOneAndRemove(itemArg => {
+      return itemArg.taskNameArg === taskNameArg;
+    });
+    descheduledCron.job.stop();
+  }
+
+  /**
+   * deschedules a task
+   * @param task
+   */
+  public async descheduleTask(task: Task) {
+    await this.descheduleTaskByName(task.name);
+  }
+  /**
+   * returns all schedules of a specific task
+   * @param taskNameArg
+   */
+  public getSchedulesForTaskName(taskNameArg: string) {}
+}

ts/taskbuffer.classes.taskonce.ts

@@ -0,0 +1,21 @@
+import * as plugins from './taskbuffer.plugins';
+
+import { Task, ITaskFunction } from './taskbuffer.classes.task';
+
+/**
+ * TaskOnce is run exactly once, no matter how often it is triggered
+ */
+export class TaskOnce extends Task {
+  hasTriggered: boolean = false;
+  constructor(optionsArg: { name?: string; taskFunction: ITaskFunction }) {
+    super({
+      name: optionsArg.name,
+      taskFunction: async () => {
+        if (!this.hasTriggered) {
+          this.hasTriggered = true;
+          await optionsArg.taskFunction();
+        }
+      }
+    });
+  }
+}

ts/taskbuffer.classes.taskparallel.ts

@@ -1,29 +1,25 @@
-import * as plugins from "./taskbuffer.plugins"
-import * as helpers from "./taskbuffer.classes.helpers"
-import { Task } from "./taskbuffer.classes.task"
+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;
-    }
+  public taskArray: Task[];
+  constructor(optionsArg: { taskArray: Task[] }) {
+    const options = {
+      ...optionsArg,
+      ...{
+        taskFunction: () => {
+          const done = plugins.smartpromise.defer();
+          const promiseArray: Promise<any>[] = []; // stores promises of all tasks, since they run in parallel
+          this.taskArray.forEach(function(taskArg) {
+            promiseArray.push(taskArg.trigger());
+          });
+          Promise.all(promiseArray).then(done.resolve);
+          return done.promise;
+        }
+      }
+    };
+    super(options);
+    this.taskArray = optionsArg.taskArray;
+  }
 }
-

ts/taskbuffer.classes.taskrunner.ts

@@ -0,0 +1,48 @@
+import * as plugins from './taskbuffer.plugins';
+
+import { Task } from './taskbuffer.classes.task';
+
+export class TaskRunner {
+  public maxParrallelJobs: number = 1;
+  public status: 'stopped' | 'running' = 'stopped';
+  public runningTasks: plugins.lik.Objectmap<Task> = new plugins.lik.Objectmap<Task>();
+  public qeuedTasks: Task[] = [];
+
+  /**
+   * adds a task to the qeue
+   */
+  public addTask(taskArg: Task) {
+    this.qeuedTasks.push(taskArg);
+  }
+
+  /**
+   * set amount of parallel tasks
+   * be careful, you might loose dependability of tasks
+   */
+  public setMaxParallelJobs(maxParrallelJobsArg: number) {
+    this.maxParrallelJobs = maxParrallelJobsArg;
+  }
+
+  /**
+   * starts the task queue
+   */
+  public start() {
+    this.status = 'running';
+  }
+
+  public async checkExecution() {
+    if (this.runningTasks.getArray().length < this.maxParrallelJobs) {
+      const nextJob = this.qeuedTasks.shift();
+      this.runningTasks.add(nextJob);
+      await nextJob.trigger();
+
+    }
+  }
+
+  /**
+   * stops the task queue
+   */
+  public stop() {
+    this.status = 'stopped';
+  };
+}

ts/taskbuffer.classes.taskspace.ts

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

ts/taskbuffer.plugins.ts

@@ -1,5 +1,8 @@
-import "typings-global"
-export import beautylog = require("beautylog");
-export import Q = require("q");
-export import lodash= require("lodash");
-export import rxjs = require("rxjs");
+import * as smartlog from '@pushrocks/smartlog';
+import cron from 'cron';
+import * as lik from '@pushrocks/lik';
+import * as rxjs from 'rxjs';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartdelay from '@pushrocks/smartdelay';
+
+export { smartlog, cron, lik, rxjs, smartpromise, smartdelay };

tslint.json

@@ -0,0 +1,17 @@
+{
+  "extends": ["tslint:latest", "tslint-config-prettier"],
+  "rules": {
+    "semicolon": [true, "always"],
+    "no-console": false,
+    "ordered-imports": false,
+    "object-literal-sort-keys": false,
+    "member-ordering": {
+      "options":{
+        "order": [
+          "static-method"
+        ]
+      }
+    }
+  },
+  "defaultSeverity": "warning"
+}