@xylabs/threads 4.4.35 → 4.5.0

package/dist/enum.d.ts

@@ -0,0 +1,5 @@
+export declare const Enum: <const T extends Record<string | number | symbol, unknown>>(obj: Readonly<T>) => Enum<T>;
+export type Enum<T extends Readonly<Record<string | number | symbol, unknown>>> = {
+    readonly [K in keyof T]: T[K];
+};
+export type EnumValue<T extends Record<string | number | symbol, unknown>, K = Enum<T>> = K[keyof K];

package/dist/enum.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Enum = void 0;
+const Enum = (obj) => {
+    return obj;
+};
+exports.Enum = Enum;

package/dist/esm/enum.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Enum = void 0;
+const Enum = (obj) => {
+    return obj;
+};
+exports.Enum = Enum;

package/dist/esm/master/pool-types.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PoolEventType = void 0;
-var PoolEventType;
-(function (PoolEventType) {
-    PoolEventType["initialized"] = "initialized";
-    PoolEventType["taskCanceled"] = "taskCanceled";
-    PoolEventType["taskCompleted"] = "taskCompleted";
-    PoolEventType["taskFailed"] = "taskFailed";
-    PoolEventType["taskQueued"] = "taskQueued";
-    PoolEventType["taskQueueDrained"] = "taskQueueDrained";
-    PoolEventType["taskStart"] = "taskStart";
-    PoolEventType["terminated"] = "terminated";
-})(PoolEventType || (exports.PoolEventType = PoolEventType = {}));
+const enum_1 = require("../enum");
+exports.PoolEventType = (0, enum_1.Enum)({
+    initialized: 'initialized',
+    taskCanceled: 'taskCanceled',
+    taskCompleted: 'taskCompleted',
+    taskFailed: 'taskFailed',
+    taskQueued: 'taskQueued',
+    taskQueueDrained: 'taskQueueDrained',
+    taskStart: 'taskStart',
+    terminated: 'terminated',
+});

package/dist/esm/master/pool.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Thread = exports.PoolEventType = exports.Pool = void 0;
 const debug_1 = __importDefault(require("debug"));
 const observable_fns_1 = require("observable-fns");
-const ponyfills_1 = require("../ponyfills");
 const implementation_1 = require("./implementation");
 const pool_types_1 = require("./pool-types");
 const thread_1 = require("./thread");
@@ -121,7 +120,10 @@ class WorkerPool {
             this.eventSubject.next({ type: pool_types_1.PoolEventType.taskQueueDrained });
             return;
         }
-        this.run(availableWorker, nextTask);
+        this.run(availableWorker, nextTask).catch((error) => {
+            this.debug('Error while running task:', error);
+            this.eventSubject.error(error);
+        });
     }
     taskCompletion(taskID) {
         return new Promise((resolve, reject) => {
@@ -153,7 +155,7 @@ class WorkerPool {
             throw this.initErrors[0];
         }
         if (allowResolvingImmediately && this.taskQueue.length === 0) {
-            await (0, ponyfills_1.allSettled)(getCurrentlyRunningTasks());
+            await Promise.allSettled(getCurrentlyRunningTasks());
             return taskFailures;
         }
         await new Promise((resolve, reject) => {
@@ -167,7 +169,7 @@ class WorkerPool {
                 },
             });
         });
-        await (0, ponyfills_1.allSettled)(getCurrentlyRunningTasks());
+        await Promise.allSettled(getCurrentlyRunningTasks());
         failureSubscription.unsubscribe();
         return taskFailures;
     }

package/dist/esm/types/master.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkerEventType = void 0;
-var WorkerEventType;
-(function (WorkerEventType) {
-    WorkerEventType["internalError"] = "internalError";
-    WorkerEventType["message"] = "message";
-    WorkerEventType["termination"] = "termination";
-})(WorkerEventType || (exports.WorkerEventType = WorkerEventType = {}));
+const enum_1 = require("../enum");
+exports.WorkerEventType = (0, enum_1.Enum)({
+    internalError: 'internalError',
+    message: 'message',
+    termination: 'termination',
+});

package/dist/esm/types/messages.js

@@ -1,16 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkerMessageType = exports.MasterMessageType = void 0;
-var MasterMessageType;
-(function (MasterMessageType) {
-    MasterMessageType["cancel"] = "cancel";
-    MasterMessageType["run"] = "run";
-})(MasterMessageType || (exports.MasterMessageType = MasterMessageType = {}));
-var WorkerMessageType;
-(function (WorkerMessageType) {
-    WorkerMessageType["error"] = "error";
-    WorkerMessageType["init"] = "init";
-    WorkerMessageType["result"] = "result";
-    WorkerMessageType["running"] = "running";
-    WorkerMessageType["uncaughtError"] = "uncaughtError";
-})(WorkerMessageType || (exports.WorkerMessageType = WorkerMessageType = {}));
+const enum_1 = require("../enum");
+exports.MasterMessageType = (0, enum_1.Enum)({
+    cancel: 'cancel',
+    run: 'run',
+});
+exports.WorkerMessageType = (0, enum_1.Enum)({
+    error: 'error',
+    init: 'init',
+    result: 'result',
+    running: 'running',
+    uncaughtError: 'uncaughtError',
+});

package/dist/master/pool-types.d.ts

@@ -1,42 +1,45 @@
+import type { EnumValue } from '../enum';
+import { Enum } from '../enum';
 import type { Thread } from './thread';
-export declare enum PoolEventType {
-    initialized = "initialized",
-    taskCanceled = "taskCanceled",
-    taskCompleted = "taskCompleted",
-    taskFailed = "taskFailed",
-    taskQueued = "taskQueued",
-    taskQueueDrained = "taskQueueDrained",
-    taskStart = "taskStart",
-    terminated = "terminated"
-}
+export declare const PoolEventType: Enum<{
+    initialized: "initialized";
+    taskCanceled: "taskCanceled";
+    taskCompleted: "taskCompleted";
+    taskFailed: "taskFailed";
+    taskQueued: "taskQueued";
+    taskQueueDrained: "taskQueueDrained";
+    taskStart: "taskStart";
+    terminated: "terminated";
+}>;
+export type PoolEventType = EnumValue<typeof PoolEventType>;
 export type TaskRunFunction<ThreadType extends Thread, Return> = (worker: ThreadType) => Promise<Return>;
 export type PoolEvent<ThreadType extends Thread> = {
-    type: PoolEventType.initialized;
+    type: 'initialized';
     size: number;
 } | {
-    type: PoolEventType.taskQueued;
+    type: 'taskQueued';
     taskID: number;
 } | {
-    type: PoolEventType.taskQueueDrained;
+    type: 'taskQueueDrained';
 } | {
-    type: PoolEventType.taskStart;
+    type: 'taskStart';
     taskID: number;
     workerID: number;
 } | {
-    type: PoolEventType.taskCompleted;
+    type: 'taskCompleted';
     returnValue: any;
     taskID: number;
     workerID: number;
 } | {
-    type: PoolEventType.taskFailed;
+    type: 'taskFailed';
     error: Error;
     taskID: number;
     workerID: number;
 } | {
-    type: PoolEventType.taskCanceled;
+    type: 'taskCanceled';
     taskID: number;
 } | {
-    type: PoolEventType.terminated;
+    type: 'terminated';
     remainingQueue: Array<QueuedTask<ThreadType, any>>;
 };
 export interface WorkerDescriptor<ThreadType extends Thread> {

package/dist/master/pool-types.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PoolEventType = void 0;
-var PoolEventType;
-(function (PoolEventType) {
-    PoolEventType["initialized"] = "initialized";
-    PoolEventType["taskCanceled"] = "taskCanceled";
-    PoolEventType["taskCompleted"] = "taskCompleted";
-    PoolEventType["taskFailed"] = "taskFailed";
-    PoolEventType["taskQueued"] = "taskQueued";
-    PoolEventType["taskQueueDrained"] = "taskQueueDrained";
-    PoolEventType["taskStart"] = "taskStart";
-    PoolEventType["terminated"] = "terminated";
-})(PoolEventType || (exports.PoolEventType = PoolEventType = {}));
+const enum_1 = require("../enum");
+exports.PoolEventType = (0, enum_1.Enum)({
+    initialized: 'initialized',
+    taskCanceled: 'taskCanceled',
+    taskCompleted: 'taskCompleted',
+    taskFailed: 'taskFailed',
+    taskQueued: 'taskQueued',
+    taskQueueDrained: 'taskQueueDrained',
+    taskStart: 'taskStart',
+    terminated: 'terminated',
+});

package/dist/master/pool.d.ts

@@ -20,7 +20,16 @@ interface PoolOptions {
     size?: number;
 }
 declare class WorkerPool<ThreadType extends Thread> implements Pool<ThreadType> {
-    static EventType: typeof PoolEventType;
+    static EventType: import("../enum").Enum<{
+        initialized: "initialized";
+        taskCanceled: "taskCanceled";
+        taskCompleted: "taskCompleted";
+        taskFailed: "taskFailed";
+        taskQueued: "taskQueued";
+        taskQueueDrained: "taskQueueDrained";
+        taskStart: "taskStart";
+        terminated: "terminated";
+    }>;
     private readonly debug;
     private readonly eventObservable;
     private readonly options;

package/dist/master/pool.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Thread = exports.PoolEventType = exports.Pool = void 0;
 const debug_1 = __importDefault(require("debug"));
 const observable_fns_1 = require("observable-fns");
-const ponyfills_1 = require("../ponyfills");
 const implementation_1 = require("./implementation");
 const pool_types_1 = require("./pool-types");
 const thread_1 = require("./thread");
@@ -121,7 +120,10 @@ class WorkerPool {
             this.eventSubject.next({ type: pool_types_1.PoolEventType.taskQueueDrained });
             return;
         }
-        this.run(availableWorker, nextTask);
+        this.run(availableWorker, nextTask).catch((error) => {
+            this.debug('Error while running task:', error);
+            this.eventSubject.error(error);
+        });
     }
     taskCompletion(taskID) {
         return new Promise((resolve, reject) => {
@@ -153,7 +155,7 @@ class WorkerPool {
             throw this.initErrors[0];
         }
         if (allowResolvingImmediately && this.taskQueue.length === 0) {
-            await (0, ponyfills_1.allSettled)(getCurrentlyRunningTasks());
+            await Promise.allSettled(getCurrentlyRunningTasks());
             return taskFailures;
         }
         await new Promise((resolve, reject) => {
@@ -167,7 +169,7 @@ class WorkerPool {
                 },
             });
         });
-        await (0, ponyfills_1.allSettled)(getCurrentlyRunningTasks());
+        await Promise.allSettled(getCurrentlyRunningTasks());
         failureSubscription.unsubscribe();
         return taskFailures;
     }

package/dist/types/master.d.ts

@@ -1,4 +1,6 @@
 import type { Observable } from 'observable-fns';
+import type { EnumValue } from '../enum';
+import { Enum } from '../enum';
 import type { ObservablePromise } from '../observable-promise';
 import type { $errors, $events, $terminate, $worker } from '../symbols';
 import type { TransferDescriptor } from '../transferable';
@@ -37,9 +39,8 @@ interface AnyFunctionThread extends PrivateThreadProps {
 interface AnyModuleThread extends PrivateThreadProps {
 }
 export type Thread = AnyFunctionThread | AnyModuleThread;
-export type TransferList = Transferable[];
 export interface Worker extends EventTarget {
-    postMessage(value: any, transferList?: TransferList): void;
+    postMessage(value: any, transferList?: Transferable[]): void;
     terminate(callback?: (error?: Error, exitCode?: number) => void): void | Promise<number>;
 }
 export interface ThreadsWorkerOptions extends WorkerOptions {
@@ -54,7 +55,7 @@ export interface ThreadsWorkerOptions extends WorkerOptions {
 }
 export declare class WorkerImplementation extends EventTarget implements Worker {
     constructor(path: string, options?: ThreadsWorkerOptions);
-    postMessage(value: any, transferList?: TransferList): void;
+    postMessage(value: any, transferList?: Transferable[]): void;
     terminate(): void | Promise<number>;
 }
 export declare class BlobWorker extends WorkerImplementation {
@@ -65,21 +66,22 @@ export interface ImplementationExport {
     blob: typeof BlobWorker;
     default: typeof WorkerImplementation;
 }
-export declare enum WorkerEventType {
-    internalError = "internalError",
-    message = "message",
-    termination = "termination"
-}
+export declare const WorkerEventType: Enum<{
+    internalError: "internalError";
+    message: "message";
+    termination: "termination";
+}>;
+export type WorkerEventType = EnumValue<typeof WorkerEventType>;
 export interface WorkerInternalErrorEvent {
     error: Error;
-    type: WorkerEventType.internalError;
+    type: 'internalError';
 }
 export interface WorkerMessageEvent<Data> {
     data: Data;
-    type: WorkerEventType.message;
+    type: 'message';
 }
 export interface WorkerTerminationEvent {
-    type: WorkerEventType.termination;
+    type: 'termination';
 }
 export type WorkerEvent = WorkerInternalErrorEvent | WorkerMessageEvent<any> | WorkerTerminationEvent;
 export {};

package/dist/types/master.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkerEventType = void 0;
-var WorkerEventType;
-(function (WorkerEventType) {
-    WorkerEventType["internalError"] = "internalError";
-    WorkerEventType["message"] = "message";
-    WorkerEventType["termination"] = "termination";
-})(WorkerEventType || (exports.WorkerEventType = WorkerEventType = {}));
+const enum_1 = require("../enum");
+exports.WorkerEventType = (0, enum_1.Enum)({
+    internalError: 'internalError',
+    message: 'message',
+    termination: 'termination',
+});

package/dist/types/messages.d.ts

@@ -1,32 +1,36 @@
+import type { EnumValue } from '../enum';
+import { Enum } from '../enum';
 export interface SerializedError {
     __error_marker: '$$error';
     message: string;
     name: string;
     stack?: string;
 }
-export declare enum MasterMessageType {
-    cancel = "cancel",
-    run = "run"
-}
+export declare const MasterMessageType: Enum<{
+    cancel: "cancel";
+    run: "run";
+}>;
+export type MasterMessageType = EnumValue<typeof MasterMessageType>;
 export type MasterJobCancelMessage = {
-    type: MasterMessageType.cancel;
+    type: 'cancel';
     uid: number;
 };
 export type MasterJobRunMessage = {
-    type: MasterMessageType.run;
+    type: 'run';
     uid: number;
     method?: string;
     args: any[];
 };
-export declare enum WorkerMessageType {
-    error = "error",
-    init = "init",
-    result = "result",
-    running = "running",
-    uncaughtError = "uncaughtError"
-}
+export declare const WorkerMessageType: Enum<{
+    error: "error";
+    init: "init";
+    result: "result";
+    running: "running";
+    uncaughtError: "uncaughtError";
+}>;
+export type WorkerMessageType = EnumValue<typeof WorkerMessageType>;
 export type WorkerUncaughtErrorMessage = {
-    type: WorkerMessageType.uncaughtError;
+    type: 'uncaughtError';
     error: {
         message: string;
         name: string;
@@ -34,7 +38,7 @@ export type WorkerUncaughtErrorMessage = {
     };
 };
 export type WorkerInitMessage = {
-    type: WorkerMessageType.init;
+    type: 'init';
     exposed: {
         type: 'function';
     } | {
@@ -43,18 +47,18 @@ export type WorkerInitMessage = {
     };
 };
 export type WorkerJobErrorMessage = {
-    type: WorkerMessageType.error;
+    type: 'error';
     uid: number;
     error: SerializedError;
 };
 export type WorkerJobResultMessage = {
-    type: WorkerMessageType.result;
+    type: 'result';
     uid: number;
     complete?: true;
     payload?: any;
 };
 export type WorkerJobStartMessage = {
-    type: WorkerMessageType.running;
+    type: 'running';
     uid: number;
     resultType: 'observable' | 'promise';
 };

package/dist/types/messages.js

@@ -1,16 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkerMessageType = exports.MasterMessageType = void 0;
-var MasterMessageType;
-(function (MasterMessageType) {
-    MasterMessageType["cancel"] = "cancel";
-    MasterMessageType["run"] = "run";
-})(MasterMessageType || (exports.MasterMessageType = MasterMessageType = {}));
-var WorkerMessageType;
-(function (WorkerMessageType) {
-    WorkerMessageType["error"] = "error";
-    WorkerMessageType["init"] = "init";
-    WorkerMessageType["result"] = "result";
-    WorkerMessageType["running"] = "running";
-    WorkerMessageType["uncaughtError"] = "uncaughtError";
-})(WorkerMessageType || (exports.WorkerMessageType = WorkerMessageType = {}));
+const enum_1 = require("../enum");
+exports.MasterMessageType = (0, enum_1.Enum)({
+    cancel: 'cancel',
+    run: 'run',
+});
+exports.WorkerMessageType = (0, enum_1.Enum)({
+    error: 'error',
+    init: 'init',
+    result: 'result',
+    running: 'running',
+    uncaughtError: 'uncaughtError',
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xylabs/threads",
-  "version": "4.4.35",
+  "version": "4.5.0",
   "description": "Web workers & worker threads as simple as a function call",
   "license": "MIT",
   "main": "dist/index.js",
@@ -91,22 +91,21 @@
     "observable-fns": "^0.6.1"
   },
   "devDependencies": {
-    "@babel/types": "^7.26.3",
+    "@babel/types": "^7.26.5",
     "@rollup/plugin-commonjs": "^28.0.2",
     "@rollup/plugin-node-resolve": "^16.0.0",
     "@types/debug": "^4.1.12",
-    "@types/node": "^22.10.4",
+    "@types/node": "^22.10.7",
     "@xylabs/ts-scripts-yarn3": "^4.2.6",
     "cross-env": "^7.0.3",
     "puppet-run": "^0.11.4",
     "raw-loader": "^4.0.2",
     "rimraf": "^6.0.1",
-    "rollup": "^4.29.1",
+    "rollup": "^4.31.0",
     "threads-plugin": "^1.4.0",
     "tiny-worker": "^2.3.0",
-    "tslib": "^2.8.1",
-    "typescript": "^5.7.2",
-    "vitest": "^2.1.8",
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.3",
     "webpack": "^5.97.1"
   },
   "optionalDependencies": {

package/src/enum.ts

@@ -0,0 +1,87 @@
+/**
+ * Transforms a given record object into a readonly "enum-like" structure while preserving
+ * the literal types of its values. This allows you to use the returned object both at runtime
+ * (for lookups) and at compile time (for strongly typed values).
+ *
+ * To maintain literal types (i.e., prevent them from being widened to `string`, `number`, etc.),
+ * ensure you annotate your object with `as const` before passing it to `Enum`.
+ *
+ * @template T - A record type with string keys and any kind of values.
+ * @param obj - A readonly record object annotated with `as const`.
+ * @returns A readonly version of the provided record, preserving exact literal value types.
+ *
+ * @example
+ * ```typescript
+ * // Defining a record with literal types using as const:
+ * const DnsRecordType = Enum({
+ *   A: 1,
+ *   AAAA: 28,
+ *   CAA: 257,
+ *   CNAME: 5,
+ *   DNAME: 39,
+ *   MX: 15,
+ *   NS: 2,
+ *   PTR: 12,
+ *   SOA: 6,
+ *   SPF: 99,
+ *   SRV: 33,
+ *   TXT: 16,
+ * } as const);
+ *
+ * // DnsRecordType is now a readonly object:
+ * // {
+ * //   readonly A: 1;
+ * //   readonly AAAA: 28;
+ * //   readonly CAA: 257;
+ * //   readonly CNAME: 5;
+ * //   readonly DNAME: 39;
+ * //   readonly MX: 15;
+ * //   readonly NS: 2;
+ * //   readonly PTR: 12;
+ * //   readonly SOA: 6;
+ * //   readonly SPF: 99;
+ * //   readonly SRV: 33;
+ * //   readonly TXT: 16;
+ * // }
+ * ```
+ */
+export const Enum = <const T extends Record<string | number | symbol, unknown>>(obj: Readonly<T>): Enum<T> => {
+  return obj
+}
+
+/**
+ * A utility type that, given a `Record<string, unknown>`, returns a readonly version
+ * of that record. This results in a type where all properties of `T` are readonly.
+ *
+ * @template T - The record type to make readonly.
+ *
+ * @example
+ * ```typescript
+ * // Given a record:
+ * export const DnsRecordType = Enum({
+ *   A: 1,
+ *   AAAA: 28,
+ *   CAA: 257,
+ *   CNAME: 5,
+ *   DNAME: 39,
+ *   MX: 15,
+ *   NS: 2,
+ *   PTR: 12,
+ *   SOA: 6,
+ *   SPF: 99,
+ *   SRV: 33,
+ *   TXT: 16,
+ * })
+ *
+ * // Now the type inference will preserve the literal types:
+ * export type DnsRecordType = Enum<typeof DnsRecordType>
+ * ```
+ */
+export type Enum<T extends Readonly<Record<string | number | symbol, unknown>>> = {
+  readonly [K in keyof T]: T[K]
+}
+
+/**
+ * A utility type that, given an `Enum` object, returns the union of its values.
+ */
+export type EnumValue<T extends Record<string | number | symbol, unknown>, K = Enum<T>> = K[keyof K]

package/src/master/pool-types.ts

@@ -1,57 +1,61 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/member-ordering */
+import type { EnumValue } from '../enum'
+import { Enum } from '../enum'
 import type { Thread } from './thread'
 
 /** Pool event type. Specifies the type of each `PoolEvent`. */
-export enum PoolEventType {
-  initialized = 'initialized',
-  taskCanceled = 'taskCanceled',
-  taskCompleted = 'taskCompleted',
-  taskFailed = 'taskFailed',
-  taskQueued = 'taskQueued',
-  taskQueueDrained = 'taskQueueDrained',
-  taskStart = 'taskStart',
-  terminated = 'terminated',
-}
+export const PoolEventType = Enum({
+  initialized: 'initialized',
+  taskCanceled: 'taskCanceled',
+  taskCompleted: 'taskCompleted',
+  taskFailed: 'taskFailed',
+  taskQueued: 'taskQueued',
+  taskQueueDrained: 'taskQueueDrained',
+  taskStart: 'taskStart',
+  terminated: 'terminated',
+})
+
+export type PoolEventType = EnumValue<typeof PoolEventType>
 
 export type TaskRunFunction<ThreadType extends Thread, Return> = (worker: ThreadType) => Promise<Return>
 
 /** Pool event. Subscribe to those events using `pool.events()`. Useful for debugging. */
 export type PoolEvent<ThreadType extends Thread> =
   | {
-    type: PoolEventType.initialized
+    type: 'initialized'
     size: number
   }
   | {
-    type: PoolEventType.taskQueued
+    type: 'taskQueued'
     taskID: number
   }
   | {
-    type: PoolEventType.taskQueueDrained
+    type: 'taskQueueDrained'
   }
   | {
-    type: PoolEventType.taskStart
+    type: 'taskStart'
     taskID: number
     workerID: number
   }
   | {
-    type: PoolEventType.taskCompleted
+    type: 'taskCompleted'
     returnValue: any
     taskID: number
     workerID: number
   }
   | {
-    type: PoolEventType.taskFailed
+    type: 'taskFailed'
     error: Error
     taskID: number
     workerID: number
   }
   | {
-    type: PoolEventType.taskCanceled
+    type: 'taskCanceled'
     taskID: number
   }
   | {
-    type: PoolEventType.terminated
+    type: 'terminated'
     remainingQueue: Array<QueuedTask<ThreadType, any>>
   }
 

package/src/master/pool.ts

@@ -6,13 +6,12 @@
 /* eslint-disable unicorn/no-array-reduce */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-namespace */
-/* eslint-disable @typescript-eslint/no-floating-promises */
+
 import DebugLogger from 'debug'
 import {
   multicast, Observable, Subject,
 } from 'observable-fns'
 
-import { allSettled } from '../ponyfills'
 import { defaultPoolSize } from './implementation'
 import type {
   PoolEvent, QueuedTask, TaskRunFunction, WorkerDescriptor,
@@ -224,7 +223,10 @@ class WorkerPool<ThreadType extends Thread> implements Pool<ThreadType> {
       return
     }
 
-    this.run(availableWorker, nextTask)
+    this.run(availableWorker, nextTask).catch((error) => {
+      this.debug('Error while running task:', error)
+      this.eventSubject.error(error)
+    })
   }
 
   private taskCompletion(taskID: number) {
@@ -259,7 +261,7 @@ class WorkerPool<ThreadType extends Thread> implements Pool<ThreadType> {
       throw this.initErrors[0]
     }
     if (allowResolvingImmediately && this.taskQueue.length === 0) {
-      await allSettled(getCurrentlyRunningTasks())
+      await Promise.allSettled(getCurrentlyRunningTasks())
       return taskFailures
     }
 
@@ -275,7 +277,7 @@ class WorkerPool<ThreadType extends Thread> implements Pool<ThreadType> {
       })
     })
 
-    await allSettled(getCurrentlyRunningTasks())
+    await Promise.allSettled(getCurrentlyRunningTasks())
     failureSubscription.unsubscribe()
 
     return taskFailures

package/src/types/master.ts

@@ -6,6 +6,8 @@
 // See <https://github.com/microsoft/TypeScript/issues/28009>
 import type { Observable } from 'observable-fns'
 
+import type { EnumValue } from '../enum'
+import { Enum } from '../enum'
 import type { ObservablePromise } from '../observable-promise'
 import type {
   $errors, $events, $terminate, $worker,
@@ -64,11 +66,9 @@ interface AnyModuleThread extends PrivateThreadProps {
 /** Worker thread. Either a `FunctionThread` or a `ModuleThread`. */
 export type Thread = AnyFunctionThread | AnyModuleThread
 
-export type TransferList = Transferable[]
-
 /** Worker instance. Either a web worker or a node.js Worker provided by `worker_threads` or `tiny-worker`. */
 export interface Worker extends EventTarget {
-  postMessage(value: any, transferList?: TransferList): void
+  postMessage(value: any, transferList?: Transferable[]): void
   /** In nodejs 10+ return type is Promise while with tiny-worker and in browser return type is void */
   terminate(callback?: (error?: Error, exitCode?: number) => void): void | Promise<number>
 }
@@ -93,7 +93,7 @@ export interface ThreadsWorkerOptions extends WorkerOptions {
 /** Worker implementation. Either web worker or a node.js Worker class. */
 export declare class WorkerImplementation extends EventTarget implements Worker {
   constructor(path: string, options?: ThreadsWorkerOptions)
-  postMessage(value: any, transferList?: TransferList): void
+  postMessage(value: any, transferList?: Transferable[]): void
   terminate(): void | Promise<number>
 }
 
@@ -109,24 +109,26 @@ export interface ImplementationExport {
 }
 
 /** Event as emitted by worker thread. Subscribe to using `Thread.events(thread)`. */
-export enum WorkerEventType {
-  internalError = 'internalError',
-  message = 'message',
-  termination = 'termination',
-}
+export const WorkerEventType = Enum({
+  internalError: 'internalError',
+  message: 'message',
+  termination: 'termination',
+})
+
+export type WorkerEventType = EnumValue<typeof WorkerEventType>
 
 export interface WorkerInternalErrorEvent {
   error: Error
-  type: WorkerEventType.internalError
+  type: 'internalError'
 }
 
 export interface WorkerMessageEvent<Data> {
   data: Data
-  type: WorkerEventType.message
+  type: 'message'
 }
 
 export interface WorkerTerminationEvent {
-  type: WorkerEventType.termination
+  type: 'termination'
 }
 
 export type WorkerEvent = WorkerInternalErrorEvent | WorkerMessageEvent<any> | WorkerTerminationEvent

package/src/types/messages.ts

@@ -1,4 +1,8 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
+
+import type { EnumValue } from '../enum'
+import { Enum } from '../enum'
+
 /* eslint-disable @typescript-eslint/member-ordering */
 export interface SerializedError {
   __error_marker: '$$error'
@@ -10,18 +14,20 @@ export interface SerializedError {
 /////////////////////////////
 // Messages sent by master:
 
-export enum MasterMessageType {
-  cancel = 'cancel',
-  run = 'run',
-}
+export const MasterMessageType = Enum({
+  cancel: 'cancel',
+  run: 'run',
+})
+
+export type MasterMessageType = EnumValue<typeof MasterMessageType>
 
 export type MasterJobCancelMessage = {
-  type: MasterMessageType.cancel
+  type: 'cancel'
   uid: number
 }
 
 export type MasterJobRunMessage = {
-  type: MasterMessageType.run
+  type: 'run'
   uid: number
   method?: string
   args: any[]
@@ -30,16 +36,18 @@ export type MasterJobRunMessage = {
 ////////////////////////////
 // Messages sent by worker:
 
-export enum WorkerMessageType {
-  error = 'error',
-  init = 'init',
-  result = 'result',
-  running = 'running',
-  uncaughtError = 'uncaughtError',
-}
+export const WorkerMessageType = Enum({
+  error: 'error',
+  init: 'init',
+  result: 'result',
+  running: 'running',
+  uncaughtError: 'uncaughtError',
+})
+
+export type WorkerMessageType = EnumValue<typeof WorkerMessageType>
 
 export type WorkerUncaughtErrorMessage = {
-  type: WorkerMessageType.uncaughtError
+  type: 'uncaughtError'
   error: {
     message: string
     name: string
@@ -48,25 +56,25 @@ export type WorkerUncaughtErrorMessage = {
 }
 
 export type WorkerInitMessage = {
-  type: WorkerMessageType.init
+  type: 'init'
   exposed: { type: 'function' } | { type: 'module'; methods: string[] }
 }
 
 export type WorkerJobErrorMessage = {
-  type: WorkerMessageType.error
+  type: 'error'
   uid: number
   error: SerializedError
 }
 
 export type WorkerJobResultMessage = {
-  type: WorkerMessageType.result
+  type: 'result'
   uid: number
   complete?: true
   payload?: any
 }
 
 export type WorkerJobStartMessage = {
-  type: WorkerMessageType.running
+  type: 'running'
   uid: number
   resultType: 'observable' | 'promise'
 }

package/dist/esm/ponyfills.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.allSettled = allSettled;
-function allSettled(values) {
-    return Promise.all(values.map((item) => {
-        const onFulfill = (value) => {
-            return { status: 'fulfilled', value };
-        };
-        const onReject = (reason) => {
-            return { reason, status: 'rejected' };
-        };
-        const itemPromise = Promise.resolve(item);
-        try {
-            return itemPromise.then(onFulfill, onReject);
-        }
-        catch (error) {
-            return Promise.reject(error);
-        }
-    }));
-}

package/dist/ponyfills.d.ts

@@ -1,8 +0,0 @@
-export type SettlementResult<T> = {
-    status: 'fulfilled';
-    value: T;
-} | {
-    reason: any;
-    status: 'rejected';
-};
-export declare function allSettled<T>(values: T[]): Promise<Array<SettlementResult<T>>>;

package/dist/ponyfills.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.allSettled = allSettled;
-function allSettled(values) {
-    return Promise.all(values.map((item) => {
-        const onFulfill = (value) => {
-            return { status: 'fulfilled', value };
-        };
-        const onReject = (reason) => {
-            return { reason, status: 'rejected' };
-        };
-        const itemPromise = Promise.resolve(item);
-        try {
-            return itemPromise.then(onFulfill, onReject);
-        }
-        catch (error) {
-            return Promise.reject(error);
-        }
-    }));
-}

package/src/ponyfills.ts

@@ -1,31 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-export type SettlementResult<T> =
-  | {
-    status: 'fulfilled'
-    value: T
-  }
-  | {
-    reason: any
-    status: 'rejected'
-  }
-
-// Based on <https://github.com/es-shims/Promise.allSettled/blob/master/implementation.js>
-export function allSettled<T>(values: T[]): Promise<Array<SettlementResult<T>>> {
-  return Promise.all(
-    values.map((item) => {
-      const onFulfill = (value: T) => {
-        return { status: 'fulfilled', value } as const
-      }
-      const onReject = (reason: any) => {
-        return { reason, status: 'rejected' } as const
-      }
-
-      const itemPromise = Promise.resolve(item)
-      try {
-        return itemPromise.then(onFulfill, onReject)
-      } catch (error) {
-        return Promise.reject(error)
-      }
-    }),
-  )
-}