@push.rocks/taskbuffer 3.1.10 → 3.4.0

package/dist_ts_web/ts/index.js

@@ -0,0 +1,12 @@
+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';
+// Task step system
+export { TaskStep } from './taskbuffer.classes.taskstep.js';
+import * as distributedCoordination from './taskbuffer.classes.distributedcoordinator.js';
+export { distributedCoordination };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFFcEQsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBQzlELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxzQ0FBc0MsQ0FBQztBQUNwRSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFDbEUsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBQzVELE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUNoRSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sdUNBQXVDLENBQUM7QUFFdEUsbUJBQW1CO0FBQ25CLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQU01RCxPQUFPLEtBQUssdUJBQXVCLE1BQU0sZ0RBQWdELENBQUM7QUFDMUYsT0FBTyxFQUFFLHVCQUF1QixFQUFFLENBQUMifQ==

package/dist_ts_web/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<any>);
+    trigger(x: any): Promise<any>;
+    private _run;
+}

package/dist_ts_web/ts/taskbuffer.classes.bufferrunner.js

@@ -0,0 +1,28 @@
+import { Task } from './taskbuffer.classes.task.js';
+export class BufferRunner {
+    constructor(taskArg) {
+        // initialize 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);
+        if (!this.task.running) {
+            this._run(x);
+        }
+        return returnPromise;
+    }
+    async _run(x) {
+        this.task.running = true;
+        while (this.bufferCounter > 0) {
+            const result = await Task.runTask(this.task, { x: x });
+            this.bufferCounter--;
+            this.task.cycleCounter.informOfCycle(result);
+        }
+        this.task.running = false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5jbGFzc2VzLmJ1ZmZlcnJ1bm5lci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3Rhc2tidWZmZXIuY2xhc3Nlcy5idWZmZXJydW5uZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBRXBELE1BQU0sT0FBTyxZQUFZO0lBS3ZCLFlBQVksT0FBa0I7UUFIOUIsd0JBQXdCO1FBQ2pCLGtCQUFhLEdBQVcsQ0FBQyxDQUFDO1FBRy9CLElBQUksQ0FBQyxJQUFJLEdBQUcsT0FBTyxDQUFDO0lBQ3RCLENBQUM7SUFFTSxPQUFPLENBQUMsQ0FBTTtRQUNuQixJQUFJLENBQUMsQ0FBQyxJQUFJLENBQUMsYUFBYSxJQUFJLElBQUksQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLEVBQUUsQ0FBQztZQUNqRCxJQUFJLENBQUMsYUFBYSxFQUFFLENBQUM7UUFDdkIsQ0FBQztRQUNELE1BQU0sYUFBYSxHQUNqQixJQUFJLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDLENBQUM7UUFDaEUsSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7WUFDdkIsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUNmLENBQUM7UUFDRCxPQUFPLGFBQWEsQ0FBQztJQUN2QixDQUFDO0lBRU8sS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFNO1FBQ3ZCLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxHQUFHLElBQUksQ0FBQztRQUN6QixPQUFPLElBQUksQ0FBQyxhQUFhLEdBQUcsQ0FBQyxFQUFFLENBQUM7WUFDOUIsTUFBTSxNQUFNLEdBQUcsTUFBTSxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsRUFBRSxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQztZQUN2RCxJQUFJLENBQUMsYUFBYSxFQUFFLENBQUM7WUFDckIsSUFBSSxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsYUFBYSxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQy9DLENBQUM7UUFDRCxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sR0FBRyxLQUFLLENBQUM7SUFDNUIsQ0FBQztDQUNGIn0=

package/dist_ts_web/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<any>);
+    getPromiseForCycle(cycleCountArg: number): Promise<unknown>;
+    informOfCycle(x: any): void;
+}

package/dist_ts_web/ts/taskbuffer.classes.cyclecounter.js

@@ -0,0 +1,31 @@
+import * as plugins from './taskbuffer.plugins.js';
+import { Task } from './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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5jbGFzc2VzLmN5Y2xlY291bnRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3Rhc2tidWZmZXIuY2xhc3Nlcy5jeWNsZWNvdW50ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSx5QkFBeUIsQ0FBQztBQUNuRCxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFPcEQsTUFBTSxPQUFPLFlBQVk7SUFHdkIsWUFBWSxPQUFrQjtRQUR2QixxQkFBZ0IsR0FBbUIsRUFBRSxDQUFDO1FBRTNDLElBQUksQ0FBQyxJQUFJLEdBQUcsT0FBTyxDQUFDO0lBQ3RCLENBQUM7SUFDTSxrQkFBa0IsQ0FBQyxhQUFxQjtRQUM3QyxNQUFNLElBQUksR0FBRyxPQUFPLENBQUMsWUFBWSxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQzFDLE1BQU0sV0FBVyxHQUFpQjtZQUNoQyxZQUFZLEVBQUUsYUFBYTtZQUMzQixRQUFRLEVBQUUsSUFBSTtTQUNmLENBQUM7UUFDRixJQUFJLENBQUMsZ0JBQWdCLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBQ3hDLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQztJQUN0QixDQUFDO0lBQ00sYUFBYSxDQUFDLENBQU07UUFDekIsTUFBTSxtQkFBbUIsR0FBbUIsRUFBRSxDQUFDO1FBQy9DLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxPQUFPLENBQUMsQ0FBQyxjQUFjLEVBQUUsRUFBRTtZQUMvQyxjQUFjLENBQUMsWUFBWSxFQUFFLENBQUM7WUFDOUIsSUFBSSxjQUFjLENBQUMsWUFBWSxJQUFJLENBQUMsRUFBRSxDQUFDO2dCQUNyQyxjQUFjLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUNyQyxDQUFDO2lCQUFNLENBQUM7Z0JBQ04sbUJBQW1CLENBQUMsSUFBSSxDQUFDLGNBQWMsQ0FBQyxDQUFDO1lBQzNDLENBQUM7UUFDSCxDQUFDLENBQUMsQ0FBQztRQUNILElBQUksQ0FBQyxnQkFBZ0IsR0FBRyxtQkFBbUIsQ0FBQztJQUM5QyxDQUFDO0NBQ0YifQ==

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

@@ -0,0 +1,27 @@
+/**
+ * Contains all data for the final coordinator to make an informed decision.
+ */
+export interface IDistributedTaskRequest {
+    submitterId: string;
+    requestResponseId: string;
+    taskName: string;
+    taskVersion: string;
+    taskExecutionTime: number;
+    taskExecutionTimeout: number;
+    taskExecutionParallel: number;
+    status: 'requesting' | 'gotRejected' | 'failed' | 'succeeded';
+}
+export interface IDistributedTaskRequestResult {
+    submitterId: string;
+    requestResponseId: string;
+    considered: boolean;
+    rank: number;
+    reason: string;
+    shouldTrigger: boolean;
+}
+export declare abstract class AbstractDistributedCoordinator {
+    abstract fireDistributedTaskRequest(infoBasis: IDistributedTaskRequest): Promise<IDistributedTaskRequestResult>;
+    abstract updateDistributedTaskRequest(infoBasis: IDistributedTaskRequest): Promise<void>;
+    abstract start(): Promise<void>;
+    abstract stop(): Promise<void>;
+}

package/dist_ts_web/ts/taskbuffer.classes.distributedcoordinator.js

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

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

@@ -0,0 +1,86 @@
+import * as plugins from './taskbuffer.plugins.js';
+import { BufferRunner } from './taskbuffer.classes.bufferrunner.js';
+import { CycleCounter } from './taskbuffer.classes.cyclecounter.js';
+import { type ITaskStep } from './taskbuffer.classes.taskstep.js';
+import type { ITaskMetadata } from './taskbuffer.interfaces.js';
+export interface ITaskFunction<T = undefined> {
+    (x?: any, setupValue?: T): PromiseLike<any>;
+}
+export interface ITaskSetupFunction<T = undefined> {
+    (): Promise<T>;
+}
+export type TPreOrAfterTaskFunction = () => Task<any>;
+export type StepNames<T> = T extends ReadonlyArray<{
+    name: infer N;
+}> ? N : never;
+export declare class Task<T = undefined, TSteps extends ReadonlyArray<{
+    name: string;
+    description: string;
+    percentage: number;
+}> = []> {
+    static extractTask<T = undefined, TSteps extends ReadonlyArray<{
+        name: string;
+        description: string;
+        percentage: number;
+    }> = []>(preOrAfterTaskArg: Task<T, TSteps> | TPreOrAfterTaskFunction): Task<T, TSteps>;
+    static emptyTaskFunction: ITaskFunction;
+    static isTask: (taskArg: Task<any>) => boolean;
+    static isTaskTouched<T = undefined, TSteps extends ReadonlyArray<{
+        name: string;
+        description: string;
+        percentage: number;
+    }> = []>(taskArg: Task<T, TSteps> | TPreOrAfterTaskFunction, touchedTasksArray: Task<T, TSteps>[]): boolean;
+    static runTask: <T_1, TSteps_1 extends ReadonlyArray<{
+        name: string;
+        description: string;
+        percentage: number;
+    }> = []>(taskArg: Task<T_1, TSteps_1> | TPreOrAfterTaskFunction, optionsArg: {
+        x?: any;
+        touchedTasksArray?: Task<T_1, TSteps_1>[];
+    }) => Promise<unknown>;
+    name: string;
+    version: string;
+    taskFunction: ITaskFunction<T>;
+    buffered: boolean;
+    cronJob: plugins.smarttime.CronJob;
+    bufferMax: number;
+    execDelay: number;
+    timeout: number;
+    preTask: Task<T, any> | TPreOrAfterTaskFunction;
+    afterTask: Task<T, any> | TPreOrAfterTaskFunction;
+    blockingTasks: Task[];
+    private finished;
+    private resolveFinished;
+    running: boolean;
+    bufferRunner: BufferRunner;
+    cycleCounter: CycleCounter;
+    lastRun?: Date;
+    runCount: number;
+    get idle(): boolean;
+    taskSetup: ITaskSetupFunction<T>;
+    setupValue: T;
+    private steps;
+    private stepProgress;
+    currentStepName?: string;
+    private providedSteps?;
+    constructor(optionsArg: {
+        taskFunction: ITaskFunction<T>;
+        preTask?: Task<T, any> | TPreOrAfterTaskFunction;
+        afterTask?: Task<T, any> | TPreOrAfterTaskFunction;
+        buffered?: boolean;
+        bufferMax?: number;
+        execDelay?: number;
+        name?: string;
+        taskSetup?: ITaskSetupFunction<T>;
+        steps?: TSteps;
+    });
+    trigger(x?: any): Promise<any>;
+    triggerUnBuffered(x?: any): Promise<any>;
+    triggerBuffered(x?: any): Promise<any>;
+    notifyStep(stepName: StepNames<TSteps>): void;
+    getProgress(): number;
+    getStepsMetadata(): ITaskStep[];
+    getMetadata(): ITaskMetadata;
+    resetSteps(): void;
+    private completeAllSteps;
+}

package/dist_ts_web/ts/taskbuffer.classes.task.js

@@ -0,0 +1,257 @@
+import * as plugins from './taskbuffer.plugins.js';
+import { BufferRunner } from './taskbuffer.classes.bufferrunner.js';
+import { CycleCounter } from './taskbuffer.classes.cyclecounter.js';
+import { TaskStep } from './taskbuffer.classes.taskstep.js';
+import { logger } from './taskbuffer.logging.js';
+export class Task {
+    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 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) => {
+        const taskToRun = Task.extractTask(taskArg);
+        const done = plugins.smartpromise.defer();
+        // Wait for all blocking tasks to finish
+        for (const task of taskToRun.blockingTasks) {
+            await task.finished;
+        }
+        if (!taskToRun.setupValue && taskToRun.taskSetup) {
+            taskToRun.setupValue = await taskToRun.taskSetup();
+        }
+        if (taskToRun.execDelay) {
+            await plugins.smartdelay.delayFor(taskToRun.execDelay);
+        }
+        taskToRun.running = true;
+        taskToRun.runCount++;
+        taskToRun.lastRun = new Date();
+        // Reset steps at the beginning of task execution
+        taskToRun.resetSteps();
+        done.promise.then(async () => {
+            taskToRun.running = false;
+            // Complete all steps when task finishes
+            taskToRun.completeAllSteps();
+            // When the task has finished running, resolve the finished promise
+            taskToRun.resolveFinished();
+            // Create a new finished promise for the next run
+            taskToRun.finished = new Promise((resolve) => {
+                taskToRun.resolveFinished = resolve;
+            });
+        });
+        const options = {
+            ...{ x: undefined, touchedTasksArray: [] },
+            ...optionsArg,
+        };
+        const x = options.x;
+        const touchedTasksArray = options.touchedTasksArray;
+        touchedTasksArray.push(taskToRun);
+        const localDeferred = plugins.smartpromise.defer();
+        localDeferred.promise
+            .then(() => {
+            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) => {
+            try {
+                return await taskToRun.taskFunction(x, taskToRun.setupValue);
+            }
+            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;
+    }; }
+    get idle() {
+        return !this.running;
+    }
+    constructor(optionsArg) {
+        // Add a list to store the blocking tasks
+        this.blockingTasks = [];
+        this.running = false;
+        this.bufferRunner = new BufferRunner(this);
+        this.cycleCounter = new CycleCounter(this);
+        this.runCount = 0;
+        // Step tracking properties
+        this.steps = new Map();
+        this.stepProgress = new Map();
+        this.taskFunction = optionsArg.taskFunction;
+        this.preTask = optionsArg.preTask;
+        this.afterTask = optionsArg.afterTask;
+        this.buffered = optionsArg.buffered;
+        this.bufferMax = optionsArg.bufferMax;
+        this.execDelay = optionsArg.execDelay;
+        this.name = optionsArg.name;
+        this.taskSetup = optionsArg.taskSetup;
+        // Initialize steps if provided
+        if (optionsArg.steps) {
+            this.providedSteps = optionsArg.steps;
+            for (const stepConfig of optionsArg.steps) {
+                const step = new TaskStep({
+                    name: stepConfig.name,
+                    description: stepConfig.description,
+                    percentage: stepConfig.percentage,
+                });
+                this.steps.set(stepConfig.name, step);
+            }
+        }
+        // Create the finished promise
+        this.finished = new Promise((resolve) => {
+            this.resolveFinished = resolve;
+        });
+    }
+    trigger(x) {
+        if (this.buffered) {
+            return this.triggerBuffered(x);
+        }
+        else {
+            return this.triggerUnBuffered(x);
+        }
+    }
+    triggerUnBuffered(x) {
+        return Task.runTask(this, { x: x });
+    }
+    triggerBuffered(x) {
+        return this.bufferRunner.trigger(x);
+    }
+    // Step notification method with typed step names
+    notifyStep(stepName) {
+        // Complete previous step if exists
+        if (this.currentStepName) {
+            const prevStep = this.steps.get(this.currentStepName);
+            if (prevStep && prevStep.status === 'active') {
+                prevStep.complete();
+                this.stepProgress.set(this.currentStepName, prevStep.percentage);
+            }
+        }
+        // Start new step
+        const step = this.steps.get(stepName);
+        if (step) {
+            step.start();
+            this.currentStepName = stepName;
+            // Emit event for frontend updates (could be enhanced with event emitter)
+            if (this.name) {
+                logger.log('info', `Task ${this.name}: Starting step "${stepName}" - ${step.description}`);
+            }
+        }
+    }
+    // Get current progress based on completed steps
+    getProgress() {
+        let totalProgress = 0;
+        for (const [stepName, percentage] of this.stepProgress) {
+            totalProgress += percentage;
+        }
+        // Add partial progress of current step if exists
+        if (this.currentStepName) {
+            const currentStep = this.steps.get(this.currentStepName);
+            if (currentStep && currentStep.status === 'active') {
+                // Could add partial progress calculation here if needed
+                // For now, we'll consider active steps as 50% complete
+                totalProgress += currentStep.percentage * 0.5;
+            }
+        }
+        return Math.min(100, Math.round(totalProgress));
+    }
+    // Get all steps metadata
+    getStepsMetadata() {
+        return Array.from(this.steps.values()).map(step => step.toJSON());
+    }
+    // Get task metadata
+    getMetadata() {
+        return {
+            name: this.name || 'unnamed',
+            version: this.version,
+            status: this.running ? 'running' : 'idle',
+            steps: this.getStepsMetadata(),
+            currentStep: this.currentStepName,
+            currentProgress: this.getProgress(),
+            runCount: this.runCount,
+            buffered: this.buffered,
+            bufferMax: this.bufferMax,
+            timeout: this.timeout,
+            cronSchedule: this.cronJob?.cronExpression,
+        };
+    }
+    // Reset all steps to pending state
+    resetSteps() {
+        this.steps.forEach(step => step.reset());
+        this.stepProgress.clear();
+        this.currentStepName = undefined;
+    }
+    // Complete all remaining steps (useful for cleanup)
+    completeAllSteps() {
+        if (this.currentStepName) {
+            const currentStep = this.steps.get(this.currentStepName);
+            if (currentStep && currentStep.status === 'active') {
+                currentStep.complete();
+                this.stepProgress.set(this.currentStepName, currentStep.percentage);
+            }
+        }
+        // Mark any pending steps as completed (in case of early task completion)
+        this.steps.forEach((step, name) => {
+            if (step.status === 'pending') {
+                // Don't add their percentage to progress since they weren't actually executed
+                step.status = 'completed';
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"taskbuffer.classes.task.js","sourceRoot":"","sources":["../../ts/taskbuffer.classes.task.ts"],"names":[],"mappings":"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"}

package/dist_ts_web/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_web/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_web/ts/taskbuffer.classes.taskdebounced.d.ts

@@ -0,0 +1,10 @@
+import { Task, type 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_web/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5jbGFzc2VzLnRhc2tkZWJvdW5jZWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy90YXNrYnVmZmVyLmNsYXNzZXMudGFza2RlYm91bmNlZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLHlCQUF5QixDQUFDO0FBRW5ELE9BQU8sRUFBRSxJQUFJLEVBQXNCLE1BQU0sOEJBQThCLENBQUM7QUFFeEUsTUFBTSxPQUFPLGFBQTJCLFNBQVEsSUFBSTtJQUlsRCxZQUFZLFVBSVg7UUFDQyxLQUFLLENBQUM7WUFDSixJQUFJLEVBQUUsVUFBVSxDQUFDLElBQUk7WUFDckIsWUFBWSxFQUFFLEtBQUssRUFBRSxDQUFJLEVBQUUsRUFBRTtnQkFDM0IsSUFBSSxDQUFDLGlCQUFpQixDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUNqQyxDQUFDO1NBQ0YsQ0FBQyxDQUFDO1FBWkcsc0JBQWlCLEdBQUcsSUFBSSxPQUFPLENBQUMsT0FBTyxDQUFDLGdCQUFnQixFQUFLLENBQUM7UUFhcEUsSUFBSSxDQUFDLFlBQVksR0FBRyxVQUFVLENBQUMsWUFBWSxDQUFDO1FBQzVDLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxVQUFVO2FBQzlCLElBQUksQ0FDSCxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsWUFBWSxDQUFDLFVBQVUsQ0FBQyxvQkFBb0IsQ0FBQyxDQUN2RTthQUNBLFNBQVMsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFO1lBQ2YsSUFBSSxDQUFDLFlBQVksQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUN2QixDQUFDLENBQUMsQ0FBQztJQUNQLENBQUM7Q0FDRiJ9

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

@@ -0,0 +1,49 @@
+import * as plugins from './taskbuffer.plugins.js';
+import { Task } from './taskbuffer.classes.task.js';
+import { AbstractDistributedCoordinator } from './taskbuffer.classes.distributedcoordinator.js';
+import type { ITaskMetadata, ITaskExecutionReport, IScheduledTaskInfo } from './taskbuffer.interfaces.js';
+export interface ICronJob {
+    cronString: string;
+    taskName: string;
+    job: any;
+}
+export interface ITaskManagerConstructorOptions {
+    distributedCoordinator?: AbstractDistributedCoordinator;
+}
+export declare class TaskManager {
+    randomId: string;
+    taskMap: plugins.lik.ObjectMap<Task<any, any>>;
+    private cronJobManager;
+    options: ITaskManagerConstructorOptions;
+    constructor(options?: ITaskManagerConstructorOptions);
+    getTaskByName(taskName: string): Task<any, any>;
+    addTask(task: Task<any, any>): void;
+    addAndScheduleTask(task: Task<any, any>, cronString: string): void;
+    triggerTaskByName(taskName: string): Promise<any>;
+    triggerTask(task: Task<any, any>): Promise<any>;
+    scheduleTaskByName(taskName: string, cronString: string): void;
+    private handleTaskScheduling;
+    private logTaskState;
+    private performDistributedConsultation;
+    descheduleTaskByName(taskName: string): void;
+    descheduleTask(task: Task<any, any>): Promise<void>;
+    getScheduleForTaskName(taskName: string): string | null;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getTaskMetadata(taskName: string): ITaskMetadata | null;
+    getAllTasksMetadata(): ITaskMetadata[];
+    getScheduledTasks(): IScheduledTaskInfo[];
+    getNextScheduledRuns(limit?: number): Array<{
+        taskName: string;
+        nextRun: Date;
+        schedule: string;
+    }>;
+    addExecuteRemoveTask<T, TSteps extends ReadonlyArray<{
+        name: string;
+        description: string;
+        percentage: number;
+    }>>(task: Task<T, TSteps>, options?: {
+        schedule?: string;
+        trackProgress?: boolean;
+    }): Promise<ITaskExecutionReport>;
+}