@xylabs/threads 4.5.0 → 4.5.1

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

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PoolEventType = void 0;
-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',
-});
+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 = {}));

package/dist/esm/master/pool.js

@@ -6,6 +6,7 @@ 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");
@@ -120,10 +121,7 @@ class WorkerPool {
             this.eventSubject.next({ type: pool_types_1.PoolEventType.taskQueueDrained });
             return;
         }
-        this.run(availableWorker, nextTask).catch((error) => {
-            this.debug('Error while running task:', error);
-            this.eventSubject.error(error);
-        });
+        this.run(availableWorker, nextTask);
     }
     taskCompletion(taskID) {
         return new Promise((resolve, reject) => {
@@ -155,7 +153,7 @@ class WorkerPool {
             throw this.initErrors[0];
         }
         if (allowResolvingImmediately && this.taskQueue.length === 0) {
-            await Promise.allSettled(getCurrentlyRunningTasks());
+            await (0, ponyfills_1.allSettled)(getCurrentlyRunningTasks());
             return taskFailures;
         }
         await new Promise((resolve, reject) => {
@@ -169,7 +167,7 @@ class WorkerPool {
                 },
             });
         });
-        await Promise.allSettled(getCurrentlyRunningTasks());
+        await (0, ponyfills_1.allSettled)(getCurrentlyRunningTasks());
         failureSubscription.unsubscribe();
         return taskFailures;
     }

package/dist/esm/ponyfills.js

@@ -0,0 +1,20 @@
+"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/esm/types/master.js

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

package/dist/esm/types/messages.js

@@ -1,15 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkerMessageType = exports.MasterMessageType = void 0;
-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',
-});
+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 = {}));

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

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

package/dist/master/pool.d.ts

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

package/dist/master/pool.js

@@ -6,6 +6,7 @@ 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");
@@ -120,10 +121,7 @@ class WorkerPool {
             this.eventSubject.next({ type: pool_types_1.PoolEventType.taskQueueDrained });
             return;
         }
-        this.run(availableWorker, nextTask).catch((error) => {
-            this.debug('Error while running task:', error);
-            this.eventSubject.error(error);
-        });
+        this.run(availableWorker, nextTask);
     }
     taskCompletion(taskID) {
         return new Promise((resolve, reject) => {
@@ -155,7 +153,7 @@ class WorkerPool {
             throw this.initErrors[0];
         }
         if (allowResolvingImmediately && this.taskQueue.length === 0) {
-            await Promise.allSettled(getCurrentlyRunningTasks());
+            await (0, ponyfills_1.allSettled)(getCurrentlyRunningTasks());
             return taskFailures;
         }
         await new Promise((resolve, reject) => {
@@ -169,7 +167,7 @@ class WorkerPool {
                 },
             });
         });
-        await Promise.allSettled(getCurrentlyRunningTasks());
+        await (0, ponyfills_1.allSettled)(getCurrentlyRunningTasks());
         failureSubscription.unsubscribe();
         return taskFailures;
     }

package/dist/ponyfills.d.ts

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,20 @@
+"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/types/master.d.ts

@@ -1,6 +1,4 @@
 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';
@@ -39,8 +37,9 @@ 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?: Transferable[]): void;
+    postMessage(value: any, transferList?: TransferList): void;
     terminate(callback?: (error?: Error, exitCode?: number) => void): void | Promise<number>;
 }
 export interface ThreadsWorkerOptions extends WorkerOptions {
@@ -55,7 +54,7 @@ export interface ThreadsWorkerOptions extends WorkerOptions {
 }
 export declare class WorkerImplementation extends EventTarget implements Worker {
     constructor(path: string, options?: ThreadsWorkerOptions);
-    postMessage(value: any, transferList?: Transferable[]): void;
+    postMessage(value: any, transferList?: TransferList): void;
     terminate(): void | Promise<number>;
 }
 export declare class BlobWorker extends WorkerImplementation {
@@ -66,22 +65,21 @@ export interface ImplementationExport {
     blob: typeof BlobWorker;
     default: typeof WorkerImplementation;
 }
-export declare const WorkerEventType: Enum<{
-    internalError: "internalError";
-    message: "message";
-    termination: "termination";
-}>;
-export type WorkerEventType = EnumValue<typeof WorkerEventType>;
+export declare enum WorkerEventType {
+    internalError = "internalError",
+    message = "message",
+    termination = "termination"
+}
 export interface WorkerInternalErrorEvent {
     error: Error;
-    type: 'internalError';
+    type: WorkerEventType.internalError;
 }
 export interface WorkerMessageEvent<Data> {
     data: Data;
-    type: 'message';
+    type: WorkerEventType.message;
 }
 export interface WorkerTerminationEvent {
-    type: 'termination';
+    type: WorkerEventType.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;
-const enum_1 = require("../enum");
-exports.WorkerEventType = (0, enum_1.Enum)({
-    internalError: 'internalError',
-    message: 'message',
-    termination: 'termination',
-});
+var WorkerEventType;
+(function (WorkerEventType) {
+    WorkerEventType["internalError"] = "internalError";
+    WorkerEventType["message"] = "message";
+    WorkerEventType["termination"] = "termination";
+})(WorkerEventType || (exports.WorkerEventType = WorkerEventType = {}));

package/dist/types/messages.d.ts

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

package/dist/types/messages.js

@@ -1,15 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkerMessageType = exports.MasterMessageType = void 0;
-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',
-});
+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 = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xylabs/threads",
-  "version": "4.5.0",
+  "version": "4.5.1",
   "description": "Web workers & worker threads as simple as a function call",
   "license": "MIT",
   "main": "dist/index.js",
@@ -95,7 +95,7 @@
     "@rollup/plugin-commonjs": "^28.0.2",
     "@rollup/plugin-node-resolve": "^16.0.0",
     "@types/debug": "^4.1.12",
-    "@types/node": "^22.10.7",
+    "@types/node": "^22.10.10",
     "@xylabs/ts-scripts-yarn3": "^4.2.6",
     "cross-env": "^7.0.3",
     "puppet-run": "^0.11.4",
@@ -104,8 +104,9 @@
     "rollup": "^4.31.0",
     "threads-plugin": "^1.4.0",
     "tiny-worker": "^2.3.0",
+    "tslib": "^2.8.1",
     "typescript": "^5.7.3",
-    "vitest": "^3.0.3",
+    "vitest": "^3.0.4",
     "webpack": "^5.97.1"
   },
   "optionalDependencies": {

package/src/master/pool-types.ts

@@ -1,61 +1,57 @@
 /* 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 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 enum PoolEventType {
+  initialized = 'initialized',
+  taskCanceled = 'taskCanceled',
+  taskCompleted = 'taskCompleted',
+  taskFailed = 'taskFailed',
+  taskQueued = 'taskQueued',
+  taskQueueDrained = 'taskQueueDrained',
+  taskStart = 'taskStart',
+  terminated = 'terminated',
+}
 
 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: 'initialized'
+    type: PoolEventType.initialized
     size: number
   }
   | {
-    type: 'taskQueued'
+    type: PoolEventType.taskQueued
     taskID: number
   }
   | {
-    type: 'taskQueueDrained'
+    type: PoolEventType.taskQueueDrained
   }
   | {
-    type: 'taskStart'
+    type: PoolEventType.taskStart
     taskID: number
     workerID: number
   }
   | {
-    type: 'taskCompleted'
+    type: PoolEventType.taskCompleted
     returnValue: any
     taskID: number
     workerID: number
   }
   | {
-    type: 'taskFailed'
+    type: PoolEventType.taskFailed
     error: Error
     taskID: number
     workerID: number
   }
   | {
-    type: 'taskCanceled'
+    type: PoolEventType.taskCanceled
     taskID: number
   }
   | {
-    type: 'terminated'
+    type: PoolEventType.terminated
     remainingQueue: Array<QueuedTask<ThreadType, any>>
   }
 

package/src/master/pool.ts

@@ -6,12 +6,13 @@
 /* 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,
@@ -223,10 +224,7 @@ class WorkerPool<ThreadType extends Thread> implements Pool<ThreadType> {
       return
     }
 
-    this.run(availableWorker, nextTask).catch((error) => {
-      this.debug('Error while running task:', error)
-      this.eventSubject.error(error)
-    })
+    this.run(availableWorker, nextTask)
   }
 
   private taskCompletion(taskID: number) {
@@ -261,7 +259,7 @@ class WorkerPool<ThreadType extends Thread> implements Pool<ThreadType> {
       throw this.initErrors[0]
     }
     if (allowResolvingImmediately && this.taskQueue.length === 0) {
-      await Promise.allSettled(getCurrentlyRunningTasks())
+      await allSettled(getCurrentlyRunningTasks())
       return taskFailures
     }
 
@@ -277,7 +275,7 @@ class WorkerPool<ThreadType extends Thread> implements Pool<ThreadType> {
       })
     })
 
-    await Promise.allSettled(getCurrentlyRunningTasks())
+    await allSettled(getCurrentlyRunningTasks())
     failureSubscription.unsubscribe()
 
     return taskFailures

package/src/ponyfills.ts

@@ -0,0 +1,31 @@
+/* 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)
+      }
+    }),
+  )
+}

package/src/types/master.ts

@@ -6,8 +6,6 @@
 // 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,
@@ -66,9 +64,11 @@ 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?: Transferable[]): void
+  postMessage(value: any, transferList?: TransferList): 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?: Transferable[]): void
+  postMessage(value: any, transferList?: TransferList): void
   terminate(): void | Promise<number>
 }
 
@@ -109,26 +109,24 @@ export interface ImplementationExport {
 }
 
 /** Event as emitted by worker thread. Subscribe to using `Thread.events(thread)`. */
-export const WorkerEventType = Enum({
-  internalError: 'internalError',
-  message: 'message',
-  termination: 'termination',
-})
-
-export type WorkerEventType = EnumValue<typeof WorkerEventType>
+export enum WorkerEventType {
+  internalError = 'internalError',
+  message = 'message',
+  termination = 'termination',
+}
 
 export interface WorkerInternalErrorEvent {
   error: Error
-  type: 'internalError'
+  type: WorkerEventType.internalError
 }
 
 export interface WorkerMessageEvent<Data> {
   data: Data
-  type: 'message'
+  type: WorkerEventType.message
 }
 
 export interface WorkerTerminationEvent {
-  type: 'termination'
+  type: WorkerEventType.termination
 }
 
 export type WorkerEvent = WorkerInternalErrorEvent | WorkerMessageEvent<any> | WorkerTerminationEvent

package/src/types/messages.ts

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

package/dist/enum.d.ts

@@ -1,5 +0,0 @@
-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

@@ -1,7 +0,0 @@
-"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

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

package/src/enum.ts

@@ -1,87 +0,0 @@
-/**
- * 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]