@push.rocks/taskbuffer 3.1.9 → 3.2.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/taskbuffer',
-    version: '3.1.9',
+    version: '3.2.0',
     description: 'A flexible task management library supporting TypeScript, allowing for task buffering, scheduling, and execution with dependency management.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLDhJQUE4STtDQUM1SixDQUFBIn0=

package/dist_ts/index.d.ts

@@ -1,10 +1,13 @@
 export { Task } from './taskbuffer.classes.task.js';
-export type { ITaskFunction } from './taskbuffer.classes.task.js';
+export type { ITaskFunction, StepNames } 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';
+export { TaskStep } from './taskbuffer.classes.taskstep.js';
+export type { ITaskStep } from './taskbuffer.classes.taskstep.js';
+export type { ITaskMetadata, ITaskExecutionReport, IScheduledTaskInfo } from './taskbuffer.interfaces.js';
 import * as distributedCoordination from './taskbuffer.classes.distributedcoordinator.js';
 export { distributedCoordination };

package/dist_ts/index.js

@@ -5,6 +5,8 @@ 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFFcEQsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBQzlELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxzQ0FBc0MsQ0FBQztBQUNwRSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFDbEUsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBQzVELE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUNoRSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sdUNBQXVDLENBQUM7QUFDdEUsT0FBTyxLQUFLLHVCQUF1QixNQUFNLGdEQUFnRCxDQUFDO0FBQzFGLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFFcEQsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBQzlELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxzQ0FBc0MsQ0FBQztBQUNwRSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFDbEUsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBQzVELE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUNoRSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sdUNBQXVDLENBQUM7QUFFdEUsbUJBQW1CO0FBQ25CLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQU01RCxPQUFPLEtBQUssdUJBQXVCLE1BQU0sZ0RBQWdELENBQUM7QUFDMUYsT0FBTyxFQUFFLHVCQUF1QixFQUFFLENBQUMifQ==

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

@@ -1,6 +1,8 @@
 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>;
 }
@@ -8,14 +10,33 @@ export interface ITaskSetupFunction<T = undefined> {
     (): Promise<T>;
 }
 export type TPreOrAfterTaskFunction = () => Task<any>;
-export declare class Task<T = undefined> {
-    static extractTask<T = undefined>(preOrAfterTaskArg: Task<T> | TPreOrAfterTaskFunction): Task<T>;
+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>(taskArg: Task<T> | TPreOrAfterTaskFunction, touchedTasksArray: Task<T>[]): boolean;
-    static runTask: <T_1>(taskArg: Task<T_1> | TPreOrAfterTaskFunction, optionsArg: {
+    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>[];
+        touchedTasksArray?: Task<T_1, TSteps_1>[];
     }) => Promise<unknown>;
     name: string;
     version: string;
@@ -25,28 +46,41 @@ export declare class Task<T = undefined> {
     bufferMax: number;
     execDelay: number;
     timeout: number;
-    preTask: Task<T> | TPreOrAfterTaskFunction;
-    afterTask: Task<T> | TPreOrAfterTaskFunction;
+    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> | TPreOrAfterTaskFunction;
-        afterTask?: Task<T> | TPreOrAfterTaskFunction;
+        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/taskbuffer.classes.task.js

@@ -1,6 +1,7 @@
 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) {
@@ -53,8 +54,14 @@ export class Task {
             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
@@ -122,6 +129,10 @@ export class Task {
         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;
@@ -130,6 +141,18 @@ export class Task {
         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;
@@ -149,5 +172,86 @@ export class Task {
     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,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
+//# 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/taskbuffer.classes.taskmanager.d.ts

@@ -1,6 +1,7 @@
 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;
@@ -11,22 +12,38 @@ export interface ITaskManagerConstructorOptions {
 }
 export declare class TaskManager {
     randomId: string;
-    taskMap: plugins.lik.ObjectMap<Task<undefined>>;
+    taskMap: plugins.lik.ObjectMap<Task<any, any>>;
     private cronJobManager;
     options: ITaskManagerConstructorOptions;
     constructor(options?: ITaskManagerConstructorOptions);
-    getTaskByName(taskName: string): Task;
-    addTask(task: Task): void;
-    addAndScheduleTask(task: Task, cronString: string): void;
+    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): 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): Promise<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/taskbuffer.classes.taskmanager.js

@@ -107,5 +107,102 @@ export class TaskManager {
             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,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"taskbuffer.classes.taskmanager.js","sourceRoot":"","sources":["../ts/taskbuffer.classes.taskmanager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,yBAAyB,CAAC;AACnD,OAAO,EAAE,IAAI,EAAE,MAAM,8BAA8B,CAAC;AACpD,OAAO,EACL,8BAA8B,GAE/B,MAAM,gDAAgD,CAAC;AAaxD,MAAM,OAAO,WAAW;IAQtB,YAAY,UAA0C,EAAE;QAPjD,aAAQ,GAAG,OAAO,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;QACzC,YAAO,GAAG,IAAI,OAAO,CAAC,GAAG,CAAC,SAAS,EAAkB,CAAC;QACrD,mBAAc,GAAG,IAAI,OAAO,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC;QACtD,YAAO,GAAmC;YAC/C,sBAAsB,EAAE,IAAI;SAC7B,CAAC;QAGA,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IACtD,CAAC;IAEM,aAAa,CAAC,QAAgB;QACnC,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC;IACjE,CAAC;IAEM,OAAO,CAAC,IAAoB;QACjC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;YACf,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;QACtE,CAAC;QACD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACzB,CAAC;IAEM,kBAAkB,CAAC,IAAoB,EAAE,UAAkB;QAChE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACnB,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IACjD,CAAC;IAEM,KAAK,CAAC,iBAAiB,CAAC,QAAgB;QAC7C,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QACnD,IAAI,CAAC,aAAa,EAAE,CAAC;YACnB,MAAM,IAAI,KAAK,CAAC,yBAAyB,QAAQ,SAAS,CAAC,CAAC;QAC9D,CAAC;QACD,OAAO,aAAa,CAAC,OAAO,EAAE,CAAC;IACjC,CAAC;IAEM,KAAK,CAAC,WAAW,CAAC,IAAoB;QAC3C,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC;IACxB,CAAC;IAEM,kBAAkB,CAAC,QAAgB,EAAE,UAAkB;QAC5D,MAAM,cAAc,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QACpD,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CAAC,yBAAyB,QAAQ,SAAS,CAAC,CAAC;QAC9D,CAAC;QACD,IAAI,CAAC,oBAAoB,CAAC,cAAc,EAAE,UAAU,CAAC,CAAC;IACxD,CAAC;IAEO,oBAAoB,CAAC,IAAoB,EAAE,UAAkB;QACnE,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,UAAU,CAC5C,UAAU,EACV,KAAK,EAAE,WAAmB,EAAE,EAAE;YAC5B,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;YACxB,IAAI,IAAI,CAAC,OAAO,CAAC,sBAAsB,EAAE,CAAC;gBACxC,MAAM,kBAAkB,GAAG,MAAM,IAAI,CAAC,8BAA8B,CAClE,IAAI,EACJ,WAAW,CACZ,CAAC;gBACF,IAAI,CAAC,kBAAkB,CAAC,aAAa,EAAE,CAAC;oBACtC,OAAO,CAAC,GAAG,CAAC,+CAA+C,CAAC,CAAC;oBAC7D,OAAO;gBACT,CAAC;qBAAM,CAAC;oBACN,OAAO,CAAC,GAAG,CAAC,sDAAsD,CAAC,CAAC;gBACtE,CAAC;YACH,CAAC;YACD,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC;QACvB,CAAC,CACF,CAAC;QACF,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;IAEO,YAAY,CAAC,IAAoB;QACvC,OAAO,CAAC,GAAG,CAAC,wCAAwC,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC;QACnE,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ;YAC/B,CAAC,CAAC,qBAAqB,IAAI,CAAC,SAAS,iBAAiB;YACtD,CAAC,CAAC,YAAY,CAAC;QACjB,OAAO,CAAC,GAAG,CAAC,UAAU,IAAI,CAAC,IAAI,SAAS,WAAW,EAAE,CAAC,CAAC;IACzD,CAAC;IAEO,KAAK,CAAC,8BAA8B,CAC1C,IAAoB,EACpB,WAAmB;QAEnB,OAAO,CAAC,GAAG,CAAC,2DAA2D,CAAC,CAAC;QAEzE,OAAO,IAAI,CAAC,OAAO,CAAC,sBAAsB,CAAC,0BAA0B,CAAC;YACpE,WAAW,EAAE,IAAI,CAAC,QAAQ;YAC1B,iBAAiB,EAAE,OAAO,CAAC,WAAW,CAAC,OAAO,EAAE;YAChD,MAAM,EAAE,YAAY;YACpB,qBAAqB,EAAE,CAAC;YACxB,iBAAiB,EAAE,WAAW;YAC9B,oBAAoB,EAAE,IAAI,CAAC,OAAO;YAClC,QAAQ,EAAE,IAAI,CAAC,IAAI;YACnB,WAAW,EAAE,IAAI,CAAC,OAAO;SAC1B,CAAC,CAAC;IACL,CAAC;IAEM,oBAAoB,CAAC,QAAgB;QAC1C,MAAM,IAAI,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QAC1C,IAAI,IAAI,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACzB,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAChD,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACtB,CAAC;QACD,IAAI,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;YACzC,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC;QAC7B,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,cAAc,CAAC,IAAoB;QAC9C,MAAM,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC7C,CAAC;IAEM,sBAAsB,CAAC,QAAgB;QAC5C,MAAM,IAAI,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QAC1C,OAAO,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC;IACnE,CAAC;IAEM,KAAK,CAAC,KAAK;QAChB,IAAI,IAAI,CAAC,OAAO,CAAC,sBAAsB,EAAE,CAAC;YACxC,MAAM,IAAI,CAAC,OAAO,CAAC,sBAAsB,CAAC,KAAK,EAAE,CAAC;QACpD,CAAC;QACD,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC;IAC9B,CAAC;IAEM,KAAK,CAAC,IAAI;QACf,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC;QAC3B,IAAI,IAAI,CAAC,OAAO,CAAC,sBAAsB,EAAE,CAAC;YACxC,MAAM,IAAI,CAAC,OAAO,CAAC,sBAAsB,CAAC,IAAI,EAAE,CAAC;QACnD,CAAC;IACH,CAAC;IAED,mCAAmC;IAC5B,eAAe,CAAC,QAAgB;QACrC,MAAM,IAAI,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QAC1C,IAAI,CAAC,IAAI;YAAE,OAAO,IAAI,CAAC;QACvB,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC;IAC5B,CAAC;IAED,6BAA6B;IACtB,mBAAmB;QACxB,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC;IACjE,CAAC;IAED,8DAA8D;IACvD,iBAAiB;QACtB,MAAM,cAAc,GAAyB,EAAE,CAAC;QAEhD,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC;YAC3C,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;gBACjB,cAAc,CAAC,IAAI,CAAC;oBAClB,IAAI,EAAE,IAAI,CAAC,IAAI,IAAI,SAAS;oBAC5B,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,cAAc;oBACrC,OAAO,EAAE,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,oBAAoB,EAAE,CAAC;oBACtD,OAAO,EAAE,IAAI,CAAC,OAAO;oBACrB,KAAK,EAAE,IAAI,CAAC,gBAAgB,EAAE,EAAE;oBAChC,QAAQ,EAAE,IAAI,CAAC,WAAW,EAAE;iBAC7B,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAED,OAAO,cAAc,CAAC;IACxB,CAAC;IAED,2CAA2C;IACpC,oBAAoB,CAAC,QAAgB,EAAE;QAC5C,MAAM,aAAa,GAAG,IAAI,CAAC,iBAAiB,EAAE;aAC3C,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACZ,QAAQ,EAAE,IAAI,CAAC,IAAI;YACnB,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,QAAQ,EAAE,IAAI,CAAC,QAAQ;SACxB,CAAC,CAAC;aACF,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;aACzD,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;QAEnB,OAAO,aAAa,CAAC;IACvB,CAAC;IAED,4DAA4D;IACrD,KAAK,CAAC,oBAAoB,CAC/B,IAAqB,EACrB,OAGC;QAED,sBAAsB;QACtB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAEnB,yBAAyB;QACzB,IAAI,OAAO,EAAE,QAAQ,EAAE,CAAC;YACtB,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAK,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;QACxD,CAAC;QAED,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC7B,MAAM,eAAe,GAAmD,EAAE,CAAC;QAE3E,IAAI,CAAC;YACH,mBAAmB;YACnB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC;YAEpC,2BAA2B;YAC3B,MAAM,MAAM,GAAyB;gBACnC,QAAQ,EAAE,IAAI,CAAC,IAAI,IAAI,SAAS;gBAChC,SAAS;gBACT,OAAO,EAAE,IAAI,CAAC,GAAG,EAAE;gBACnB,QAAQ,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS;gBAChC,KAAK,EAAE,IAAI,CAAC,gBAAgB,EAAE;gBAC9B,cAAc,EAAE,IAAI,CAAC,gBAAgB,EAAE;qBACpC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,KAAK,WAAW,CAAC;qBAC3C,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC;gBACzB,QAAQ,EAAE,IAAI,CAAC,WAAW,EAAE;gBAC5B,MAAM;aACP,CAAC;YAEF,2BAA2B;YAC3B,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAE1B,iCAAiC;YACjC,IAAI,OAAO,EAAE,QAAQ,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;gBACnC,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACvC,CAAC;YAED,OAAO,MAAM,CAAC;QAChB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,sBAAsB;YACtB,MAAM,WAAW,GAAyB;gBACxC,QAAQ,EAAE,IAAI,CAAC,IAAI,IAAI,SAAS;gBAChC,SAAS;gBACT,OAAO,EAAE,IAAI,CAAC,GAAG,EAAE;gBACnB,QAAQ,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS;gBAChC,KAAK,EAAE,IAAI,CAAC,gBAAgB,EAAE;gBAC9B,cAAc,EAAE,IAAI,CAAC,gBAAgB,EAAE;qBACpC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,KAAK,WAAW,CAAC;qBAC3C,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC;gBACzB,QAAQ,EAAE,IAAI,CAAC,WAAW,EAAE;gBAC5B,KAAK,EAAE,KAAc;aACtB,CAAC;YAEF,yCAAyC;YACzC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAE1B,iCAAiC;YACjC,IAAI,OAAO,EAAE,QAAQ,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;gBACnC,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACvC,CAAC;YAED,MAAM,WAAW,CAAC;QACpB,CAAC;IACH,CAAC;CACF"}

package/dist_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/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5jbGFzc2VzLnRhc2tzdGVwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvdGFza2J1ZmZlci5jbGFzc2VzLnRhc2tzdGVwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVVBLE1BQU0sT0FBTyxRQUFRO0lBU25CLFlBQVksTUFBaUU7UUFMdEUsV0FBTSxHQUF1QyxTQUFTLENBQUM7UUFNNUQsSUFBSSxDQUFDLElBQUksR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDO1FBQ3hCLElBQUksQ0FBQyxXQUFXLEdBQUcsTUFBTSxDQUFDLFdBQVcsQ0FBQztRQUN0QyxJQUFJLENBQUMsVUFBVSxHQUFHLE1BQU0sQ0FBQyxVQUFVLENBQUM7SUFDdEMsQ0FBQztJQUVNLEtBQUs7UUFDVixJQUFJLENBQUMsTUFBTSxHQUFHLFFBQVEsQ0FBQztRQUN2QixJQUFJLENBQUMsU0FBUyxHQUFHLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQztJQUM5QixDQUFDO0lBRU0sUUFBUTtRQUNiLElBQUksSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDO1lBQ25CLElBQUksQ0FBQyxPQUFPLEdBQUcsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDO1lBQzFCLElBQUksQ0FBQyxRQUFRLEdBQUcsSUFBSSxDQUFDLE9BQU8sR0FBRyxJQUFJLENBQUMsU0FBUyxDQUFDO1FBQ2hELENBQUM7UUFDRCxJQUFJLENBQUMsTUFBTSxHQUFHLFdBQVcsQ0FBQztJQUM1QixDQUFDO0lBRU0sS0FBSztRQUNWLElBQUksQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDO1FBQ3hCLElBQUksQ0FBQyxTQUFTLEdBQUcsU0FBUyxDQUFDO1FBQzNCLElBQUksQ0FBQyxPQUFPLEdBQUcsU0FBUyxDQUFDO1FBQ3pCLElBQUksQ0FBQyxRQUFRLEdBQUcsU0FBUyxDQUFDO0lBQzVCLENBQUM7SUFFTSxNQUFNO1FBQ1gsT0FBTztZQUNMLElBQUksRUFBRSxJQUFJLENBQUMsSUFBSTtZQUNmLFdBQVcsRUFBRSxJQUFJLENBQUMsV0FBVztZQUM3QixVQUFVLEVBQUUsSUFBSSxDQUFDLFVBQVU7WUFDM0IsTUFBTSxFQUFFLElBQUksQ0FBQyxNQUFNO1lBQ25CLFNBQVMsRUFBRSxJQUFJLENBQUMsU0FBUztZQUN6QixPQUFPLEVBQUUsSUFBSSxDQUFDLE9BQU87WUFDckIsUUFBUSxFQUFFLElBQUksQ0FBQyxRQUFRO1NBQ3hCLENBQUM7SUFDSixDQUFDO0NBQ0YifQ==

package/dist_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/taskbuffer.interfaces.js

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

package/dist_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/00_commitinfo_data.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/taskbuffer",
-  "version": "3.1.9",
+  "version": "3.2.0",
   "private": false,
   "description": "A flexible task management library supporting TypeScript, allowing for task buffering, scheduling, and execution with dependency management.",
   "main": "dist_ts/index.js",
@@ -61,7 +61,7 @@
   ],
   "scripts": {
     "test": "(tstest test/ --verbose --logfile --timeout 120)",
-    "build": "(tsbuild --web && tsbundle npm)",
+    "build": "(tsbuild tsfolders)",
     "buildDocs": "tsdoc"
   }
 }