@push.rocks/taskbuffer 3.0.10

package/dist_ts/00_commitinfo_data.d.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export declare const commitinfo: {
+    name: string;
+    version: string;
+    description: string;
+};

package/dist_ts/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@pushrocks/taskbuffer',
+    version: '3.0.10',
+    description: 'flexible task management. TypeScript ready!'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx1QkFBdUI7SUFDN0IsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLDZDQUE2QztDQUMzRCxDQUFBIn0=

package/dist_ts/index.d.ts

@@ -0,0 +1,10 @@
+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/dist_ts/index.js

@@ -0,0 +1,10 @@
+export { Task } 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 };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFFcEQsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBQzlELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxzQ0FBc0MsQ0FBQztBQUNwRSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFDbEUsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBQzVELE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUNoRSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sdUNBQXVDLENBQUM7QUFDdEUsT0FBTyxLQUFLLHVCQUF1QixNQUFNLGdEQUFnRCxDQUFDO0FBQzFGLE9BQU8sRUFDTCx1QkFBdUIsRUFDeEIsQ0FBQSJ9

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

@@ -0,0 +1,8 @@
+import { Task } from './taskbuffer.classes.task.js';
+export declare class BufferRunner {
+    task: Task;
+    bufferCounter: number;
+    constructor(taskArg: Task);
+    trigger(x: any): Promise<any>;
+    private _run;
+}

package/dist_ts/taskbuffer.classes.bufferrunner.js

@@ -0,0 +1,35 @@
+import { Task } from './taskbuffer.classes.task.js';
+export class BufferRunner {
+    constructor(taskArg) {
+        // initialze by default
+        this.bufferCounter = 0;
+        this.task = taskArg;
+    }
+    trigger(x) {
+        if (!(this.bufferCounter >= this.task.bufferMax)) {
+            this.bufferCounter++;
+        }
+        const returnPromise = this.task.cycleCounter.getPromiseForCycle(this.bufferCounter + 1);
+        if (!this.task.running) {
+            this._run(x);
+        }
+        return returnPromise;
+    }
+    _run(x) {
+        const recursiveBufferRunner = (x) => {
+            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);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5jbGFzc2VzLmJ1ZmZlcnJ1bm5lci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3Rhc2tidWZmZXIuY2xhc3Nlcy5idWZmZXJydW5uZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBRXBELE1BQU0sT0FBTyxZQUFZO0lBSXZCLFlBQVksT0FBYTtRQUZ6Qix1QkFBdUI7UUFDaEIsa0JBQWEsR0FBVyxDQUFDLENBQUM7UUFFL0IsSUFBSSxDQUFDLElBQUksR0FBRyxPQUFPLENBQUM7SUFDdEIsQ0FBQztJQUVNLE9BQU8sQ0FBQyxDQUFNO1FBQ25CLElBQUksQ0FBQyxDQUFDLElBQUksQ0FBQyxhQUFhLElBQUksSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsRUFBRTtZQUNoRCxJQUFJLENBQUMsYUFBYSxFQUFFLENBQUM7U0FDdEI7UUFDRCxNQUFNLGFBQWEsR0FBaUIsSUFBSSxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsa0JBQWtCLENBQzNFLElBQUksQ0FBQyxhQUFhLEdBQUcsQ0FBQyxDQUN2QixDQUFDO1FBQ0YsSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFO1lBQ3RCLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUM7U0FDZDtRQUNELE9BQU8sYUFBYSxDQUFDO0lBQ3ZCLENBQUM7SUFFTyxJQUFJLENBQUMsQ0FBTTtRQUNqQixNQUFNLHFCQUFxQixHQUFHLENBQUMsQ0FBTSxFQUFFLEVBQUU7WUFDdkMsSUFBSSxJQUFJLENBQUMsYUFBYSxJQUFJLENBQUMsRUFBRTtnQkFDM0IsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLEdBQUcsSUFBSSxDQUFDO2dCQUN6QixJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsRUFBRSxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRTtvQkFDM0MsSUFBSSxDQUFDLGFBQWEsRUFBRSxDQUFDLENBQUMseURBQXlEO29CQUMvRSxJQUFJLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxhQUFhLENBQUMsQ0FBQyxDQUFDLENBQUM7b0JBQ3hDLHFCQUFxQixDQUFDLENBQUMsQ0FBQyxDQUFDO2dCQUMzQixDQUFDLENBQUMsQ0FBQzthQUNKO2lCQUFNO2dCQUNMLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxHQUFHLEtBQUssQ0FBQzthQUMzQjtRQUNILENBQUMsQ0FBQztRQUNGLHFCQUFxQixDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQzNCLENBQUM7Q0FDRiJ9

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

@@ -0,0 +1,13 @@
+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 declare class CycleCounter {
+    task: Task;
+    cycleObjectArray: ICycleObject[];
+    constructor(taskArg: Task);
+    getPromiseForCycle(cycleCountArg: number): Promise<unknown>;
+    informOfCycle(x: any): void;
+}

package/dist_ts/taskbuffer.classes.cyclecounter.js

@@ -0,0 +1,31 @@
+import * as plugins from './taskbuffer.plugins.js';
+import './taskbuffer.classes.task.js';
+export class CycleCounter {
+    constructor(taskArg) {
+        this.cycleObjectArray = [];
+        this.task = taskArg;
+    }
+    getPromiseForCycle(cycleCountArg) {
+        const done = plugins.smartpromise.defer();
+        const cycleObject = {
+            cycleCounter: cycleCountArg,
+            deferred: done,
+        };
+        this.cycleObjectArray.push(cycleObject);
+        return done.promise;
+    }
+    informOfCycle(x) {
+        const newCycleObjectArray = [];
+        this.cycleObjectArray.forEach((cycleObjectArg) => {
+            cycleObjectArg.cycleCounter--;
+            if (cycleObjectArg.cycleCounter <= 0) {
+                cycleObjectArg.deferred.resolve(x);
+            }
+            else {
+                newCycleObjectArray.push(cycleObjectArg);
+            }
+        });
+        this.cycleObjectArray = newCycleObjectArray;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5jbGFzc2VzLmN5Y2xlY291bnRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3Rhc2tidWZmZXIuY2xhc3Nlcy5jeWNsZWNvdW50ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSx5QkFBeUIsQ0FBQztBQUNuRCxPQUFxQiw4QkFBOEIsQ0FBQztBQU9wRCxNQUFNLE9BQU8sWUFBWTtJQUd2QixZQUFZLE9BQWE7UUFEbEIscUJBQWdCLEdBQW1CLEVBQUUsQ0FBQztRQUUzQyxJQUFJLENBQUMsSUFBSSxHQUFHLE9BQU8sQ0FBQztJQUN0QixDQUFDO0lBQ00sa0JBQWtCLENBQUMsYUFBcUI7UUFDN0MsTUFBTSxJQUFJLEdBQUcsT0FBTyxDQUFDLFlBQVksQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUMxQyxNQUFNLFdBQVcsR0FBaUI7WUFDaEMsWUFBWSxFQUFFLGFBQWE7WUFDM0IsUUFBUSxFQUFFLElBQUk7U0FDZixDQUFDO1FBQ0YsSUFBSSxDQUFDLGdCQUFnQixDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQztRQUN4QyxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUM7SUFDdEIsQ0FBQztJQUNNLGFBQWEsQ0FBQyxDQUFNO1FBQ3pCLE1BQU0sbUJBQW1CLEdBQW1CLEVBQUUsQ0FBQztRQUMvQyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsT0FBTyxDQUFDLENBQUMsY0FBYyxFQUFFLEVBQUU7WUFDL0MsY0FBYyxDQUFDLFlBQVksRUFBRSxDQUFDO1lBQzlCLElBQUksY0FBYyxDQUFDLFlBQVksSUFBSSxDQUFDLEVBQUU7Z0JBQ3BDLGNBQWMsQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDO2FBQ3BDO2lCQUFNO2dCQUNMLG1CQUFtQixDQUFDLElBQUksQ0FBQyxjQUFjLENBQUMsQ0FBQzthQUMxQztRQUNILENBQUMsQ0FBQyxDQUFDO1FBQ0gsSUFBSSxDQUFDLGdCQUFnQixHQUFHLG1CQUFtQixDQUFDO0lBQzlDLENBQUM7Q0FDRiJ9

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

@@ -0,0 +1,29 @@
+/**
+ * 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 declare abstract class AbstractDistributedCoordinator {
+    abstract fireDistributedTaskRequest(infoBasisArg: IDistributedTaskRequest): Promise<IDistributedTaskRequestResult>;
+    abstract updateDistributedTaskRequest(infoBasisArg: IDistributedTaskRequest): Promise<void>;
+}

package/dist_ts/taskbuffer.classes.distributedcoordinator.js

@@ -0,0 +1,5 @@
+import './taskbuffer.classes.task.js';
+import './taskbuffer.plugins.js';
+export class AbstractDistributedCoordinator {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5jbGFzc2VzLmRpc3RyaWJ1dGVkY29vcmRpbmF0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy90YXNrYnVmZmVyLmNsYXNzZXMuZGlzdHJpYnV0ZWRjb29yZGluYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFxQiw4QkFBOEIsQ0FBQztBQUNwRCxPQUF5Qix5QkFBeUIsQ0FBQztBQTZCbkQsTUFBTSxPQUFnQiw4QkFBOEI7Q0FHbkQifQ==

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

@@ -0,0 +1,84 @@
+import * as plugins from './taskbuffer.plugins.js';
+import { BufferRunner } from './taskbuffer.classes.bufferrunner.js';
+import { CycleCounter } from './taskbuffer.classes.cyclecounter.js';
+export interface ITaskFunction {
+    (x?: any): PromiseLike<any>;
+}
+export type TPreOrAfterTaskFunction = () => Task;
+export declare class Task {
+    static extractTask(preOrAfterTaskArg: Task | TPreOrAfterTaskFunction): Task;
+    static emptyTaskFunction: ITaskFunction;
+    static isTask: (taskArg: Task) => boolean;
+    static isTaskTouched: (taskArg: Task | TPreOrAfterTaskFunction, touchedTasksArray: Task[]) => boolean;
+    static runTask: (taskArg: Task | TPreOrAfterTaskFunction, optionsArg: {
+        x?: any;
+        touchedTasksArray?: Task[];
+    }) => Promise<unknown>;
+    name: string;
+    /**
+     * the version of the task
+     * should follow semver
+     * might be important for DistributedCoordinator
+     */
+    version: string;
+    taskFunction: ITaskFunction;
+    buffered: boolean;
+    cronJob: plugins.smarttime.CronJob;
+    bufferMax: number;
+    execDelay: number;
+    timeout: number;
+    preTask: Task | TPreOrAfterTaskFunction;
+    afterTask: Task | TPreOrAfterTaskFunction;
+    running: boolean;
+    bufferRunner: BufferRunner;
+    cycleCounter: CycleCounter;
+    idle: boolean;
+    private _state;
+    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;
+    });
+    /**
+     * trigger the task. Will trigger buffered if this.buffered is true
+     */
+    trigger(x?: any): Promise<any>;
+    /**
+     * trigger task unbuffered.
+     * will actually run the task, not considering any buffered limits.
+     */
+    triggerUnBuffered(x?: any): Promise<any>;
+    /**
+     * trigger task buffered.
+     * note: .trigger() also calls this function
+     */
+    triggerBuffered(x?: any): Promise<any>;
+    get state(): string;
+    set state(stateArg: string);
+}

package/dist_ts/taskbuffer.classes.task.js

@@ -0,0 +1,159 @@
+import * as plugins from './taskbuffer.plugins.js';
+import { BufferRunner } from './taskbuffer.classes.bufferrunner.js';
+import { CycleCounter } from './taskbuffer.classes.cyclecounter.js';
+import { logger } from './taskbuffer.logging.js';
+export class Task {
+    // STATIC
+    static extractTask(preOrAfterTaskArg) {
+        switch (true) {
+            case !preOrAfterTaskArg:
+                return null;
+            case preOrAfterTaskArg instanceof Task:
+                return preOrAfterTaskArg;
+            case typeof preOrAfterTaskArg === 'function':
+                const taskFunction = preOrAfterTaskArg;
+                return taskFunction();
+            default:
+                return null;
+        }
+    }
+    static { this.emptyTaskFunction = function (x) {
+        const done = plugins.smartpromise.defer();
+        done.resolve();
+        return done.promise;
+    }; }
+    static { this.isTask = (taskArg) => {
+        if (taskArg instanceof Task && typeof taskArg.taskFunction === 'function') {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }; }
+    static { this.isTaskTouched = (taskArg, touchedTasksArray) => {
+        const taskToCheck = Task.extractTask(taskArg);
+        let result = false;
+        for (const keyArg in touchedTasksArray) {
+            if (taskToCheck === touchedTasksArray[keyArg]) {
+                result = true;
+            }
+        }
+        return result;
+    }; }
+    static { this.runTask = async (taskArg, optionsArg) => {
+        // extracts the task in case it is specified as a return value of a function
+        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,
+        };
+        const x = options.x;
+        const touchedTasksArray = 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 {
+                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;
+    }; }
+    constructor(optionsArg) {
+        // initialize by default
+        this.running = false;
+        this.bufferRunner = new BufferRunner(this);
+        this.cycleCounter = new CycleCounter(this);
+        this.idle = true;
+        this._state = 'ready';
+        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
+     */
+    trigger(x) {
+        if (this.buffered) {
+            return this.triggerBuffered(x);
+        }
+        else {
+            return this.triggerUnBuffered(x);
+        }
+    }
+    /**
+     * trigger task unbuffered.
+     * will actually run the task, not considering any buffered limits.
+     */
+    triggerUnBuffered(x) {
+        return Task.runTask(this, { x: x });
+    }
+    /**
+     * trigger task buffered.
+     * note: .trigger() also calls this function
+     */
+    triggerBuffered(x) {
+        return this.bufferRunner.trigger(x);
+    }
+    get state() {
+        return this._state;
+    }
+    set state(stateArg) {
+        if (stateArg === 'locked') {
+            this._state = 'locked';
+        }
+        else {
+            logger.log('error', `state type ${stateArg} could not be set`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/dist_ts/taskbuffer.classes.taskchain.js

@@ -0,0 +1,51 @@
+// TaskChain chains tasks
+// and extends Task
+import * as plugins from './taskbuffer.plugins.js';
+import { Task } from './taskbuffer.classes.task.js';
+import { logger } from './taskbuffer.logging.js';
+export class Taskchain extends Task {
+    constructor(optionsArg) {
+        const options = {
+            ...{
+                name: 'unnamed Taskchain',
+                log: false,
+            },
+            ...optionsArg,
+            ...{
+                taskFunction: (x) => {
+                    // this is the function that gets executed when TaskChain is triggered
+                    const done = plugins.smartpromise.defer(); // this is the starting Deferred object
+                    let taskCounter = 0; // counter for iterating async over the taskArray
+                    const 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) => {
+                                logger.log('info', this.taskArray[taskCounter].name);
+                                taskCounter++;
+                                iterateTasks(x);
+                            });
+                        }
+                        else {
+                            console.log('Taskchain "' + this.name + '" completed successfully');
+                            done.resolve(x);
+                        }
+                    };
+                    iterateTasks(x);
+                    return done.promise;
+                },
+            },
+        };
+        super(options);
+        this.taskArray = optionsArg.taskArray;
+    }
+    addTask(taskArg) {
+        this.taskArray.push(taskArg);
+    }
+    removeTask(taskArg) {
+        // TODO:
+    }
+    shiftTask() {
+        // TODO:
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,10 @@
+import { Task, ITaskFunction } from './taskbuffer.classes.task.js';
+export declare class TaskDebounced<T = unknown> extends Task {
+    private _debouncedTaskFunction;
+    private _observableIntake;
+    constructor(optionsArg: {
+        name: string;
+        taskFunction: ITaskFunction;
+        debounceTimeInMillis: number;
+    });
+}

package/dist_ts/taskbuffer.classes.taskdebounced.js

@@ -0,0 +1,20 @@
+import * as plugins from './taskbuffer.plugins.js';
+import { Task } from './taskbuffer.classes.task.js';
+export class TaskDebounced extends Task {
+    constructor(optionsArg) {
+        super({
+            name: optionsArg.name,
+            taskFunction: async (x) => {
+                this._observableIntake.push(x);
+            },
+        });
+        this._observableIntake = new plugins.smartrx.ObservableIntake();
+        this.taskFunction = optionsArg.taskFunction;
+        this._observableIntake.observable
+            .pipe(plugins.smartrx.rxjs.ops.debounceTime(optionsArg.debounceTimeInMillis))
+            .subscribe((x) => {
+            this.taskFunction(x);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5jbGFzc2VzLnRhc2tkZWJvdW5jZWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy90YXNrYnVmZmVyLmNsYXNzZXMudGFza2RlYm91bmNlZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLHlCQUF5QixDQUFDO0FBRW5ELE9BQU8sRUFBRSxJQUFJLEVBQWlCLE1BQU0sOEJBQThCLENBQUM7QUFFbkUsTUFBTSxPQUFPLGFBQTJCLFNBQVEsSUFBSTtJQUlsRCxZQUFZLFVBSVg7UUFDQyxLQUFLLENBQUM7WUFDSixJQUFJLEVBQUUsVUFBVSxDQUFDLElBQUk7WUFDckIsWUFBWSxFQUFFLEtBQUssRUFBRSxDQUFJLEVBQUUsRUFBRTtnQkFDM0IsSUFBSSxDQUFDLGlCQUFpQixDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUNqQyxDQUFDO1NBQ0YsQ0FBQyxDQUFDO1FBWkcsc0JBQWlCLEdBQUcsSUFBSSxPQUFPLENBQUMsT0FBTyxDQUFDLGdCQUFnQixFQUFLLENBQUM7UUFhcEUsSUFBSSxDQUFDLFlBQVksR0FBRyxVQUFVLENBQUMsWUFBWSxDQUFDO1FBQzVDLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxVQUFVO2FBQzlCLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsWUFBWSxDQUFDLFVBQVUsQ0FBQyxvQkFBb0IsQ0FBQyxDQUFDO2FBQzVFLFNBQVMsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFO1lBQ2YsSUFBSSxDQUFDLFlBQVksQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUN2QixDQUFDLENBQUMsQ0FBQztJQUNQLENBQUM7Q0FDRiJ9

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

@@ -0,0 +1,68 @@
+import * as plugins from './taskbuffer.plugins.js';
+import { Task } from './taskbuffer.classes.task.js';
+import { AbstractDistributedCoordinator } from './taskbuffer.classes.distributedcoordinator.js';
+export interface ICronJob {
+    cronString: string;
+    taskNameArg: string;
+    job: any;
+}
+export interface ITaskManagerConstructorOptions {
+    distributedCoordinator?: AbstractDistributedCoordinator;
+}
+export declare class TaskManager {
+    randomId: string;
+    taskMap: plugins.lik.ObjectMap<Task>;
+    private cronJobManager;
+    options: ITaskManagerConstructorOptions;
+    constructor(optionosArg?: ITaskManagerConstructorOptions);
+    /**
+     * checks if a task is already present
+     * @param taskNameArg
+     */
+    getTaskByName(taskNameArg: string): Task;
+    /**
+     * adds a Task to the TaskManager
+     * @param taskArg
+     */
+    addTask(taskArg: Task): void;
+    /**
+     * adds and schedules a task at once
+     * @param taskArg
+     * @param cronStringArg
+     */
+    addAndScheduleTask(taskArg: Task, cronStringArg: string): void;
+    /**
+     * triggers a task in the TaskManagerByName
+     * @param taskNameArg
+     */
+    triggerTaskByName(taskNameArg: string): Promise<any>;
+    triggerTask(task: Task): Promise<any>;
+    /**
+     * schedules the task by name
+     * @param taskNameArg
+     */
+    scheduleTaskByName(taskNameArg: string, cronStringArg: string): void;
+    /**
+     * deschedules a task by name
+     * @param taskNameArg
+     */
+    descheduleTaskByName(taskNameArg: string): void;
+    /**
+     * deschedules a task
+     * @param task
+     */
+    descheduleTask(task: Task): Promise<void>;
+    /**
+     * returns all schedules of a specific task
+     * @param taskNameArg
+     */
+    getSchedulesForTaskName(taskNameArg: string): void;
+    /**
+     * starts the taskmanager
+     */
+    start(): void;
+    /**
+     * stops the taskmanager
+     */
+    stop(): void;
+}