@ms-cloudpack/api-server 0.42.1 → 0.43.0

package/lib/types/TaskList.d.ts

@@ -0,0 +1,392 @@
+import { z } from 'zod';
+export declare const ZodTaskList: z.ZodObject<{
+    tasks: z.ZodArray<z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+        status: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"pending">, z.ZodLiteral<"complete">]>>;
+        timings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            start: z.ZodNumber;
+            end: z.ZodOptional<z.ZodNumber>;
+            threwException: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            start: number;
+            end?: number | undefined;
+            threwException?: boolean | undefined;
+        }, {
+            name: string;
+            start: number;
+            end?: number | undefined;
+            threwException?: boolean | undefined;
+        }>, "many">>;
+        startTime: z.ZodNumber;
+        durationMilliseconds: z.ZodOptional<z.ZodNumber>;
+        lastUpdated: z.ZodOptional<z.ZodNumber>;
+    }, {
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        inputPath: z.ZodOptional<z.ZodString>;
+        outputPath: z.ZodOptional<z.ZodString>;
+    }>, {
+        id: z.ZodString;
+        errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            text: z.ZodString;
+            source: z.ZodString;
+            location: z.ZodOptional<z.ZodObject<{
+                file: z.ZodString;
+                line: z.ZodOptional<z.ZodNumber>;
+                column: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                file: string;
+                line?: number | undefined;
+                column?: number | undefined;
+            }, {
+                file: string;
+                line?: number | undefined;
+                column?: number | undefined;
+            }>>;
+            notes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                text: z.ZodString;
+                location: z.ZodOptional<z.ZodObject<{
+                    file: z.ZodString;
+                    line: z.ZodOptional<z.ZodNumber>;
+                    column: z.ZodOptional<z.ZodNumber>;
+                }, "strip", z.ZodTypeAny, {
+                    file: string;
+                    line?: number | undefined;
+                    column?: number | undefined;
+                }, {
+                    file: string;
+                    line?: number | undefined;
+                    column?: number | undefined;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                text: string;
+                location?: {
+                    file: string;
+                    line?: number | undefined;
+                    column?: number | undefined;
+                } | undefined;
+            }, {
+                text: string;
+                location?: {
+                    file: string;
+                    line?: number | undefined;
+                    column?: number | undefined;
+                } | undefined;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            text: string;
+            source: string;
+            location?: {
+                file: string;
+                line?: number | undefined;
+                column?: number | undefined;
+            } | undefined;
+            notes?: {
+                text: string;
+                location?: {
+                    file: string;
+                    line?: number | undefined;
+                    column?: number | undefined;
+                } | undefined;
+            }[] | undefined;
+        }, {
+            text: string;
+            source: string;
+            location?: {
+                file: string;
+                line?: number | undefined;
+                column?: number | undefined;
+            } | undefined;
+            notes?: {
+                text: string;
+                location?: {
+                    file: string;
+                    line?: number | undefined;
+                    column?: number | undefined;
+                } | undefined;
+            }[] | undefined;
+        }>, "many">>;
+        warnings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            text: z.ZodString;
+            source: z.ZodString;
+            location: z.ZodOptional<z.ZodObject<{
+                file: z.ZodString;
+                line: z.ZodOptional<z.ZodNumber>;
+                column: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                file: string;
+                line?: number | undefined;
+                column?: number | undefined;
+            }, {
+                file: string;
+                line?: number | undefined;
+                column?: number | undefined;
+            }>>;
+            notes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                text: z.ZodString;
+                location: z.ZodOptional<z.ZodObject<{
+                    file: z.ZodString;
+                    line: z.ZodOptional<z.ZodNumber>;
+                    column: z.ZodOptional<z.ZodNumber>;
+                }, "strip", z.ZodTypeAny, {
+                    file: string;
+                    line?: number | undefined;
+                    column?: number | undefined;
+                }, {
+                    file: string;
+                    line?: number | undefined;
+                    column?: number | undefined;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                text: string;
+                location?: {
+                    file: string;
+                    line?: number | undefined;
+                    column?: number | undefined;
+                } | undefined;
+            }, {
+                text: string;
+                location?: {
+                    file: string;
+                    line?: number | undefined;
+                    column?: number | undefined;
+                } | undefined;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            text: string;
+            source: string;
+            location?: {
+                file: string;
+                line?: number | undefined;
+                column?: number | undefined;
+            } | undefined;
+            notes?: {
+                text: string;
+                location?: {
+                    file: string;
+                    line?: number | undefined;
+                    column?: number | undefined;
+                } | undefined;
+            }[] | undefined;
+        }, {
+            text: string;
+            source: string;
+            location?: {
+                file: string;
+                line?: number | undefined;
+                column?: number | undefined;
+            } | undefined;
+            notes?: {
+                text: string;
+                location?: {
+                    file: string;
+                    line?: number | undefined;
+                    column?: number | undefined;
+                } | undefined;
+            }[] | undefined;
+        }>, "many">>;
+    }>, "strip", z.ZodTypeAny, {
+        id: string;
+        startTime: number;
+        status?: "pending" | "complete" | undefined;
+        name?: string | undefined;
+        inputPath?: string | undefined;
+        outputPath?: string | undefined;
+        errors?: {
+            text: string;
+            source: string;
+            location?: {
+                file: string;
+                line?: number | undefined;
+                column?: number | undefined;
+            } | undefined;
+            notes?: {
+                text: string;
+                location?: {
+                    file: string;
+                    line?: number | undefined;
+                    column?: number | undefined;
+                } | undefined;
+            }[] | undefined;
+        }[] | undefined;
+        warnings?: {
+            text: string;
+            source: string;
+            location?: {
+                file: string;
+                line?: number | undefined;
+                column?: number | undefined;
+            } | undefined;
+            notes?: {
+                text: string;
+                location?: {
+                    file: string;
+                    line?: number | undefined;
+                    column?: number | undefined;
+                } | undefined;
+            }[] | undefined;
+        }[] | undefined;
+        timings?: {
+            name: string;
+            start: number;
+            end?: number | undefined;
+            threwException?: boolean | undefined;
+        }[] | undefined;
+        durationMilliseconds?: number | undefined;
+        lastUpdated?: number | undefined;
+    }, {
+        id: string;
+        startTime: number;
+        status?: "pending" | "complete" | undefined;
+        name?: string | undefined;
+        inputPath?: string | undefined;
+        outputPath?: string | undefined;
+        errors?: {
+            text: string;
+            source: string;
+            location?: {
+                file: string;
+                line?: number | undefined;
+                column?: number | undefined;
+            } | undefined;
+            notes?: {
+                text: string;
+                location?: {
+                    file: string;
+                    line?: number | undefined;
+                    column?: number | undefined;
+                } | undefined;
+            }[] | undefined;
+        }[] | undefined;
+        warnings?: {
+            text: string;
+            source: string;
+            location?: {
+                file: string;
+                line?: number | undefined;
+                column?: number | undefined;
+            } | undefined;
+            notes?: {
+                text: string;
+                location?: {
+                    file: string;
+                    line?: number | undefined;
+                    column?: number | undefined;
+                } | undefined;
+            }[] | undefined;
+        }[] | undefined;
+        timings?: {
+            name: string;
+            start: number;
+            end?: number | undefined;
+            threwException?: boolean | undefined;
+        }[] | undefined;
+        durationMilliseconds?: number | undefined;
+        lastUpdated?: number | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    tasks: {
+        id: string;
+        startTime: number;
+        status?: "pending" | "complete" | undefined;
+        name?: string | undefined;
+        inputPath?: string | undefined;
+        outputPath?: string | undefined;
+        errors?: {
+            text: string;
+            source: string;
+            location?: {
+                file: string;
+                line?: number | undefined;
+                column?: number | undefined;
+            } | undefined;
+            notes?: {
+                text: string;
+                location?: {
+                    file: string;
+                    line?: number | undefined;
+                    column?: number | undefined;
+                } | undefined;
+            }[] | undefined;
+        }[] | undefined;
+        warnings?: {
+            text: string;
+            source: string;
+            location?: {
+                file: string;
+                line?: number | undefined;
+                column?: number | undefined;
+            } | undefined;
+            notes?: {
+                text: string;
+                location?: {
+                    file: string;
+                    line?: number | undefined;
+                    column?: number | undefined;
+                } | undefined;
+            }[] | undefined;
+        }[] | undefined;
+        timings?: {
+            name: string;
+            start: number;
+            end?: number | undefined;
+            threwException?: boolean | undefined;
+        }[] | undefined;
+        durationMilliseconds?: number | undefined;
+        lastUpdated?: number | undefined;
+    }[];
+}, {
+    tasks: {
+        id: string;
+        startTime: number;
+        status?: "pending" | "complete" | undefined;
+        name?: string | undefined;
+        inputPath?: string | undefined;
+        outputPath?: string | undefined;
+        errors?: {
+            text: string;
+            source: string;
+            location?: {
+                file: string;
+                line?: number | undefined;
+                column?: number | undefined;
+            } | undefined;
+            notes?: {
+                text: string;
+                location?: {
+                    file: string;
+                    line?: number | undefined;
+                    column?: number | undefined;
+                } | undefined;
+            }[] | undefined;
+        }[] | undefined;
+        warnings?: {
+            text: string;
+            source: string;
+            location?: {
+                file: string;
+                line?: number | undefined;
+                column?: number | undefined;
+            } | undefined;
+            notes?: {
+                text: string;
+                location?: {
+                    file: string;
+                    line?: number | undefined;
+                    column?: number | undefined;
+                } | undefined;
+            }[] | undefined;
+        }[] | undefined;
+        timings?: {
+            name: string;
+            start: number;
+            end?: number | undefined;
+            threwException?: boolean | undefined;
+        }[] | undefined;
+        durationMilliseconds?: number | undefined;
+        lastUpdated?: number | undefined;
+    }[];
+}>;
+export type TaskList = z.infer<typeof ZodTaskList>;
+//# sourceMappingURL=TaskList.d.ts.map

package/lib/types/TaskList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TaskList.d.ts","sourceRoot":"","sources":["../../src/types/TaskList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEtB,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC"}

package/lib/types/TaskList.js

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { ZodTaskDescription } from './TaskDescription.js';
+export const ZodTaskList = z.object({
+    tasks: z.array(ZodTaskDescription),
+});
+//# sourceMappingURL=TaskList.js.map

package/lib/types/TaskList.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TaskList.js","sourceRoot":"","sources":["../../src/types/TaskList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC;IAClC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,kBAAkB,CAAC;CACnC,CAAC,CAAC","sourcesContent":["import { z } from 'zod';\nimport { ZodTaskDescription } from './TaskDescription.js';\n\nexport const ZodTaskList = z.object({\n  tasks: z.array(ZodTaskDescription),\n});\n\nexport type TaskList = z.infer<typeof ZodTaskList>;\n"]}

package/lib/types/TaskRunnerContext.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from './Context.js';
+export type TaskRunnerContext = Pick<Context, 'reporter' | 'bus' | 'session'>;
+//# sourceMappingURL=TaskRunnerContext.d.ts.map

package/lib/types/TaskRunnerContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TaskRunnerContext.d.ts","sourceRoot":"","sources":["../../src/types/TaskRunnerContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAAC,OAAO,EAAE,UAAU,GAAG,KAAK,GAAG,SAAS,CAAC,CAAC"}

package/lib/types/TaskRunnerContext.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=TaskRunnerContext.js.map

package/lib/types/TaskRunnerContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TaskRunnerContext.js","sourceRoot":"","sources":["../../src/types/TaskRunnerContext.ts"],"names":[],"mappings":"","sourcesContent":["import type { Context } from './Context.js';\n\nexport type TaskRunnerContext = Pick<Context, 'reporter' | 'bus' | 'session'>;\n"]}

package/lib/utilities/TaskRunner.d.ts

@@ -1,18 +1,19 @@
-/// <reference types="node" resolution-mode="require"/>
 import type { TaskOptions } from '../types/TaskOptions.js';
 import type { Task } from '../types/Task.js';
-import EventEmitter from 'events';
+import type { TaskRunnerContext } from '../types/TaskRunnerContext.js';
 /**
  * TaskRunner class manages the state of Tasks.
  * This class is to be called by the api server.
  */
-export declare class TaskRunner extends EventEmitter {
+export declare class TaskRunner {
+    private _context;
     private _queue;
+    private _taskStats;
     private _pendingTasks;
     private _completedTasks;
     private _requiresRerun;
     private _prevTasks;
-    constructor();
+    constructor(context?: TaskRunnerContext);
     /**
      * The add method enqueues a Task and returns its Promise.
      * If a Task with the same id has already been processed,
@@ -30,9 +31,21 @@ export declare class TaskRunner extends EventEmitter {
      * to clear the TaskRunner's state before reloading the page.
      */
     remove(id: string): void;
+    /**
+     * The clear method disposes all tasks and clears the TaskRunner.
+     */
+    clear(): void;
     /** Pauses the TaskRunner (for testing). */
-    pause(): void;
+    _pause(): void;
     /** Starts or resumes the TaskRunner (for testing). */
-    start(): void;
+    _start(): void;
+    /**
+     * Internal method to report the start of a task to the bus.
+     */
+    private _reportStart;
+    /**
+     * Internal method to report the end of a task to the bus.
+     */
+    private _reportEnd;
 }
 //# sourceMappingURL=TaskRunner.d.ts.map

package/lib/utilities/TaskRunner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TaskRunner.d.ts","sourceRoot":"","sources":["../../src/utilities/TaskRunner.ts"],"names":[],"mappings":";AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAE7C,OAAO,YAAY,MAAM,QAAQ,CAAC;AAOlC;;;GAGG;AACH,qBAAa,UAAW,SAAQ,YAAY;IAC1C,OAAO,CAAC,MAAM,CAAS;IAEvB,OAAO,CAAC,aAAa,CAA4B;IAEjD,OAAO,CAAC,eAAe,CAAmB;IAC1C,OAAO,CAAC,cAAc,CAAc;IAEpC,OAAO,CAAC,UAAU,CAAyB;;IAY3C;;;;;OAKG;IACH,GAAG,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IAiF1E;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAcxB,2CAA2C;IAC3C,KAAK,IAAI,IAAI;IAIb,sDAAsD;IACtD,KAAK,IAAI,IAAI;CAGd"}
+{"version":3,"file":"TaskRunner.d.ts","sourceRoot":"","sources":["../../src/utilities/TaskRunner.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAOvE;;;GAGG;AACH,qBAAa,UAAU;IAGrB,OAAO,CAAC,QAAQ,CAAgC;IAChD,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,UAAU,CAAY;IAE9B,OAAO,CAAC,aAAa,CAA4B;IAEjD,OAAO,CAAC,eAAe,CAAmB;IAC1C,OAAO,CAAC,cAAc,CAAc;IAEpC,OAAO,CAAC,UAAU,CAAyB;gBAE/B,OAAO,CAAC,EAAE,iBAAiB;IAevC;;;;;OAKG;IACH,GAAG,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IA6E1E;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAaxB;;OAEG;IACH,KAAK,IAAI,IAAI;IAYb,2CAA2C;IAC3C,MAAM,IAAI,IAAI;IAId,sDAAsD;IACtD,MAAM,IAAI,IAAI;IAId;;OAEG;IACH,OAAO,CAAC,YAAY;IAmCpB;;OAEG;IACH,OAAO,CAAC,UAAU;CA6BnB"}

package/lib/utilities/TaskRunner.js

@@ -1,21 +1,23 @@
 import PQueue from 'p-queue';
-import EventEmitter from 'events';
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const log = (...messages) => {
-    // console.log(`TaskRunner:`, ...messages);
-};
+import { getDefaultTaskStats } from './getDefaultTaskStats.js';
+import { taskListSource, taskStatsSource } from '../index.browser.js';
 /**
  * TaskRunner class manages the state of Tasks.
  * This class is to be called by the api server.
  */
-export class TaskRunner extends EventEmitter {
-    constructor() {
-        super();
+export class TaskRunner {
+    constructor(context) {
+        this._context = context;
         this._queue = new PQueue({ concurrency: 10 });
+        this._taskStats = getDefaultTaskStats();
         this._pendingTasks = new Map();
         this._completedTasks = new Map();
         this._requiresRerun = new Set();
         this._prevTasks = new Map();
+        if (this._context) {
+            const { bus, session } = this._context;
+            bus.publish([session.id, 'status'], this._taskStats);
+        }
     }
     /**
      * The add method enqueues a Task and returns its Promise.
@@ -33,7 +35,6 @@ export class TaskRunner extends EventEmitter {
         // Check if we are already completed the task with that id.
         const action = this._completedTasks.get(id);
         if (action !== undefined && !rerun) {
-            log(`Previous action found, returning: "${name}:${id}"`);
             return Promise.resolve(action);
         }
         // Check if we are already running the task with that id.
@@ -42,7 +43,6 @@ export class TaskRunner extends EventEmitter {
             if (rerun) {
                 this._requiresRerun.add(id);
             }
-            log(`Previous action found, waiting: "${name}:${id}"`);
             return pending;
         }
         const resultPromise = (async () => {
@@ -53,22 +53,21 @@ export class TaskRunner extends EventEmitter {
                 taskResult = await this._queue.add(async () => {
                     const startDescription = {
                         ...task.getStartDescription?.(),
-                        id: task.id,
+                        id,
                     };
-                    this.emit('executeStarted', startDescription);
+                    this._reportStart(id, startDescription);
                     const result = await execute();
                     const endDescription = {
                         ...task.getEndDescription?.(result),
-                        id: task.id,
+                        id,
                     };
-                    this.emit('executeCompleted', endDescription);
+                    this._reportEnd(id, endDescription);
                     return result;
                 }, 
                 // Removes void from return type.
                 // Read more on: https://github.com/sindresorhus/p-queue/issues/175
                 { throwOnTimeout: true, priority });
             } while (this._requiresRerun.has(id));
-            log(`Task finished: "${name}:${id}"`);
             // Delete from pending list.
             this._pendingTasks.delete(id);
             // Extra check to ensure that the task returned a value.
@@ -98,7 +97,7 @@ export class TaskRunner extends EventEmitter {
             .get(id)
             ?.dispose?.()
             .catch(() => {
-            log(`Error disposing task: ${id}`);
+            console.debug(`Error disposing task: ${id}`);
         });
         this._prevTasks.get(id)?.clear?.();
         this._prevTasks.delete(id);
@@ -106,13 +105,90 @@ export class TaskRunner extends EventEmitter {
         this._pendingTasks.delete(id);
         this._completedTasks.delete(id);
     }
+    /**
+     * The clear method disposes all tasks and clears the TaskRunner.
+     */
+    clear() {
+        this._taskStats = getDefaultTaskStats();
+        if (this._context) {
+            const { bus, session } = this._context;
+            bus.publish([session.id, 'status'], this._taskStats);
+            bus.publish(taskListSource, { tasks: [] });
+        }
+        for (const id of this._prevTasks.keys()) {
+            this.remove(id);
+        }
+    }
     /** Pauses the TaskRunner (for testing). */
-    pause() {
+    _pause() {
         this._queue.pause();
     }
     /** Starts or resumes the TaskRunner (for testing). */
-    start() {
+    _start() {
         this._queue.start();
     }
+    /**
+     * Internal method to report the start of a task to the bus.
+     */
+    _reportStart(id, description) {
+        if (!this._context)
+            return;
+        const { bus } = this._context;
+        const { tasks } = bus.getData(taskListSource.path) || { tasks: [] };
+        const index = tasks.findIndex((t) => t.id === id);
+        const previousDescription = tasks[index];
+        const now = new Date().getTime();
+        if (!previousDescription) {
+            this._taskStats.totalTasks++;
+        }
+        if (previousDescription?.status === 'complete') {
+            this._taskStats.totalErrors -= previousDescription.errors?.length || 0;
+            this._taskStats.totalWarnings -= previousDescription.warnings?.length || 0;
+        }
+        this._taskStats.remainingTasks++;
+        this._taskStats.status = 'pending';
+        const task = {
+            ...description,
+            status: 'pending',
+            startTime: now,
+        };
+        if (index === -1) {
+            tasks.push(task);
+        }
+        else {
+            tasks[index] = task;
+        }
+        bus.publish(taskStatsSource, this._taskStats);
+        bus.publish(taskListSource, { tasks });
+    }
+    /**
+     * Internal method to report the end of a task to the bus.
+     */
+    _reportEnd(id, description) {
+        if (!this._context)
+            return;
+        const { bus } = this._context;
+        const { tasks } = bus.getData(taskListSource.path) || { tasks: [] };
+        const index = tasks.findIndex((t) => t.id === id);
+        const previousDescription = tasks[index];
+        const now = new Date().getTime();
+        if (previousDescription) {
+            this._taskStats.remainingTasks--;
+            this._taskStats.totalErrors += description?.errors?.length || 0;
+            this._taskStats.totalWarnings += description?.warnings?.length || 0;
+            tasks[index] = {
+                ...previousDescription,
+                ...description,
+                status: 'complete',
+                durationMilliseconds: now - previousDescription.startTime,
+                lastUpdated: now,
+            };
+            if (this._taskStats.remainingTasks === 0) {
+                this._taskStats.status = 'idle';
+            }
+            bus.publish(taskStatsSource, this._taskStats);
+            bus.publish(taskListSource, { tasks });
+        }
+    }
 }
 //# sourceMappingURL=TaskRunner.js.map