@xylabs/threads 3.3.2 → 3.4.0

package/dist/master/pool.js

@@ -145,7 +145,7 @@ class WorkerPool {
                 }
                 else if (event.type === pool_types_1.PoolEventType.terminated) {
                     eventSubscription.unsubscribe();
-                    reject(Error('Pool has been terminated before task was run.'));
+                    reject(new Error('Pool has been terminated before task was run.'));
                 }
             });
         });

package/dist/master/spawn.js

@@ -24,7 +24,7 @@ const initMessageTimeout = typeof process !== 'undefined' && process.env !== und
 async function withTimeout(promise, timeoutInMs, errorMessage) {
     let timeoutHandle;
     const timeout = new Promise((resolve, reject) => {
-        timeoutHandle = setTimeout(() => reject(Error(errorMessage)), timeoutInMs);
+        timeoutHandle = setTimeout(() => reject(new Error(errorMessage)), timeoutInMs);
     });
     const result = await Promise.race([promise, timeout]);
     clearTimeout(timeoutHandle);
@@ -58,7 +58,7 @@ function createEventObservable(worker, workerTermination) {
         const rejectionHandler = ((errorEvent) => {
             debugThreadUtils('Unhandled promise rejection event in thread:', errorEvent);
             const workerEvent = {
-                error: Error(errorEvent.reason),
+                error: new Error(errorEvent.reason),
                 type: master_1.WorkerEventType.internalError,
             };
             observer.next(workerEvent);

package/dist/serializers.js

@@ -16,7 +16,7 @@ function extendSerializer(extend, implementation) {
 exports.extendSerializer = extendSerializer;
 const DefaultErrorSerializer = {
     deserialize(message) {
-        return Object.assign(Error(message.message), {
+        return Object.assign(new Error(message.message), {
             name: message.name,
             stack: message.stack,
         });

package/dist-esm/master/pool.js

@@ -139,7 +139,7 @@ class WorkerPool {
                 }
                 else if (event.type === PoolEventType.terminated) {
                     eventSubscription.unsubscribe();
-                    reject(Error('Pool has been terminated before task was run.'));
+                    reject(new Error('Pool has been terminated before task was run.'));
                 }
             });
         });

package/dist-esm/master/spawn.js

@@ -18,7 +18,7 @@ const initMessageTimeout = typeof process !== 'undefined' && process.env !== und
 async function withTimeout(promise, timeoutInMs, errorMessage) {
     let timeoutHandle;
     const timeout = new Promise((resolve, reject) => {
-        timeoutHandle = setTimeout(() => reject(Error(errorMessage)), timeoutInMs);
+        timeoutHandle = setTimeout(() => reject(new Error(errorMessage)), timeoutInMs);
     });
     const result = await Promise.race([promise, timeout]);
     clearTimeout(timeoutHandle);
@@ -52,7 +52,7 @@ function createEventObservable(worker, workerTermination) {
         const rejectionHandler = ((errorEvent) => {
             debugThreadUtils('Unhandled promise rejection event in thread:', errorEvent);
             const workerEvent = {
-                error: Error(errorEvent.reason),
+                error: new Error(errorEvent.reason),
                 type: WorkerEventType.internalError,
             };
             observer.next(workerEvent);

package/dist-esm/serializers.js

@@ -12,7 +12,7 @@ export function extendSerializer(extend, implementation) {
 }
 const DefaultErrorSerializer = {
     deserialize(message) {
-        return Object.assign(Error(message.message), {
+        return Object.assign(new Error(message.message), {
             name: message.name,
             stack: message.stack,
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xylabs/threads",
-  "version": "3.3.2",
+  "version": "3.4.0",
   "description": "Web workers & worker threads as simple as a function call",
   "license": "MIT",
   "main": "dist/index.js",
@@ -67,36 +67,36 @@
   ],
   "dependencies": {
     "@babel/types": "^7.24.5",
-    "callsites": "^3.1.0",
+    "callsites": "^4.1.0",
     "debug": "^4.3.4",
-    "is-observable": "^2.1.0",
+    "is-observable": "^3.0.0",
     "observable-fns": "^0.6.1"
   },
   "devDependencies": {
-    "@rollup/plugin-commonjs": "^16.0.0",
-    "@rollup/plugin-node-resolve": "^10.0.0",
+    "@rollup/plugin-commonjs": "^25.0.8",
+    "@rollup/plugin-node-resolve": "^15.2.3",
     "@types/chai": "^4.3.16",
     "@types/debug": "^4.1.12",
     "@types/execa": "^2.0.0",
-    "@types/node": "^20.12.8",
-    "@types/webpack": "^4.41.38",
-    "ava": "^3.15.0",
-    "chai": "^4.4.1",
+    "@types/node": "^20.12.12",
+    "@types/webpack": "^5.28.5",
+    "ava": "^6.1.3",
+    "chai": "^5.1.1",
     "cross-env": "^7.0.3",
-    "execa": "^4.1.0",
-    "mocha": "^8.4.0",
+    "execa": "^9.1.0",
+    "mocha": "^10.4.0",
     "puppet-run": "^0.11.4",
-    "puppet-run-plugin-mocha": "^0.10.0-alpha",
+    "puppet-run-plugin-mocha": "^0.1.1",
     "raw-loader": "^4.0.2",
-    "rimraf": "^3.0.2",
-    "rollup": "^2.79.1",
+    "rimraf": "^5.0.7",
+    "rollup": "^4.18.0",
     "threads-plugin": "^1.4.0",
     "tiny-worker": "^2.3.0",
-    "ts-loader": "^8.4.0",
-    "ts-node": "^9.1.1",
+    "ts-loader": "^9.5.1",
+    "ts-node": "^10.9.2",
     "typescript": "^5.4.5",
     "wavy": "^1.0.4",
-    "webpack": "^4.47.0",
+    "webpack": "^5.91.0",
     "worker-plugin": "^5.0.1"
   },
   "optionalDependencies": {

package/src/master/pool.ts

@@ -232,7 +232,7 @@ class WorkerPool<ThreadType extends Thread> implements Pool<ThreadType> {
           reject(event.error)
         } else if (event.type === PoolEventType.terminated) {
           eventSubscription.unsubscribe()
-          reject(Error('Pool has been terminated before task was run.'))
+          reject(new Error('Pool has been terminated before task was run.'))
         }
       })
     })

package/src/master/spawn.ts

@@ -47,7 +47,7 @@ async function withTimeout<T>(promise: Promise<T>, timeoutInMs: number, errorMes
   let timeoutHandle: any
 
   const timeout = new Promise<never>((resolve, reject) => {
-    timeoutHandle = setTimeout(() => reject(Error(errorMessage)), timeoutInMs)
+    timeoutHandle = setTimeout(() => reject(new Error(errorMessage)), timeoutInMs)
   })
   const result = await Promise.race([promise, timeout])
 
@@ -83,7 +83,7 @@ function createEventObservable(worker: WorkerType, workerTermination: Promise<an
     const rejectionHandler = ((errorEvent: PromiseRejectionEvent) => {
       debugThreadUtils('Unhandled promise rejection event in thread:', errorEvent)
       const workerEvent: WorkerInternalErrorEvent = {
-        error: Error(errorEvent.reason),
+        error: new Error(errorEvent.reason),
         type: WorkerEventType.internalError,
       }
       observer.next(workerEvent)

package/src/serializers.ts

@@ -39,7 +39,7 @@ export type JsonSerializable = JsonSerializablePrimitive | JsonSerializablePrimi
 
 const DefaultErrorSerializer: Serializer<SerializedError, Error> = {
   deserialize(message: SerializedError): Error {
-    return Object.assign(Error(message.message), {
+    return Object.assign(new Error(message.message), {
       name: message.name,
       stack: message.stack,
     })

package/test/observable-promise.test.ts

@@ -53,7 +53,7 @@ test('can proxy a promise rejection', async (t) => {
   let handlerCallCount = 0
 
   const async = new ObservablePromise((observer) => {
-    setTimeout(() => observer.error(Error('I am supposed to be rejected.')), 1)
+    setTimeout(() => observer.error(new Error('I am supposed to be rejected.')), 1)
   })
 
   const promise1 = async.then(
@@ -123,7 +123,7 @@ test('can subscribe to errors', async (t) => {
 
   const async = new ObservablePromise((observer) => {
     setTimeout(() => observer.next(1), 10)
-    setTimeout(() => observer.error(Error('Fails as expected.')), 20)
+    setTimeout(() => observer.error(new Error('Fails as expected.')), 20)
     setTimeout(() => observer.next(2), 30)
     setTimeout(() => observer.complete(), 40)
   })
@@ -152,7 +152,7 @@ test('from(Observable) works', async (t) => {
   const async = ObservablePromise.from(
     new Observable((observer) => {
       setTimeout(() => observer.next(1), 10)
-      setTimeout(() => observer.error(Error('Fails as expected.')), 20)
+      setTimeout(() => observer.error(new Error('Fails as expected.')), 20)
       setTimeout(() => observer.next(2), 30)
       setTimeout(() => observer.complete(), 40)
     }),
@@ -182,7 +182,7 @@ test('from(Promise) works', async (t) => {
   )
   t.is(await resolved, 'Works')
 
-  const rejected = ObservablePromise.from(Promise.reject(Error('Fails')))
+  const rejected = ObservablePromise.from(Promise.reject(new Error('Fails')))
   const error = await t.throwsAsync(rejected)
 
   t.is(error.message, 'Fails')

package/test/observable.test.ts

@@ -72,7 +72,7 @@ test('Observable subject propagates errors', async (t) => {
     () => (completed3 = true),
   )
 
-  const testingError = Error('Test, test!')
+  const testingError = new Error('Test, test!')
 
   subscription1.unsubscribe()
   subject.error(testingError)