@push.rocks/taskbuffer 3.2.0 → 3.5.0

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>;
+}

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

@@ -0,0 +1,208 @@
+import * as plugins from './taskbuffer.plugins.js';
+import { Task } from './taskbuffer.classes.task.js';
+import { AbstractDistributedCoordinator, } from './taskbuffer.classes.distributedcoordinator.js';
+export class TaskManager {
+    constructor(options = {}) {
+        this.randomId = plugins.smartunique.shortId();
+        this.taskMap = new plugins.lik.ObjectMap();
+        this.cronJobManager = new plugins.smarttime.CronManager();
+        this.options = {
+            distributedCoordinator: null,
+        };
+        this.options = Object.assign(this.options, options);
+    }
+    getTaskByName(taskName) {
+        return this.taskMap.findSync((task) => task.name === taskName);
+    }
+    addTask(task) {
+        if (!task.name) {
+            throw new Error('Task must have a name to be added to taskManager');
+        }
+        this.taskMap.add(task);
+    }
+    addAndScheduleTask(task, cronString) {
+        this.addTask(task);
+        this.scheduleTaskByName(task.name, cronString);
+    }
+    async triggerTaskByName(taskName) {
+        const taskToTrigger = this.getTaskByName(taskName);
+        if (!taskToTrigger) {
+            throw new Error(`No task with the name ${taskName} found.`);
+        }
+        return taskToTrigger.trigger();
+    }
+    async triggerTask(task) {
+        return task.trigger();
+    }
+    scheduleTaskByName(taskName, cronString) {
+        const taskToSchedule = this.getTaskByName(taskName);
+        if (!taskToSchedule) {
+            throw new Error(`No task with the name ${taskName} found.`);
+        }
+        this.handleTaskScheduling(taskToSchedule, cronString);
+    }
+    handleTaskScheduling(task, cronString) {
+        const cronJob = this.cronJobManager.addCronjob(cronString, async (triggerTime) => {
+            this.logTaskState(task);
+            if (this.options.distributedCoordinator) {
+                const announcementResult = await this.performDistributedConsultation(task, triggerTime);
+                if (!announcementResult.shouldTrigger) {
+                    console.log('Distributed coordinator result: NOT EXECUTING');
+                    return;
+                }
+                else {
+                    console.log('Distributed coordinator result: CHOSEN AND EXECUTING');
+                }
+            }
+            await task.trigger();
+        });
+        task.cronJob = cronJob;
+    }
+    logTaskState(task) {
+        console.log(`Taskbuffer schedule triggered task >>${task.name}<<`);
+        const bufferState = task.buffered
+            ? `buffered with max ${task.bufferMax} buffered calls`
+            : `unbuffered`;
+        console.log(`Task >>${task.name}<< is ${bufferState}`);
+    }
+    async performDistributedConsultation(task, triggerTime) {
+        console.log('Found a distributed coordinator, performing consultation.');
+        return this.options.distributedCoordinator.fireDistributedTaskRequest({
+            submitterId: this.randomId,
+            requestResponseId: plugins.smartunique.shortId(),
+            status: 'requesting',
+            taskExecutionParallel: 1,
+            taskExecutionTime: triggerTime,
+            taskExecutionTimeout: task.timeout,
+            taskName: task.name,
+            taskVersion: task.version,
+        });
+    }
+    descheduleTaskByName(taskName) {
+        const task = this.getTaskByName(taskName);
+        if (task && task.cronJob) {
+            this.cronJobManager.removeCronjob(task.cronJob);
+            task.cronJob = null;
+        }
+        if (this.cronJobManager.cronjobs.isEmpty) {
+            this.cronJobManager.stop();
+        }
+    }
+    async descheduleTask(task) {
+        await this.descheduleTaskByName(task.name);
+    }
+    getScheduleForTaskName(taskName) {
+        const task = this.getTaskByName(taskName);
+        return task && task.cronJob ? task.cronJob.cronExpression : null;
+    }
+    async start() {
+        if (this.options.distributedCoordinator) {
+            await this.options.distributedCoordinator.start();
+        }
+        this.cronJobManager.start();
+    }
+    async stop() {
+        this.cronJobManager.stop();
+        if (this.options.distributedCoordinator) {
+            await this.options.distributedCoordinator.stop();
+        }
+    }
+    // Get metadata for a specific task
+    getTaskMetadata(taskName) {
+        const task = this.getTaskByName(taskName);
+        if (!task)
+            return null;
+        return task.getMetadata();
+    }
+    // Get metadata for all tasks
+    getAllTasksMetadata() {
+        return this.taskMap.getArray().map(task => task.getMetadata());
+    }
+    // Get scheduled tasks with their schedules and next run times
+    getScheduledTasks() {
+        const scheduledTasks = [];
+        for (const task of this.taskMap.getArray()) {
+            if (task.cronJob) {
+                scheduledTasks.push({
+                    name: task.name || 'unnamed',
+                    schedule: task.cronJob.cronExpression,
+                    nextRun: new Date(task.cronJob.getNextExecutionTime()),
+                    lastRun: task.lastRun,
+                    steps: task.getStepsMetadata?.(),
+                    metadata: task.getMetadata(),
+                });
+            }
+        }
+        return scheduledTasks;
+    }
+    // Get next scheduled runs across all tasks
+    getNextScheduledRuns(limit = 10) {
+        const scheduledRuns = this.getScheduledTasks()
+            .map(task => ({
+            taskName: task.name,
+            nextRun: task.nextRun,
+            schedule: task.schedule,
+        }))
+            .sort((a, b) => a.nextRun.getTime() - b.nextRun.getTime())
+            .slice(0, limit);
+        return scheduledRuns;
+    }
+    // Add, execute, and remove a task while collecting metadata
+    async addExecuteRemoveTask(task, options) {
+        // Add task to manager
+        this.addTask(task);
+        // Optionally schedule it
+        if (options?.schedule) {
+            this.scheduleTaskByName(task.name, options.schedule);
+        }
+        const startTime = Date.now();
+        const progressUpdates = [];
+        try {
+            // Execute the task
+            const result = await task.trigger();
+            // Collect execution report
+            const report = {
+                taskName: task.name || 'unnamed',
+                startTime,
+                endTime: Date.now(),
+                duration: Date.now() - startTime,
+                steps: task.getStepsMetadata(),
+                stepsCompleted: task.getStepsMetadata()
+                    .filter(step => step.status === 'completed')
+                    .map(step => step.name),
+                progress: task.getProgress(),
+                result,
+            };
+            // Remove task from manager
+            this.taskMap.remove(task);
+            // Deschedule if it was scheduled
+            if (options?.schedule && task.name) {
+                this.descheduleTaskByName(task.name);
+            }
+            return report;
+        }
+        catch (error) {
+            // Create error report
+            const errorReport = {
+                taskName: task.name || 'unnamed',
+                startTime,
+                endTime: Date.now(),
+                duration: Date.now() - startTime,
+                steps: task.getStepsMetadata(),
+                stepsCompleted: task.getStepsMetadata()
+                    .filter(step => step.status === 'completed')
+                    .map(step => step.name),
+                progress: task.getProgress(),
+                error: error,
+            };
+            // Remove task from manager even on error
+            this.taskMap.remove(task);
+            // Deschedule if it was scheduled
+            if (options?.schedule && task.name) {
+                this.descheduleTaskByName(task.name);
+            }
+            throw errorReport;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"taskbuffer.classes.taskmanager.js","sourceRoot":"","sources":["../../ts/taskbuffer.classes.taskmanager.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,11 @@
+import { Task, type 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_web/ts/taskbuffer.classes.taskonce.js

@@ -0,0 +1,20 @@
+import * as plugins from './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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5jbGFzc2VzLnRhc2tvbmNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvdGFza2J1ZmZlci5jbGFzc2VzLnRhc2tvbmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0seUJBQXlCLENBQUM7QUFFbkQsT0FBTyxFQUFFLElBQUksRUFBc0IsTUFBTSw4QkFBOEIsQ0FBQztBQUV4RTs7R0FFRztBQUNILE1BQU0sT0FBTyxRQUFTLFNBQVEsSUFBSTtJQUVoQyxZQUFZLFVBQTBEO1FBQ3BFLEtBQUssQ0FBQztZQUNKLElBQUksRUFBRSxVQUFVLENBQUMsSUFBSTtZQUNyQixZQUFZLEVBQUUsS0FBSyxJQUFJLEVBQUU7Z0JBQ3ZCLElBQUksQ0FBQyxJQUFJLENBQUMsWUFBWSxFQUFFLENBQUM7b0JBQ3ZCLElBQUksQ0FBQyxZQUFZLEdBQUcsSUFBSSxDQUFDO29CQUN6QixNQUFNLFVBQVUsQ0FBQyxZQUFZLEVBQUUsQ0FBQztnQkFDbEMsQ0FBQztZQUNILENBQUM7U0FDRixDQUFDLENBQUM7UUFWTCxpQkFBWSxHQUFZLEtBQUssQ0FBQztJQVc5QixDQUFDO0NBQ0YifQ==

package/dist_ts_web/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_web/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5jbGFzc2VzLnRhc2twYXJhbGxlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3Rhc2tidWZmZXIuY2xhc3Nlcy50YXNrcGFyYWxsZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSx5QkFBeUIsQ0FBQztBQUNuRCxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFFcEQsTUFBTSxPQUFPLFlBQWEsU0FBUSxJQUFJO0lBRXBDLFlBQVksVUFBaUM7UUFDM0MsTUFBTSxPQUFPLEdBQUc7WUFDZCxHQUFHLFVBQVU7WUFDYixHQUFHO2dCQUNELFlBQVksRUFBRSxHQUFHLEVBQUU7b0JBQ2pCLE1BQU0sSUFBSSxHQUFHLE9BQU8sQ0FBQyxZQUFZLENBQUMsS0FBSyxFQUFFLENBQUM7b0JBQzFDLE1BQU0sWUFBWSxHQUFtQixFQUFFLENBQUMsQ0FBQywyREFBMkQ7b0JBQ3BHLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLFVBQVUsT0FBTzt3QkFDdEMsWUFBWSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FBQztvQkFDdkMsQ0FBQyxDQUFDLENBQUM7b0JBQ0gsT0FBTyxDQUFDLEdBQUcsQ0FBQyxZQUFZLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDO29CQUM3QyxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUM7Z0JBQ3RCLENBQUM7YUFDRjtTQUNGLENBQUM7UUFDRixLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDZixJQUFJLENBQUMsU0FBUyxHQUFHLFVBQVUsQ0FBQyxTQUFTLENBQUM7SUFDeEMsQ0FBQztDQUNGIn0=

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

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

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

@@ -0,0 +1,27 @@
+export interface ITaskStep {
+    name: string;
+    description: string;
+    percentage: number;
+    status: 'pending' | 'active' | 'completed';
+    startTime?: number;
+    endTime?: number;
+    duration?: number;
+}
+export declare class TaskStep implements ITaskStep {
+    name: string;
+    description: string;
+    percentage: number;
+    status: 'pending' | 'active' | 'completed';
+    startTime?: number;
+    endTime?: number;
+    duration?: number;
+    constructor(config: {
+        name: string;
+        description: string;
+        percentage: number;
+    });
+    start(): void;
+    complete(): void;
+    reset(): void;
+    toJSON(): ITaskStep;
+}

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

@@ -0,0 +1,37 @@
+export class TaskStep {
+    constructor(config) {
+        this.status = 'pending';
+        this.name = config.name;
+        this.description = config.description;
+        this.percentage = config.percentage;
+    }
+    start() {
+        this.status = 'active';
+        this.startTime = Date.now();
+    }
+    complete() {
+        if (this.startTime) {
+            this.endTime = Date.now();
+            this.duration = this.endTime - this.startTime;
+        }
+        this.status = 'completed';
+    }
+    reset() {
+        this.status = 'pending';
+        this.startTime = undefined;
+        this.endTime = undefined;
+        this.duration = undefined;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            description: this.description,
+            percentage: this.percentage,
+            status: this.status,
+            startTime: this.startTime,
+            endTime: this.endTime,
+            duration: this.duration,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5jbGFzc2VzLnRhc2tzdGVwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvdGFza2J1ZmZlci5jbGFzc2VzLnRhc2tzdGVwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVVBLE1BQU0sT0FBTyxRQUFRO0lBU25CLFlBQVksTUFBaUU7UUFMdEUsV0FBTSxHQUF1QyxTQUFTLENBQUM7UUFNNUQsSUFBSSxDQUFDLElBQUksR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDO1FBQ3hCLElBQUksQ0FBQyxXQUFXLEdBQUcsTUFBTSxDQUFDLFdBQVcsQ0FBQztRQUN0QyxJQUFJLENBQUMsVUFBVSxHQUFHLE1BQU0sQ0FBQyxVQUFVLENBQUM7SUFDdEMsQ0FBQztJQUVNLEtBQUs7UUFDVixJQUFJLENBQUMsTUFBTSxHQUFHLFFBQVEsQ0FBQztRQUN2QixJQUFJLENBQUMsU0FBUyxHQUFHLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQztJQUM5QixDQUFDO0lBRU0sUUFBUTtRQUNiLElBQUksSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDO1lBQ25CLElBQUksQ0FBQyxPQUFPLEdBQUcsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDO1lBQzFCLElBQUksQ0FBQyxRQUFRLEdBQUcsSUFBSSxDQUFDLE9BQU8sR0FBRyxJQUFJLENBQUMsU0FBUyxDQUFDO1FBQ2hELENBQUM7UUFDRCxJQUFJLENBQUMsTUFBTSxHQUFHLFdBQVcsQ0FBQztJQUM1QixDQUFDO0lBRU0sS0FBSztRQUNWLElBQUksQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDO1FBQ3hCLElBQUksQ0FBQyxTQUFTLEdBQUcsU0FBUyxDQUFDO1FBQzNCLElBQUksQ0FBQyxPQUFPLEdBQUcsU0FBUyxDQUFDO1FBQ3pCLElBQUksQ0FBQyxRQUFRLEdBQUcsU0FBUyxDQUFDO0lBQzVCLENBQUM7SUFFTSxNQUFNO1FBQ1gsT0FBTztZQUNMLElBQUksRUFBRSxJQUFJLENBQUMsSUFBSTtZQUNmLFdBQVcsRUFBRSxJQUFJLENBQUMsV0FBVztZQUM3QixVQUFVLEVBQUUsSUFBSSxDQUFDLFVBQVU7WUFDM0IsTUFBTSxFQUFFLElBQUksQ0FBQyxNQUFNO1lBQ25CLFNBQVMsRUFBRSxJQUFJLENBQUMsU0FBUztZQUN6QixPQUFPLEVBQUUsSUFBSSxDQUFDLE9BQU87WUFDckIsUUFBUSxFQUFFLElBQUksQ0FBQyxRQUFRO1NBQ3hCLENBQUM7SUFDSixDQUFDO0NBQ0YifQ==

package/dist_ts_web/ts/taskbuffer.interfaces.d.ts

@@ -0,0 +1,36 @@
+import type { ITaskStep } from './taskbuffer.classes.taskstep.js';
+export interface ITaskMetadata {
+    name: string;
+    version?: string;
+    status: 'idle' | 'running' | 'completed' | 'failed';
+    steps: ITaskStep[];
+    currentStep?: string;
+    currentProgress: number;
+    lastRun?: Date;
+    nextRun?: Date;
+    runCount: number;
+    averageDuration?: number;
+    cronSchedule?: string;
+    buffered?: boolean;
+    bufferMax?: number;
+    timeout?: number;
+}
+export interface ITaskExecutionReport {
+    taskName: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    steps: ITaskStep[];
+    stepsCompleted: string[];
+    progress: number;
+    result?: any;
+    error?: Error;
+}
+export interface IScheduledTaskInfo {
+    name: string;
+    schedule: string;
+    nextRun: Date;
+    lastRun?: Date;
+    steps?: ITaskStep[];
+    metadata?: ITaskMetadata;
+}

package/dist_ts_web/ts/taskbuffer.interfaces.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5pbnRlcmZhY2VzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvdGFza2J1ZmZlci5pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist_ts_web/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_web/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5sb2dnaW5nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvdGFza2J1ZmZlci5sb2dnaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0seUJBQXlCLENBQUM7QUFFbkQsTUFBTSxDQUFDLE1BQU0sTUFBTSxHQUFHLElBQUksT0FBTyxDQUFDLFFBQVEsQ0FBQyxVQUFVLEVBQUUsQ0FBQyJ9

package/dist_ts_web/ts/taskbuffer.plugins.d.ts

@@ -0,0 +1,8 @@
+import * as lik from '@push.rocks/lik';
+import * as smartlog from '@push.rocks/smartlog';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartrx from '@push.rocks/smartrx';
+import * as smarttime from '@push.rocks/smarttime';
+import * as smartunique from '@push.rocks/smartunique';
+export { lik, smartlog, smartpromise, smartdelay, smartrx, smarttime, smartunique, };

package/dist_ts_web/ts/taskbuffer.plugins.js

@@ -0,0 +1,9 @@
+import * as lik from '@push.rocks/lik';
+import * as smartlog from '@push.rocks/smartlog';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartrx from '@push.rocks/smartrx';
+import * as smarttime from '@push.rocks/smarttime';
+import * as smartunique from '@push.rocks/smartunique';
+export { lik, smartlog, smartpromise, smartdelay, smartrx, smarttime, smartunique, };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5wbHVnaW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvdGFza2J1ZmZlci5wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxHQUFHLE1BQU0saUJBQWlCLENBQUM7QUFDdkMsT0FBTyxLQUFLLFFBQVEsTUFBTSxzQkFBc0IsQ0FBQztBQUNqRCxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxVQUFVLE1BQU0sd0JBQXdCLENBQUM7QUFDckQsT0FBTyxLQUFLLE9BQU8sTUFBTSxxQkFBcUIsQ0FBQztBQUMvQyxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFFdkQsT0FBTyxFQUNMLEdBQUcsRUFDSCxRQUFRLEVBQ1IsWUFBWSxFQUNaLFVBQVUsRUFDVixPQUFPLEVBQ1AsU0FBUyxFQUNULFdBQVcsR0FDWixDQUFDIn0=

package/dist_ts_web/ts_web/00_commitinfo_data.d.ts

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

package/dist_ts_web/ts_web/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@push.rocks/taskbuffer',
+    version: '3.5.0',
+    description: 'A flexible task management library supporting TypeScript, allowing for task buffering, scheduling, and execution with dependency management.'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHNfd2ViLzAwX2NvbW1pdGluZm9fZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRztJQUN4QixJQUFJLEVBQUUsd0JBQXdCO0lBQzlCLE9BQU8sRUFBRSxPQUFPO0lBQ2hCLFdBQVcsRUFBRSw4SUFBOEk7Q0FDNUosQ0FBQSJ9

package/dist_ts_web/ts_web/demorunner.d.ts

@@ -0,0 +1 @@
+export {};

package/dist_ts_web/ts_web/demorunner.js

@@ -0,0 +1,33 @@
+import { html, render } from '@design.estate/dees-element';
+import { taskbufferDashboardDemo } from './index.js';
+// Main demo runner
+class DemoRunner {
+    constructor() {
+        this.init();
+    }
+    async init() {
+        // Wait for DOM to be ready
+        await this.domReady();
+        // Render the demo
+        this.renderDemo();
+    }
+    domReady() {
+        return new Promise((resolve) => {
+            if (document.readyState === 'complete' || document.readyState === 'interactive') {
+                resolve();
+            }
+            else {
+                document.addEventListener('DOMContentLoaded', () => resolve());
+            }
+        });
+    }
+    renderDemo() {
+        // Get the demo function result
+        const demoTemplate = taskbufferDashboardDemo();
+        // Render to body
+        render(demoTemplate, document.body);
+    }
+}
+// Start the demo runner
+new DemoRunner();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVtb3J1bm5lci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzX3dlYi9kZW1vcnVubmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDM0QsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sWUFBWSxDQUFDO0FBRXJELG1CQUFtQjtBQUNuQixNQUFNLFVBQVU7SUFDZDtRQUNFLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUNkLENBQUM7SUFFRCxLQUFLLENBQUMsSUFBSTtRQUNSLDJCQUEyQjtRQUMzQixNQUFNLElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUV0QixrQkFBa0I7UUFDbEIsSUFBSSxDQUFDLFVBQVUsRUFBRSxDQUFDO0lBQ3BCLENBQUM7SUFFTyxRQUFRO1FBQ2QsT0FBTyxJQUFJLE9BQU8sQ0FBQyxDQUFDLE9BQU8sRUFBRSxFQUFFO1lBQzdCLElBQUksUUFBUSxDQUFDLFVBQVUsS0FBSyxVQUFVLElBQUksUUFBUSxDQUFDLFVBQVUsS0FBSyxhQUFhLEVBQUUsQ0FBQztnQkFDaEYsT0FBTyxFQUFFLENBQUM7WUFDWixDQUFDO2lCQUFNLENBQUM7Z0JBQ04sUUFBUSxDQUFDLGdCQUFnQixDQUFDLGtCQUFrQixFQUFFLEdBQUcsRUFBRSxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7WUFDakUsQ0FBQztRQUNILENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVPLFVBQVU7UUFDaEIsK0JBQStCO1FBQy9CLE1BQU0sWUFBWSxHQUFHLHVCQUF1QixFQUFFLENBQUM7UUFFL0MsaUJBQWlCO1FBQ2pCLE1BQU0sQ0FBQyxZQUFZLEVBQUUsUUFBUSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ3RDLENBQUM7Q0FDRjtBQUVELHdCQUF3QjtBQUN4QixJQUFJLFVBQVUsRUFBRSxDQUFDIn0=

package/dist_ts_web/ts_web/elements/taskbuffer-dashboard.demo.d.ts

@@ -0,0 +1,2 @@
+import '../taskbuffer-dashboard.js';
+export declare const demoFunc: () => import("@design.estate/dees-element").TemplateResult<1>;