@ariestools/threads 8.2.0 → 8.3.0

package/dist/browser/master/index-browser.mjs

@@ -92,17 +92,25 @@ import {
 } from "observable-fns";
 
 // src/master/pool-types.ts
-var PoolEventType = /* @__PURE__ */ ((PoolEventType2) => {
-  PoolEventType2["initialized"] = "initialized";
-  PoolEventType2["taskCanceled"] = "taskCanceled";
-  PoolEventType2["taskCompleted"] = "taskCompleted";
-  PoolEventType2["taskFailed"] = "taskFailed";
-  PoolEventType2["taskQueued"] = "taskQueued";
-  PoolEventType2["taskQueueDrained"] = "taskQueueDrained";
-  PoolEventType2["taskStart"] = "taskStart";
-  PoolEventType2["terminated"] = "terminated";
-  return PoolEventType2;
-})(PoolEventType || {});
+import { Enum } from "@ariestools/sdk/enum";
+var PoolEventType = Enum({
+  /** All workers in the pool have initialized. */
+  initialized: "initialized",
+  /** A queued task was canceled before execution. */
+  taskCanceled: "taskCanceled",
+  /** A task completed successfully. */
+  taskCompleted: "taskCompleted",
+  /** A task failed during execution. */
+  taskFailed: "taskFailed",
+  /** A task was added to the queue. */
+  taskQueued: "taskQueued",
+  /** The pool has no remaining queued tasks. */
+  taskQueueDrained: "taskQueueDrained",
+  /** A worker started executing a task. */
+  taskStart: "taskStart",
+  /** The pool and its workers were terminated. */
+  terminated: "terminated"
+});
 
 // src/symbols.ts
 var $errors = /* @__PURE__ */ Symbol("thread.errors");
@@ -178,7 +186,7 @@ var WorkerPool = class {
         await Promise.all(workers.map((worker) => worker.init));
         this.eventSubject.next({
           size: workers.length,
-          type: "initialized" /* initialized */
+          type: PoolEventType.initialized
         });
       } catch (error) {
         const initError = error instanceof Error ? error : new Error(String(error));
@@ -197,7 +205,7 @@ var WorkerPool = class {
     this.debug(`Running task #${task.id} on worker #${workerID}...`);
     this.eventSubject.next({
       taskID: task.id,
-      type: "taskStart" /* taskStart */,
+      type: PoolEventType.taskStart,
       workerID
     });
     try {
@@ -206,7 +214,7 @@ var WorkerPool = class {
       this.eventSubject.next({
         returnValue,
         taskID: task.id,
-        type: "taskCompleted" /* taskCompleted */,
+        type: PoolEventType.taskCompleted,
         workerID
       });
     } catch (ex) {
@@ -215,7 +223,7 @@ var WorkerPool = class {
       this.eventSubject.next({
         error,
         taskID: task.id,
-        type: "taskFailed" /* taskFailed */,
+        type: PoolEventType.taskFailed,
         workerID
       });
     }
@@ -244,7 +252,7 @@ var WorkerPool = class {
     const nextTask = this.taskQueue.shift();
     if (!nextTask) {
       this.debug("Task queue is empty");
-      this.eventSubject.next({ type: "taskQueueDrained" /* taskQueueDrained */ });
+      this.eventSubject.next({ type: PoolEventType.taskQueueDrained });
       return;
     }
     this.run(availableWorker, nextTask);
@@ -252,13 +260,13 @@ var WorkerPool = class {
   taskCompletion(taskID) {
     return new Promise((resolve, reject) => {
       const eventSubscription = this.events().subscribe((event) => {
-        if (event.type === "taskCompleted" /* taskCompleted */ && event.taskID === taskID) {
+        if (event.type === PoolEventType.taskCompleted && event.taskID === taskID) {
           eventSubscription.unsubscribe();
           resolve(event.returnValue);
-        } else if (event.type === "taskFailed" /* taskFailed */ && event.taskID === taskID) {
+        } else if (event.type === PoolEventType.taskFailed && event.taskID === taskID) {
           eventSubscription.unsubscribe();
           reject(event.error);
-        } else if (event.type === "terminated" /* terminated */) {
+        } else if (event.type === PoolEventType.terminated) {
           eventSubscription.unsubscribe();
           reject(new Error("Pool has been terminated before task was run."));
         }
@@ -276,7 +284,7 @@ var WorkerPool = class {
     const getCurrentlyRunningTasks = () => flatMap(this.workers, (worker) => worker.runningTasks);
     const taskFailures = [];
     const failureSubscription = this.eventObservable.subscribe((event) => {
-      if (event.type === "taskFailed" /* taskFailed */) {
+      if (event.type === PoolEventType.taskFailed) {
         taskFailures.push(event.error);
       }
     });
@@ -284,7 +292,7 @@ var WorkerPool = class {
       const subscription = this.eventObservable.subscribe({
         error: reject,
         next(event) {
-          if (event.type !== "taskQueueDrained" /* taskQueueDrained */) {
+          if (event.type !== PoolEventType.taskQueueDrained) {
             return;
           }
           subscription.unsubscribe();
@@ -303,10 +311,10 @@ var WorkerPool = class {
       const subscription = this.eventObservable.subscribe({
         error: reject,
         next(event) {
-          if (event.type === "taskQueueDrained" /* taskQueueDrained */) {
+          if (event.type === PoolEventType.taskQueueDrained) {
             subscription.unsubscribe();
             resolve(settlementPromise);
-          } else if (event.type === "taskFailed" /* taskFailed */) {
+          } else if (event.type === PoolEventType.taskFailed) {
             subscription.unsubscribe();
             reject(event.error);
           }
@@ -345,7 +353,7 @@ var WorkerPool = class {
         this.taskQueue = this.taskQueue.filter((someTask) => someTask !== task);
         this.eventSubject.next({
           taskID: task.id,
-          type: "taskCanceled" /* taskCanceled */
+          type: PoolEventType.taskCanceled
         });
       },
       id: taskID,
@@ -361,7 +369,7 @@ var WorkerPool = class {
     this.taskQueue.push(task);
     this.eventSubject.next({
       taskID: task.id,
-      type: "taskQueued" /* taskQueued */
+      type: PoolEventType.taskQueued
     });
     this.scheduleWork();
     return task;
@@ -373,7 +381,7 @@ var WorkerPool = class {
     }
     this.eventSubject.next({
       remainingQueue: [...this.taskQueue],
-      type: "terminated" /* terminated */
+      type: PoolEventType.terminated
     });
     this.eventSubject.complete();
     await Promise.all(this.workers.map(async (worker) => Thread.terminate(await worker.init)));
@@ -441,6 +449,17 @@ function createPromiseWithResolver() {
   return [promise, exposedResolver];
 }
 
+// src/types/master.ts
+import { Enum as Enum2 } from "@ariestools/sdk/enum";
+var WorkerEventType = Enum2({
+  /** The threads implementation encountered an internal error. */
+  internalError: "internalError",
+  /** The worker emitted a message. */
+  message: "message",
+  /** The worker terminated. */
+  termination: "termination"
+});
+
 // src/master/invocation-proxy.ts
 import DebugLogger2 from "debug";
 import { multicast as multicast2, Observable as Observable3 } from "observable-fns";
@@ -598,13 +617,34 @@ function isTransferDescriptor(thing) {
   return thing != null && typeof thing === "object" && Reflect.get(thing, $transferable) === true;
 }
 
+// src/types/messages.ts
+import { Enum as Enum3 } from "@ariestools/sdk/enum";
+var MasterMessageType = Enum3({
+  /** Cancel a previously submitted job. */
+  cancel: "cancel",
+  /** Run a job in the worker. */
+  run: "run"
+});
+var WorkerMessageType = Enum3({
+  /** A job failed. */
+  error: "error",
+  /** The worker exposed its callable API. */
+  init: "init",
+  /** A job produced a result. */
+  result: "result",
+  /** A job started running. */
+  running: "running",
+  /** An error escaped the worker job handler. */
+  uncaughtError: "uncaughtError"
+});
+
 // src/master/invocation-proxy.ts
 var debugMessages = DebugLogger2("threads:master:messages");
 var nextJobUID = 1;
 var dedupe = (array) => [...new Set(array)];
-var isJobErrorMessage = (data) => data?.type === "error" /* error */;
-var isJobResultMessage = (data) => data?.type === "result" /* result */;
-var isJobStartMessage = (data) => data?.type === "running" /* running */;
+var isJobErrorMessage = (data) => data?.type === WorkerMessageType.error;
+var isJobResultMessage = (data) => data?.type === WorkerMessageType.result;
+var isJobStartMessage = (data) => data?.type === WorkerMessageType.running;
 function createObservableForJob(worker, jobUID) {
   return new Observable3((observer) => {
     let asyncType;
@@ -643,7 +683,7 @@ function createObservableForJob(worker, jobUID) {
     return () => {
       if (asyncType === "observable" || asyncType === void 0) {
         const cancelMessage = {
-          type: "cancel" /* cancel */,
+          type: MasterMessageType.cancel,
           uid: jobUID
         };
         worker.postMessage(cancelMessage);
@@ -681,7 +721,7 @@ function createProxyFunction(worker, method) {
     const runMessage = {
       args,
       method,
-      type: "run" /* run */,
+      type: MasterMessageType.run,
       uid
     };
     debugMessages("Sending command to run function to worker:", runMessage);
@@ -738,7 +778,7 @@ function createEventObservable(worker, workerTermination) {
     const messageHandler = ((messageEvent) => {
       const workerEvent = {
         data: messageEvent.data,
-        type: "message" /* message */
+        type: WorkerEventType.message
       };
       observer.next(workerEvent);
     });
@@ -746,7 +786,7 @@ function createEventObservable(worker, workerTermination) {
       debugThreadUtils("Unhandled promise rejection event in thread:", errorEvent);
       const workerEvent = {
         error: new Error(errorEvent.reason),
-        type: "internalError" /* internalError */
+        type: WorkerEventType.internalError
       };
       observer.next(workerEvent);
     });
@@ -754,7 +794,7 @@ function createEventObservable(worker, workerTermination) {
     worker.addEventListener("unhandledrejection", rejectionHandler);
     void (async () => {
       await workerTermination;
-      const terminationEvent = { type: "termination" /* termination */ };
+      const terminationEvent = { type: WorkerEventType.termination };
       worker.removeEventListener("message", messageHandler);
       worker.removeEventListener("unhandledrejection", rejectionHandler);
       observer.next(terminationEvent);
@@ -772,7 +812,7 @@ function createTerminator(worker) {
   return { terminate, termination };
 }
 function setPrivateThreadProps(raw, worker, workerEvents, terminate) {
-  const workerErrors = workerEvents.filter((event) => event.type === "internalError" /* internalError */).map((errorEvent) => errorEvent.error);
+  const workerErrors = workerEvents.filter((event) => event.type === WorkerEventType.internalError).map((errorEvent) => errorEvent.error);
   const result = raw;
   const privateProps = [
     [$errors, { enumerable: false, value: workerErrors }],