@push.rocks/taskbuffer 3.0.10

package/dist_ts/taskbuffer.classes.taskmanager.js

@@ -0,0 +1,129 @@
+import * as plugins from './taskbuffer.plugins.js';
+import './taskbuffer.classes.task.js';
+import './taskbuffer.classes.distributedcoordinator.js';
+export class TaskManager {
+    constructor(optionosArg = {}) {
+        this.randomId = plugins.isounique.uni();
+        this.taskMap = new plugins.lik.ObjectMap();
+        this.cronJobManager = new plugins.smarttime.CronManager();
+        this.options = {
+            distributedCoordinator: null
+        };
+        this.options = Object.assign(this.options, optionosArg);
+    }
+    /**
+     * checks if a task is already present
+     * @param taskNameArg
+     */
+    getTaskByName(taskNameArg) {
+        return this.taskMap.findSync((itemArg) => {
+            return itemArg.name === taskNameArg;
+        });
+    }
+    /**
+     * adds a Task to the TaskManager
+     * @param taskArg
+     */
+    addTask(taskArg) {
+        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
+     */
+    addAndScheduleTask(taskArg, cronStringArg) {
+        this.addTask(taskArg);
+        this.scheduleTaskByName(taskArg.name, cronStringArg);
+    }
+    /**
+     * triggers a task in the TaskManagerByName
+     * @param taskNameArg
+     */
+    triggerTaskByName(taskNameArg) {
+        const taskToTrigger = this.getTaskByName(taskNameArg);
+        if (!taskToTrigger) {
+            throw new Error(`There is no task with the name of ${taskNameArg}`);
+        }
+        return taskToTrigger.trigger();
+    }
+    async triggerTask(task) {
+        return task.trigger();
+    }
+    /**
+     * schedules the task by name
+     * @param taskNameArg
+     */
+    scheduleTaskByName(taskNameArg, cronStringArg) {
+        const taskToSchedule = this.getTaskByName(taskNameArg);
+        const cronJob = this.cronJobManager.addCronjob(cronStringArg, async (triggerTimeArg) => {
+            console.log(`taskbuffer schedule triggered task >>${taskToSchedule.name}<<`);
+            console.log(`task >>${taskToSchedule.name}<< is ${taskToSchedule.buffered
+                ? `buffered with max ${taskToSchedule.bufferMax} buffered calls`
+                : `unbuffered`}`);
+            if (this.options.distributedCoordinator) {
+                console.log(`Found a distrubuted coordinator, performing distributed consultation.`);
+                const announcementResult = await this.options.distributedCoordinator.fireDistributedTaskRequest({
+                    submitterRandomId: this.randomId,
+                    status: 'requesting',
+                    taskExecutionParallel: 1,
+                    taskExecutionTime: triggerTimeArg,
+                    taskExecutionTimeout: taskToSchedule.timeout,
+                    taskName: taskToSchedule.name,
+                    taskVersion: taskToSchedule.version,
+                });
+                if (!announcementResult.shouldTrigger) {
+                    console.log('distributed coordinator result: NOT EXECUTING');
+                    return;
+                }
+                else {
+                    console.log('distributed coordinator result: CHOSEN AND EXECUTING');
+                }
+            }
+            await taskToSchedule.trigger();
+        });
+        taskToSchedule.cronJob = cronJob;
+    }
+    /**
+     * deschedules a task by name
+     * @param taskNameArg
+     */
+    descheduleTaskByName(taskNameArg) {
+        const taskToDeSchedule = this.getTaskByName(taskNameArg);
+        if (taskToDeSchedule.cronJob) {
+            this.cronJobManager.removeCronjob(taskToDeSchedule.cronJob);
+            taskToDeSchedule.cronJob = null;
+        }
+        if (this.cronJobManager.cronjobs.isEmpty) {
+            this.cronJobManager.stop();
+        }
+    }
+    /**
+     * deschedules a task
+     * @param task
+     */
+    async descheduleTask(task) {
+        await this.descheduleTaskByName(task.name);
+    }
+    /**
+     * returns all schedules of a specific task
+     * @param taskNameArg
+     */
+    getSchedulesForTaskName(taskNameArg) { }
+    /**
+     * starts the taskmanager
+     */
+    start() {
+        this.cronJobManager.start();
+    }
+    /**
+     * stops the taskmanager
+     */
+    stop() {
+        this.cronJobManager.stop();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/taskbuffer.classes.taskonce.d.ts

@@ -0,0 +1,11 @@
+import { Task, ITaskFunction } from './taskbuffer.classes.task.js';
+/**
+ * TaskOnce is run exactly once, no matter how often it is triggered
+ */
+export declare class TaskOnce extends Task {
+    hasTriggered: boolean;
+    constructor(optionsArg: {
+        name?: string;
+        taskFunction: ITaskFunction;
+    });
+}

package/dist_ts/taskbuffer.classes.taskonce.js

@@ -0,0 +1,20 @@
+import './taskbuffer.plugins.js';
+import { Task } from './taskbuffer.classes.task.js';
+/**
+ * TaskOnce is run exactly once, no matter how often it is triggered
+ */
+export class TaskOnce extends Task {
+    constructor(optionsArg) {
+        super({
+            name: optionsArg.name,
+            taskFunction: async () => {
+                if (!this.hasTriggered) {
+                    this.hasTriggered = true;
+                    await optionsArg.taskFunction();
+                }
+            },
+        });
+        this.hasTriggered = false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5jbGFzc2VzLnRhc2tvbmNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvdGFza2J1ZmZlci5jbGFzc2VzLnRhc2tvbmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQXlCLHlCQUF5QixDQUFDO0FBRW5ELE9BQU8sRUFBRSxJQUFJLEVBQWlCLE1BQU0sOEJBQThCLENBQUM7QUFFbkU7O0dBRUc7QUFDSCxNQUFNLE9BQU8sUUFBUyxTQUFRLElBQUk7SUFFaEMsWUFBWSxVQUEwRDtRQUNwRSxLQUFLLENBQUM7WUFDSixJQUFJLEVBQUUsVUFBVSxDQUFDLElBQUk7WUFDckIsWUFBWSxFQUFFLEtBQUssSUFBSSxFQUFFO2dCQUN2QixJQUFJLENBQUMsSUFBSSxDQUFDLFlBQVksRUFBRTtvQkFDdEIsSUFBSSxDQUFDLFlBQVksR0FBRyxJQUFJLENBQUM7b0JBQ3pCLE1BQU0sVUFBVSxDQUFDLFlBQVksRUFBRSxDQUFDO2lCQUNqQztZQUNILENBQUM7U0FDRixDQUFDLENBQUM7UUFWTCxpQkFBWSxHQUFZLEtBQUssQ0FBQztJQVc5QixDQUFDO0NBQ0YifQ==

package/dist_ts/taskbuffer.classes.taskparallel.d.ts

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

package/dist_ts/taskbuffer.classes.taskparallel.js

@@ -0,0 +1,23 @@
+import * as plugins from './taskbuffer.plugins.js';
+import { Task } from './taskbuffer.classes.task.js';
+export class Taskparallel extends Task {
+    constructor(optionsArg) {
+        const options = {
+            ...optionsArg,
+            ...{
+                taskFunction: () => {
+                    const done = plugins.smartpromise.defer();
+                    const promiseArray = []; // 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;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5jbGFzc2VzLnRhc2twYXJhbGxlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3Rhc2tidWZmZXIuY2xhc3Nlcy50YXNrcGFyYWxsZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSx5QkFBeUIsQ0FBQztBQUNuRCxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFFcEQsTUFBTSxPQUFPLFlBQWEsU0FBUSxJQUFJO0lBRXBDLFlBQVksVUFBaUM7UUFDM0MsTUFBTSxPQUFPLEdBQUc7WUFDZCxHQUFHLFVBQVU7WUFDYixHQUFHO2dCQUNELFlBQVksRUFBRSxHQUFHLEVBQUU7b0JBQ2pCLE1BQU0sSUFBSSxHQUFHLE9BQU8sQ0FBQyxZQUFZLENBQUMsS0FBSyxFQUFFLENBQUM7b0JBQzFDLE1BQU0sWUFBWSxHQUFtQixFQUFFLENBQUMsQ0FBQywyREFBMkQ7b0JBQ3BHLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLFVBQVUsT0FBTzt3QkFDdEMsWUFBWSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FBQztvQkFDdkMsQ0FBQyxDQUFDLENBQUM7b0JBQ0gsT0FBTyxDQUFDLEdBQUcsQ0FBQyxZQUFZLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDO29CQUM3QyxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUM7Z0JBQ3RCLENBQUM7YUFDRjtTQUNGLENBQUM7UUFDRixLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDZixJQUFJLENBQUMsU0FBUyxHQUFHLFVBQVUsQ0FBQyxTQUFTLENBQUM7SUFDeEMsQ0FBQztDQUNGIn0=

package/dist_ts/taskbuffer.classes.taskrunner.d.ts

@@ -0,0 +1,30 @@
+import * as plugins from './taskbuffer.plugins.js';
+import { Task } from './taskbuffer.classes.task.js';
+export declare class TaskRunner {
+    maxParrallelJobs: number;
+    status: 'stopped' | 'running';
+    runningTasks: plugins.lik.ObjectMap<Task>;
+    qeuedTasks: Task[];
+    constructor();
+    /**
+     * adds a task to the qeue
+     */
+    addTask(taskArg: Task): void;
+    /**
+     * set amount of parallel tasks
+     * be careful, you might loose dependability of tasks
+     */
+    setMaxParallelJobs(maxParrallelJobsArg: number): void;
+    /**
+     * starts the task queue
+     */
+    start(): Promise<void>;
+    /**
+     * checks wether execution is on point
+     */
+    checkExecution(): Promise<void>;
+    /**
+     * stops the task queue
+     */
+    stop(): Promise<void>;
+}

package/dist_ts/taskbuffer.classes.taskrunner.js

@@ -0,0 +1,54 @@
+import * as plugins from './taskbuffer.plugins.js';
+import './taskbuffer.classes.task.js';
+export class TaskRunner {
+    constructor() {
+        this.maxParrallelJobs = 1;
+        this.status = 'stopped';
+        this.runningTasks = new plugins.lik.ObjectMap();
+        this.qeuedTasks = [];
+        this.runningTasks.eventSubject.subscribe(async (eventArg) => {
+            this.checkExecution();
+        });
+    }
+    /**
+     * adds a task to the qeue
+     */
+    addTask(taskArg) {
+        this.qeuedTasks.push(taskArg);
+        this.checkExecution();
+    }
+    /**
+     * set amount of parallel tasks
+     * be careful, you might loose dependability of tasks
+     */
+    setMaxParallelJobs(maxParrallelJobsArg) {
+        this.maxParrallelJobs = maxParrallelJobsArg;
+    }
+    /**
+     * starts the task queue
+     */
+    async start() {
+        this.status = 'running';
+    }
+    /**
+     * checks wether execution is on point
+     */
+    async checkExecution() {
+        if (this.runningTasks.getArray().length < this.maxParrallelJobs &&
+            this.status === 'running' &&
+            this.qeuedTasks.length > 0) {
+            const nextJob = this.qeuedTasks.shift();
+            this.runningTasks.add(nextJob);
+            await nextJob.trigger();
+            this.runningTasks.remove(nextJob);
+            this.checkExecution();
+        }
+    }
+    /**
+     * stops the task queue
+     */
+    async stop() {
+        this.status = 'stopped';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5jbGFzc2VzLnRhc2tydW5uZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy90YXNrYnVmZmVyLmNsYXNzZXMudGFza3J1bm5lci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLHlCQUF5QixDQUFDO0FBRW5ELE9BQXFCLDhCQUE4QixDQUFDO0FBRXBELE1BQU0sT0FBTyxVQUFVO0lBTXJCO1FBTE8scUJBQWdCLEdBQVcsQ0FBQyxDQUFDO1FBQzdCLFdBQU0sR0FBMEIsU0FBUyxDQUFDO1FBQzFDLGlCQUFZLEdBQWdDLElBQUksT0FBTyxDQUFDLEdBQUcsQ0FBQyxTQUFTLEVBQVEsQ0FBQztRQUM5RSxlQUFVLEdBQVcsRUFBRSxDQUFDO1FBRzdCLElBQUksQ0FBQyxZQUFZLENBQUMsWUFBWSxDQUFDLFNBQVMsQ0FBQyxLQUFLLEVBQUUsUUFBUSxFQUFFLEVBQUU7WUFDMUQsSUFBSSxDQUFDLGNBQWMsRUFBRSxDQUFDO1FBQ3hCLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVEOztPQUVHO0lBQ0ksT0FBTyxDQUFDLE9BQWE7UUFDMUIsSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDOUIsSUFBSSxDQUFDLGNBQWMsRUFBRSxDQUFDO0lBQ3hCLENBQUM7SUFFRDs7O09BR0c7SUFDSSxrQkFBa0IsQ0FBQyxtQkFBMkI7UUFDbkQsSUFBSSxDQUFDLGdCQUFnQixHQUFHLG1CQUFtQixDQUFDO0lBQzlDLENBQUM7SUFFRDs7T0FFRztJQUNJLEtBQUssQ0FBQyxLQUFLO1FBQ2hCLElBQUksQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDO0lBQzFCLENBQUM7SUFFRDs7T0FFRztJQUNJLEtBQUssQ0FBQyxjQUFjO1FBQ3pCLElBQ0UsSUFBSSxDQUFDLFlBQVksQ0FBQyxRQUFRLEVBQUUsQ0FBQyxNQUFNLEdBQUcsSUFBSSxDQUFDLGdCQUFnQjtZQUMzRCxJQUFJLENBQUMsTUFBTSxLQUFLLFNBQVM7WUFDekIsSUFBSSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxFQUMxQjtZQUNBLE1BQU0sT0FBTyxHQUFHLElBQUksQ0FBQyxVQUFVLENBQUMsS0FBSyxFQUFFLENBQUM7WUFDeEMsSUFBSSxDQUFDLFlBQVksQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLENBQUM7WUFDL0IsTUFBTSxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUM7WUFDeEIsSUFBSSxDQUFDLFlBQVksQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUM7WUFDbEMsSUFBSSxDQUFDLGNBQWMsRUFBRSxDQUFDO1NBQ3ZCO0lBQ0gsQ0FBQztJQUVEOztPQUVHO0lBQ0ksS0FBSyxDQUFDLElBQUk7UUFDZixJQUFJLENBQUMsTUFBTSxHQUFHLFNBQVMsQ0FBQztJQUMxQixDQUFDO0NBQ0YifQ==

package/dist_ts/taskbuffer.logging.d.ts

@@ -0,0 +1,2 @@
+import * as plugins from './taskbuffer.plugins.js';
+export declare const logger: plugins.smartlog.ConsoleLog;

package/dist_ts/taskbuffer.logging.js

@@ -0,0 +1,3 @@
+import * as plugins from './taskbuffer.plugins.js';
+export const logger = new plugins.smartlog.ConsoleLog();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5sb2dnaW5nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvdGFza2J1ZmZlci5sb2dnaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0seUJBQXlCLENBQUM7QUFFbkQsTUFBTSxDQUFDLE1BQU0sTUFBTSxHQUFHLElBQUksT0FBTyxDQUFDLFFBQVEsQ0FBQyxVQUFVLEVBQUUsQ0FBQyJ9

package/dist_ts/taskbuffer.plugins.d.ts

@@ -0,0 +1,8 @@
+import * as isounique from '@pushrocks/isounique';
+import * as lik from '@pushrocks/lik';
+import * as smartlog from '@pushrocks/smartlog';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartdelay from '@pushrocks/smartdelay';
+import * as smartrx from '@pushrocks/smartrx';
+import * as smarttime from '@pushrocks/smarttime';
+export { isounique, lik, smartlog, smartpromise, smartdelay, smartrx, smarttime };

package/dist_ts/taskbuffer.plugins.js

@@ -0,0 +1,9 @@
+import * as isounique from '@pushrocks/isounique';
+import * as lik from '@pushrocks/lik';
+import * as smartlog from '@pushrocks/smartlog';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartdelay from '@pushrocks/smartdelay';
+import * as smartrx from '@pushrocks/smartrx';
+import * as smarttime from '@pushrocks/smarttime';
+export { isounique, lik, smartlog, smartpromise, smartdelay, smartrx, smarttime };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5wbHVnaW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvdGFza2J1ZmZlci5wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxTQUFTLE1BQU0sc0JBQXNCLENBQUM7QUFDbEQsT0FBTyxLQUFLLEdBQUcsTUFBTSxnQkFBZ0IsQ0FBQztBQUN0QyxPQUFPLEtBQUssUUFBUSxNQUFNLHFCQUFxQixDQUFDO0FBQ2hELE9BQU8sS0FBSyxZQUFZLE1BQU0seUJBQXlCLENBQUM7QUFDeEQsT0FBTyxLQUFLLFVBQVUsTUFBTSx1QkFBdUIsQ0FBQztBQUNwRCxPQUFPLEtBQUssT0FBTyxNQUFNLG9CQUFvQixDQUFDO0FBQzlDLE9BQU8sS0FBSyxTQUFTLE1BQU0sc0JBQXNCLENBQUM7QUFFbEQsT0FBTyxFQUFFLFNBQVMsRUFBRSxHQUFHLEVBQUUsUUFBUSxFQUFFLFlBQVksRUFBRSxVQUFVLEVBQUUsT0FBTyxFQUFFLFNBQVMsRUFBRSxDQUFDIn0=

package/npmextra.json

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

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@push.rocks/taskbuffer",
+  "version": "3.0.10",
+  "private": false,
+  "description": "flexible task management. TypeScript ready!",
+  "main": "dist_ts/index.js",
+  "typings": "dist_ts/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "test": "(tstest test/ --web)",
+    "build": "(tsbuild --web && tsbundle npm)"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/pushrocks/taskbuffer.git"
+  },
+  "keywords": [
+    "gulp",
+    "task",
+    "buffer",
+    "TypeScript",
+    "push.rocks"
+  ],
+  "author": "Lossless GmbH",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://gitlab.com/pushrocks/taskbuffer/issues"
+  },
+  "homepage": "https://gitlab.com/pushrocks/taskbuffer#readme",
+  "dependencies": {
+    "@pushrocks/isounique": "^1.0.5",
+    "@pushrocks/lik": "^6.0.0",
+    "@pushrocks/smartdelay": "^2.0.13",
+    "@pushrocks/smartlog": "^3.0.1",
+    "@pushrocks/smartpromise": "^3.1.7",
+    "@pushrocks/smartrx": "^3.0.0",
+    "@pushrocks/smarttime": "^4.0.1"
+  },
+  "devDependencies": {
+    "@gitzone/tsbuild": "^2.1.63",
+    "@gitzone/tsbundle": "^2.0.6",
+    "@gitzone/tsrun": "^1.2.39",
+    "@gitzone/tstest": "^1.0.72",
+    "@pushrocks/tapbundle": "^5.0.4",
+    "@types/node": "^18.11.18"
+  },
+  "files": [
+    "ts/**/*",
+    "ts_web/**/*",
+    "dist/**/*",
+    "dist_*/**/*",
+    "dist_ts/**/*",
+    "dist_ts_web/**/*",
+    "assets/**/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
+  ]
+}

package/readme.md

@@ -0,0 +1,63 @@
+# @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
+
+Status Category | Status Badge
+-- | --
+GitLab Pipelines | [![pipeline status](https://gitlab.com/pushrocks/taskbuffer/badges/master/pipeline.svg)](https://lossless.cloud)
+GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/pushrocks/taskbuffer/badges/master/coverage.svg)](https://lossless.cloud)
+npm | [![npm downloads per month](https://badgen.net/npm/dy/@pushrocks/taskbuffer)](https://lossless.cloud)
+Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/pushrocks/taskbuffer)](https://lossless.cloud)
+TypeScript Support | [![TypeScript](https://badgen.net/badge/TypeScript/>=%203.x/blue?icon=typescript)](https://lossless.cloud)
+node Support | [![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+Code Style | [![Code Style](https://badgen.net/badge/style/prettier/purple)](https://lossless.cloud)
+PackagePhobia (total standalone install weight) | [![PackagePhobia](https://badgen.net/packagephobia/install/@pushrocks/taskbuffer)](https://lossless.cloud)
+PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@pushrocks/taskbuffer)](https://lossless.cloud)
+BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@pushrocks/taskbuffer)](https://lossless.cloud)
+Platform support | [![Supports Windows 10](https://badgen.net/badge/supports%20Windows%2010/yes/green?icon=windows)](https://lossless.cloud) [![Supports Mac OS X](https://badgen.net/badge/supports%20Mac%20OS%20X/yes/green?icon=apple)](https://lossless.cloud)
+
+## 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)
+
+## Contribution
+
+We are always happy for code contributions. If you are not the code contributing type that is ok. Still, maintaining Open Source repositories takes considerable time and thought. If you like the quality of what we do and our modules are useful to you we would appreciate a little monthly contribution: You can [contribute one time](https://lossless.link/contribute-onetime) or [contribute monthly](https://lossless.link/contribute). :)
+
+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)

package/ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@pushrocks/taskbuffer',
+  version: '3.0.10',
+  description: 'flexible task management. TypeScript ready!'
+}

package/ts/index.ts

@@ -0,0 +1,12 @@
+export { Task } from './taskbuffer.classes.task.js';
+export type { ITaskFunction } from './taskbuffer.classes.task.js'
+export { Taskchain } from './taskbuffer.classes.taskchain.js';
+export { Taskparallel } from './taskbuffer.classes.taskparallel.js';
+export { TaskManager } from './taskbuffer.classes.taskmanager.js';
+export { TaskOnce } from './taskbuffer.classes.taskonce.js';
+export { TaskRunner } from './taskbuffer.classes.taskrunner.js';
+export { TaskDebounced } from './taskbuffer.classes.taskdebounced.js';
+import * as distributedCoordination from './taskbuffer.classes.distributedcoordinator.js';
+export {
+  distributedCoordination
+}

package/ts/taskbuffer.classes.bufferrunner.ts

@@ -0,0 +1,39 @@
+import { Task } from './taskbuffer.classes.task.js';
+
+export class BufferRunner {
+  public task: Task;
+  // initialze by default
+  public bufferCounter: number = 0;
+  constructor(taskArg: Task) {
+    this.task = taskArg;
+  }
+
+  public trigger(x: any): Promise<any> {
+    if (!(this.bufferCounter >= this.task.bufferMax)) {
+      this.bufferCounter++;
+    }
+    const returnPromise: Promise<any> = this.task.cycleCounter.getPromiseForCycle(
+      this.bufferCounter + 1
+    );
+    if (!this.task.running) {
+      this._run(x);
+    }
+    return returnPromise;
+  }
+
+  private _run(x: any) {
+    const recursiveBufferRunner = (x: any) => {
+      if (this.bufferCounter >= 0) {
+        this.task.running = true;
+        Task.runTask(this.task, { x: x }).then((x) => {
+          this.bufferCounter--; // this.bufferCounter drops below 0, the recursion stops.
+          this.task.cycleCounter.informOfCycle(x);
+          recursiveBufferRunner(x);
+        });
+      } else {
+        this.task.running = false;
+      }
+    };
+    recursiveBufferRunner(x);
+  }
+}

package/ts/taskbuffer.classes.cyclecounter.ts

@@ -0,0 +1,36 @@
+import * as plugins from './taskbuffer.plugins.js';
+import { Task } from './taskbuffer.classes.task.js';
+
+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: any) {
+    const newCycleObjectArray: ICycleObject[] = [];
+    this.cycleObjectArray.forEach((cycleObjectArg) => {
+      cycleObjectArg.cycleCounter--;
+      if (cycleObjectArg.cycleCounter <= 0) {
+        cycleObjectArg.deferred.resolve(x);
+      } else {
+        newCycleObjectArray.push(cycleObjectArg);
+      }
+    });
+    this.cycleObjectArray = newCycleObjectArray;
+  }
+}

package/ts/taskbuffer.classes.distributedcoordinator.ts

@@ -0,0 +1,34 @@
+import { Task } from './taskbuffer.classes.task.js';
+import * as plugins from './taskbuffer.plugins.js';
+
+/**
+ * constains all data for the final coordinator to actually make an informed decision
+ */
+export interface IDistributedTaskRequest {
+  /**
+   * this needs to correlate to the consultationResult
+   */
+  submitterRandomId: string;
+  taskName: string;
+  taskVersion: string;
+  taskExecutionTime: number;
+  taskExecutionTimeout: number;
+  taskExecutionParallel: number;
+  status: 'requesting' | 'gotRejected' | 'failed' | 'succeeded';
+}
+
+export interface IDistributedTaskRequestResult {
+  /**
+   * this needs to correlate to the decisionInfoBasis
+   */
+  submitterRandomId: string;
+  considered: boolean;
+  rank: string;
+  reason: string;
+  shouldTrigger: boolean;
+}
+
+export abstract class AbstractDistributedCoordinator {
+  public abstract fireDistributedTaskRequest(infoBasisArg: IDistributedTaskRequest): Promise<IDistributedTaskRequestResult>
+  public abstract updateDistributedTaskRequest(infoBasisArg: IDistributedTaskRequest): Promise<void>
+}