@xylabs/threads 3.6.7 → 3.6.9

package/dist/esm/master/implementation.browser.js

@@ -29,9 +29,9 @@ function selectWorkerImplementation() {
                     url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`);
                 }
             }
-            if (typeof url === 'string' &&
-                isAbsoluteURL(url) &&
-                (options?.CORSWorkaround ?? true)) {
+            if (typeof url === 'string'
+                && isAbsoluteURL(url)
+                && (options?.CORSWorkaround ?? true)) {
                 url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`);
             }
             super(url, options);

package/dist/esm/master/implementation.node.js

@@ -56,8 +56,8 @@ function resolveScriptPath(scriptPath, baseURL) {
     const makeRelative = (filePath) => {
         return node_path_1.default.isAbsolute(filePath) ? filePath : node_path_1.default.join(baseURL || eval('__dirname'), filePath);
     };
-    return typeof __non_webpack_require__ === 'function' ?
-        __non_webpack_require__.resolve(makeRelative(scriptPath))
+    return typeof __non_webpack_require__ === 'function'
+        ? __non_webpack_require__.resolve(makeRelative(scriptPath))
         : eval('require').resolve(makeRelative(rebaseScriptPath(scriptPath, /[/\\]worker_threads[/\\]/)));
 }
 function initWorkerThreadsWorker() {
@@ -96,7 +96,7 @@ function initWorkerThreadsWorker() {
         }
     }
     const terminateWorkersAndMaster = () => {
-        Promise.all(allWorkers.map((worker) => worker.terminate())).then(() => process.exit(0), () => process.exit(1));
+        Promise.all(allWorkers.map(worker => worker.terminate())).then(() => process.exit(0), () => process.exit(1));
         allWorkers = [];
     };
     process.on('SIGINT', () => terminateWorkersAndMaster());
@@ -120,8 +120,10 @@ function initTinyWorker() {
     class Worker extends TinyWorker {
         emitter;
         constructor(scriptPath, options) {
-            const resolvedScriptPath = options && options.fromSource ? null
-                : process.platform === 'win32' ? `file:///${resolveScriptPath(scriptPath).replaceAll('\\', '/')}`
+            const resolvedScriptPath = options && options.fromSource
+                ? null
+                : process.platform === 'win32'
+                    ? `file:///${resolveScriptPath(scriptPath).replaceAll('\\', '/')}`
                     : resolveScriptPath(scriptPath);
             if (!resolvedScriptPath) {
                 const sourceCode = scriptPath;
@@ -148,12 +150,12 @@ function initTinyWorker() {
             this.emitter.removeListener(eventName, listener);
         }
         terminate() {
-            allWorkers = allWorkers.filter((worker) => worker !== this);
+            allWorkers = allWorkers.filter(worker => worker !== this);
             return super.terminate();
         }
     }
     const terminateWorkersAndMaster = () => {
-        Promise.all(allWorkers.map((worker) => worker.terminate())).then(() => process.exit(0), () => process.exit(1));
+        Promise.all(allWorkers.map(worker => worker.terminate())).then(() => process.exit(0), () => process.exit(1));
         allWorkers = [];
     };
     process.on('SIGINT', () => terminateWorkersAndMaster());
@@ -195,8 +197,8 @@ function isWorkerRuntime() {
         return self !== undefined && self['postMessage'] ? true : false;
     }
     else {
-        const isMainThread = typeof __non_webpack_require__ === 'function' ?
-            __non_webpack_require__('worker_threads').isMainThread
+        const isMainThread = typeof __non_webpack_require__ === 'function'
+            ? __non_webpack_require__('worker_threads').isMainThread
             : eval('require')('worker_threads').isMainThread;
         return !isMainThread;
     }

package/dist/esm/master/pool.js

@@ -19,7 +19,7 @@ function createArray(size) {
     return array;
 }
 function delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+    return new Promise(resolve => setTimeout(resolve, ms));
 }
 function flatMap(array, mapper) {
     return array.reduce((flattened, element) => [...flattened, ...mapper(element)], []);
@@ -51,7 +51,7 @@ class WorkerPool {
         this.options = options;
         this.workers = spawnWorkers(spawnWorker, size);
         this.eventObservable = (0, observable_fns_1.multicast)(observable_fns_1.Observable.from(this.eventSubject));
-        Promise.all(this.workers.map((worker) => worker.init)).then(() => this.eventSubject.next({
+        Promise.all(this.workers.map(worker => worker.init)).then(() => this.eventSubject.next({
             size: this.workers.length,
             type: pool_types_1.PoolEventType.initialized,
         }), (error) => {
@@ -62,7 +62,7 @@ class WorkerPool {
     }
     findIdlingWorker() {
         const { concurrency = 1 } = this.options;
-        return this.workers.find((worker) => worker.runningTasks.length < concurrency);
+        return this.workers.find(worker => worker.runningTasks.length < concurrency);
     }
     async runPoolTask(worker, task) {
         const workerID = this.workers.indexOf(worker) + 1;
@@ -95,7 +95,7 @@ class WorkerPool {
     async run(worker, task) {
         const runPromise = (async () => {
             const removeTaskFromWorkersRunningTasks = () => {
-                worker.runningTasks = worker.runningTasks.filter((someRunPromise) => someRunPromise !== runPromise);
+                worker.runningTasks = worker.runningTasks.filter(someRunPromise => someRunPromise !== runPromise);
             };
             await delay(0);
             try {
@@ -142,7 +142,7 @@ class WorkerPool {
         });
     }
     async settled(allowResolvingImmediately = false) {
-        const getCurrentlyRunningTasks = () => flatMap(this.workers, (worker) => worker.runningTasks);
+        const getCurrentlyRunningTasks = () => flatMap(this.workers, worker => worker.runningTasks);
         const taskFailures = [];
         const failureSubscription = this.eventObservable.subscribe((event) => {
             if (event.type === pool_types_1.PoolEventType.taskFailed) {
@@ -213,7 +213,7 @@ class WorkerPool {
             cancel: () => {
                 if (!this.taskQueue.includes(task))
                     return;
-                this.taskQueue = this.taskQueue.filter((someTask) => someTask !== task);
+                this.taskQueue = this.taskQueue.filter(someTask => someTask !== task);
                 this.eventSubject.next({
                     taskID: task.id,
                     type: pool_types_1.PoolEventType.taskCanceled,
@@ -224,9 +224,9 @@ class WorkerPool {
             then: taskCompletion.then.bind(taskCompletion),
         };
         if (this.taskQueue.length >= maxQueuedJobs) {
-            throw new Error('Maximum number of pool tasks queued. Refusing to queue another one.\n' +
-                'This usually happens for one of two reasons: We are either at peak ' +
-                "workload right now or some tasks just won't finish, thus blocking the pool.");
+            throw new Error('Maximum number of pool tasks queued. Refusing to queue another one.\n'
+                + 'This usually happens for one of two reasons: We are either at peak '
+                + "workload right now or some tasks just won't finish, thus blocking the pool.");
         }
         this.debug(`Queueing task #${task.id}...`);
         this.taskQueue.push(task);

package/dist/esm/master/spawn.js

@@ -16,8 +16,8 @@ const debugSpawn = (0, debug_1.default)('threads:master:spawn');
 const debugThreadUtils = (0, debug_1.default)('threads:master:thread-utils');
 const isInitMessage = (data) => data && data.type === 'init';
 const isUncaughtErrorMessage = (data) => data && data.type === 'uncaughtError';
-const initMessageTimeout = typeof process !== 'undefined' && process.env !== undefined && process.env.THREADS_WORKER_INIT_TIMEOUT ?
-    Number.parseInt(process.env.THREADS_WORKER_INIT_TIMEOUT, 10)
+const initMessageTimeout = typeof process !== 'undefined' && process.env !== undefined && process.env.THREADS_WORKER_INIT_TIMEOUT
+    ? Number.parseInt(process.env.THREADS_WORKER_INIT_TIMEOUT, 10)
     : 10_000;
 async function withTimeout(promise, timeoutInMs, errorMessage) {
     let timeoutHandle;
@@ -85,8 +85,8 @@ function createTerminator(worker) {
 }
 function setPrivateThreadProps(raw, worker, workerEvents, terminate) {
     const workerErrors = workerEvents
-        .filter((event) => event.type === master_1.WorkerEventType.internalError)
-        .map((errorEvent) => errorEvent.error);
+        .filter(event => event.type === master_1.WorkerEventType.internalError)
+        .map(errorEvent => errorEvent.error);
     return Object.assign(raw, {
         [symbols_1.$errors]: workerErrors,
         [symbols_1.$events]: workerEvents,

package/dist/esm/observable-promise.js

@@ -115,8 +115,8 @@ class ObservablePromise extends observable_fns_1.Observable {
         }, () => handler());
     }
     static from(thing) {
-        return isThenable(thing) ?
-            new ObservablePromise((observer) => {
+        return isThenable(thing)
+            ? new ObservablePromise((observer) => {
                 const onFulfilled = (value) => {
                     observer.next(value);
                     observer.complete();

package/dist/esm/observable.js

@@ -9,7 +9,7 @@ class Subject extends observable_fns_1.Observable {
         super((observer) => {
             this[$observers] = [...(this[$observers] || []), observer];
             const unsubscribe = () => {
-                this[$observers] = this[$observers].filter((someObserver) => someObserver !== observer);
+                this[$observers] = this[$observers].filter(someObserver => someObserver !== observer);
             };
             return unsubscribe;
         });

package/dist/esm/worker/index.js

@@ -95,7 +95,7 @@ async function runFunction(jobUID, fn, args) {
     const resultType = isObservable(syncResult) ? 'observable' : 'promise';
     postJobStartMessage(jobUID, resultType);
     if (isObservable(syncResult)) {
-        const subscription = syncResult.subscribe((value) => postJobResultMessage(jobUID, false, (0, common_1.serialize)(value)), (error) => {
+        const subscription = syncResult.subscribe(value => postJobResultMessage(jobUID, false, (0, common_1.serialize)(value)), (error) => {
             postJobErrorMessage(jobUID, (0, common_1.serialize)(error));
             activeSubscriptions.delete(jobUID);
         }, () => {
@@ -136,7 +136,7 @@ function expose(exposed) {
                 runFunction(messageData.uid, exposed[messageData.method], messageData.args.map(common_1.deserialize));
             }
         });
-        const methodNames = Object.keys(exposed).filter((key) => typeof exposed[key] === 'function');
+        const methodNames = Object.keys(exposed).filter(key => typeof exposed[key] === 'function');
         postModuleInitMessage(methodNames);
     }
     else {

package/dist/master/implementation.browser.js

@@ -29,9 +29,9 @@ function selectWorkerImplementation() {
                     url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`);
                 }
             }
-            if (typeof url === 'string' &&
-                isAbsoluteURL(url) &&
-                (options?.CORSWorkaround ?? true)) {
+            if (typeof url === 'string'
+                && isAbsoluteURL(url)
+                && (options?.CORSWorkaround ?? true)) {
                 url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`);
             }
             super(url, options);

package/dist/master/implementation.node.js

@@ -56,8 +56,8 @@ function resolveScriptPath(scriptPath, baseURL) {
     const makeRelative = (filePath) => {
         return node_path_1.default.isAbsolute(filePath) ? filePath : node_path_1.default.join(baseURL || eval('__dirname'), filePath);
     };
-    return typeof __non_webpack_require__ === 'function' ?
-        __non_webpack_require__.resolve(makeRelative(scriptPath))
+    return typeof __non_webpack_require__ === 'function'
+        ? __non_webpack_require__.resolve(makeRelative(scriptPath))
         : eval('require').resolve(makeRelative(rebaseScriptPath(scriptPath, /[/\\]worker_threads[/\\]/)));
 }
 function initWorkerThreadsWorker() {
@@ -96,7 +96,7 @@ function initWorkerThreadsWorker() {
         }
     }
     const terminateWorkersAndMaster = () => {
-        Promise.all(allWorkers.map((worker) => worker.terminate())).then(() => process.exit(0), () => process.exit(1));
+        Promise.all(allWorkers.map(worker => worker.terminate())).then(() => process.exit(0), () => process.exit(1));
         allWorkers = [];
     };
     process.on('SIGINT', () => terminateWorkersAndMaster());
@@ -120,8 +120,10 @@ function initTinyWorker() {
     class Worker extends TinyWorker {
         emitter;
         constructor(scriptPath, options) {
-            const resolvedScriptPath = options && options.fromSource ? null
-                : process.platform === 'win32' ? `file:///${resolveScriptPath(scriptPath).replaceAll('\\', '/')}`
+            const resolvedScriptPath = options && options.fromSource
+                ? null
+                : process.platform === 'win32'
+                    ? `file:///${resolveScriptPath(scriptPath).replaceAll('\\', '/')}`
                     : resolveScriptPath(scriptPath);
             if (!resolvedScriptPath) {
                 const sourceCode = scriptPath;
@@ -148,12 +150,12 @@ function initTinyWorker() {
             this.emitter.removeListener(eventName, listener);
         }
         terminate() {
-            allWorkers = allWorkers.filter((worker) => worker !== this);
+            allWorkers = allWorkers.filter(worker => worker !== this);
             return super.terminate();
         }
     }
     const terminateWorkersAndMaster = () => {
-        Promise.all(allWorkers.map((worker) => worker.terminate())).then(() => process.exit(0), () => process.exit(1));
+        Promise.all(allWorkers.map(worker => worker.terminate())).then(() => process.exit(0), () => process.exit(1));
         allWorkers = [];
     };
     process.on('SIGINT', () => terminateWorkersAndMaster());
@@ -195,8 +197,8 @@ function isWorkerRuntime() {
         return self !== undefined && self['postMessage'] ? true : false;
     }
     else {
-        const isMainThread = typeof __non_webpack_require__ === 'function' ?
-            __non_webpack_require__('worker_threads').isMainThread
+        const isMainThread = typeof __non_webpack_require__ === 'function'
+            ? __non_webpack_require__('worker_threads').isMainThread
             : eval('require')('worker_threads').isMainThread;
         return !isMainThread;
     }

package/dist/master/pool.js

@@ -19,7 +19,7 @@ function createArray(size) {
     return array;
 }
 function delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+    return new Promise(resolve => setTimeout(resolve, ms));
 }
 function flatMap(array, mapper) {
     return array.reduce((flattened, element) => [...flattened, ...mapper(element)], []);
@@ -51,7 +51,7 @@ class WorkerPool {
         this.options = options;
         this.workers = spawnWorkers(spawnWorker, size);
         this.eventObservable = (0, observable_fns_1.multicast)(observable_fns_1.Observable.from(this.eventSubject));
-        Promise.all(this.workers.map((worker) => worker.init)).then(() => this.eventSubject.next({
+        Promise.all(this.workers.map(worker => worker.init)).then(() => this.eventSubject.next({
             size: this.workers.length,
             type: pool_types_1.PoolEventType.initialized,
         }), (error) => {
@@ -62,7 +62,7 @@ class WorkerPool {
     }
     findIdlingWorker() {
         const { concurrency = 1 } = this.options;
-        return this.workers.find((worker) => worker.runningTasks.length < concurrency);
+        return this.workers.find(worker => worker.runningTasks.length < concurrency);
     }
     async runPoolTask(worker, task) {
         const workerID = this.workers.indexOf(worker) + 1;
@@ -95,7 +95,7 @@ class WorkerPool {
     async run(worker, task) {
         const runPromise = (async () => {
             const removeTaskFromWorkersRunningTasks = () => {
-                worker.runningTasks = worker.runningTasks.filter((someRunPromise) => someRunPromise !== runPromise);
+                worker.runningTasks = worker.runningTasks.filter(someRunPromise => someRunPromise !== runPromise);
             };
             await delay(0);
             try {
@@ -142,7 +142,7 @@ class WorkerPool {
         });
     }
     async settled(allowResolvingImmediately = false) {
-        const getCurrentlyRunningTasks = () => flatMap(this.workers, (worker) => worker.runningTasks);
+        const getCurrentlyRunningTasks = () => flatMap(this.workers, worker => worker.runningTasks);
         const taskFailures = [];
         const failureSubscription = this.eventObservable.subscribe((event) => {
             if (event.type === pool_types_1.PoolEventType.taskFailed) {
@@ -213,7 +213,7 @@ class WorkerPool {
             cancel: () => {
                 if (!this.taskQueue.includes(task))
                     return;
-                this.taskQueue = this.taskQueue.filter((someTask) => someTask !== task);
+                this.taskQueue = this.taskQueue.filter(someTask => someTask !== task);
                 this.eventSubject.next({
                     taskID: task.id,
                     type: pool_types_1.PoolEventType.taskCanceled,
@@ -224,9 +224,9 @@ class WorkerPool {
             then: taskCompletion.then.bind(taskCompletion),
         };
         if (this.taskQueue.length >= maxQueuedJobs) {
-            throw new Error('Maximum number of pool tasks queued. Refusing to queue another one.\n' +
-                'This usually happens for one of two reasons: We are either at peak ' +
-                "workload right now or some tasks just won't finish, thus blocking the pool.");
+            throw new Error('Maximum number of pool tasks queued. Refusing to queue another one.\n'
+                + 'This usually happens for one of two reasons: We are either at peak '
+                + "workload right now or some tasks just won't finish, thus blocking the pool.");
         }
         this.debug(`Queueing task #${task.id}...`);
         this.taskQueue.push(task);

package/dist/master/spawn.js

@@ -16,8 +16,8 @@ const debugSpawn = (0, debug_1.default)('threads:master:spawn');
 const debugThreadUtils = (0, debug_1.default)('threads:master:thread-utils');
 const isInitMessage = (data) => data && data.type === 'init';
 const isUncaughtErrorMessage = (data) => data && data.type === 'uncaughtError';
-const initMessageTimeout = typeof process !== 'undefined' && process.env !== undefined && process.env.THREADS_WORKER_INIT_TIMEOUT ?
-    Number.parseInt(process.env.THREADS_WORKER_INIT_TIMEOUT, 10)
+const initMessageTimeout = typeof process !== 'undefined' && process.env !== undefined && process.env.THREADS_WORKER_INIT_TIMEOUT
+    ? Number.parseInt(process.env.THREADS_WORKER_INIT_TIMEOUT, 10)
     : 10_000;
 async function withTimeout(promise, timeoutInMs, errorMessage) {
     let timeoutHandle;
@@ -85,8 +85,8 @@ function createTerminator(worker) {
 }
 function setPrivateThreadProps(raw, worker, workerEvents, terminate) {
     const workerErrors = workerEvents
-        .filter((event) => event.type === master_1.WorkerEventType.internalError)
-        .map((errorEvent) => errorEvent.error);
+        .filter(event => event.type === master_1.WorkerEventType.internalError)
+        .map(errorEvent => errorEvent.error);
     return Object.assign(raw, {
         [symbols_1.$errors]: workerErrors,
         [symbols_1.$events]: workerEvents,

package/dist/observable-promise.js

@@ -115,8 +115,8 @@ class ObservablePromise extends observable_fns_1.Observable {
         }, () => handler());
     }
     static from(thing) {
-        return isThenable(thing) ?
-            new ObservablePromise((observer) => {
+        return isThenable(thing)
+            ? new ObservablePromise((observer) => {
                 const onFulfilled = (value) => {
                     observer.next(value);
                     observer.complete();

package/dist/observable.js

@@ -9,7 +9,7 @@ class Subject extends observable_fns_1.Observable {
         super((observer) => {
             this[$observers] = [...(this[$observers] || []), observer];
             const unsubscribe = () => {
-                this[$observers] = this[$observers].filter((someObserver) => someObserver !== observer);
+                this[$observers] = this[$observers].filter(someObserver => someObserver !== observer);
             };
             return unsubscribe;
         });

package/dist/worker/index.js

@@ -95,7 +95,7 @@ async function runFunction(jobUID, fn, args) {
     const resultType = isObservable(syncResult) ? 'observable' : 'promise';
     postJobStartMessage(jobUID, resultType);
     if (isObservable(syncResult)) {
-        const subscription = syncResult.subscribe((value) => postJobResultMessage(jobUID, false, (0, common_1.serialize)(value)), (error) => {
+        const subscription = syncResult.subscribe(value => postJobResultMessage(jobUID, false, (0, common_1.serialize)(value)), (error) => {
             postJobErrorMessage(jobUID, (0, common_1.serialize)(error));
             activeSubscriptions.delete(jobUID);
         }, () => {
@@ -136,7 +136,7 @@ function expose(exposed) {
                 runFunction(messageData.uid, exposed[messageData.method], messageData.args.map(common_1.deserialize));
             }
         });
-        const methodNames = Object.keys(exposed).filter((key) => typeof exposed[key] === 'function');
+        const methodNames = Object.keys(exposed).filter(key => typeof exposed[key] === 'function');
         postModuleInitMessage(methodNames);
     }
     else {

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@xylabs/threads",
-  "version": "3.6.7",
+  "version": "3.6.9",
   "description": "Web workers & worker threads as simple as a function call",
   "license": "MIT",
   "main": "dist/index.js",
   "module": "dist/esm/index.js",
   "scripts": {
     "package-compile": "yarn build",
-    "clean": "rimraf dist/ dist-esm/",
+    "clean": "rimraf ./dist ./dist-esm",
     "dev": "npm run clean && tsc -p tsconfig.json --watch",
     "build": "npm run clean && npm run build:cjs && npm run build:es",
     "build:cjs": "tsc -p tsconfig.json",
@@ -105,8 +105,8 @@
     "puppet-run": "^0.11.4",
     "puppet-run-plugin-mocha": "^0.1.1",
     "raw-loader": "^4.0.2",
-    "rimraf": "^4.4.1",
-    "rollup": "^4.19.2",
+    "rimraf": "^5.0.10",
+    "rollup": "^4.20.0",
     "threads-plugin": "^1.4.0",
     "tiny-worker": "^2.3.0",
     "ts-loader": "^9.5.1",

package/src/master/implementation.browser.ts

@@ -37,10 +37,10 @@ function selectWorkerImplementation(): ImplementationExport {
         }
       }
       if (
-        typeof url === 'string' &&
-        isAbsoluteURL(url) && // Create source code blob loading JS file via `importScripts()`
+        typeof url === 'string'
+        && isAbsoluteURL(url) // Create source code blob loading JS file via `importScripts()`
         // to circumvent worker CORS restrictions
-        (options?.CORSWorkaround ?? true)
+        && (options?.CORSWorkaround ?? true)
       ) {
         url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`)
       }

package/src/master/implementation.node.ts

@@ -1,9 +1,9 @@
+/* eslint-disable @typescript-eslint/no-require-imports */
 /* eslint-disable import/no-internal-modules */
 /* eslint-disable unicorn/no-process-exit */
-/* eslint-disable sonarjs/no-identical-functions */
 /* eslint-disable unicorn/prefer-logical-operator-over-ternary */
 /* eslint-disable unicorn/prefer-regexp-test */
-/* eslint-disable @typescript-eslint/no-var-requires */
+
 /* eslint-disable unicorn/prefer-add-event-listener */
 /* eslint-disable unicorn/prefer-event-target */
 /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -86,15 +86,15 @@ function resolveScriptPath(scriptPath: string, baseURL?: string | undefined) {
     return path.isAbsolute(filePath) ? filePath : path.join(baseURL || eval('__dirname'), filePath)
   }
 
-  return typeof __non_webpack_require__ === 'function' ?
-      __non_webpack_require__.resolve(makeRelative(scriptPath))
+  return typeof __non_webpack_require__ === 'function'
+    ? __non_webpack_require__.resolve(makeRelative(scriptPath))
     : eval('require').resolve(makeRelative(rebaseScriptPath(scriptPath, /[/\\]worker_threads[/\\]/)))
 }
 
 function initWorkerThreadsWorker(): ImplementationExport {
   // Webpack hack
-  const NativeWorker =
-    typeof __non_webpack_require__ === 'function' ? __non_webpack_require__('worker_threads').Worker : eval('require')('worker_threads').Worker
+  const NativeWorker
+    = typeof __non_webpack_require__ === 'function' ? __non_webpack_require__('worker_threads').Worker : eval('require')('worker_threads').Worker
 
   let allWorkers: Array<typeof NativeWorker> = []
 
@@ -137,7 +137,7 @@ function initWorkerThreadsWorker(): ImplementationExport {
 
   const terminateWorkersAndMaster = () => {
     // we should terminate all workers and then gracefully shutdown self process
-    Promise.all(allWorkers.map((worker) => worker.terminate())).then(
+    Promise.all(allWorkers.map(worker => worker.terminate())).then(
       () => process.exit(0),
       () => process.exit(1),
     )
@@ -175,10 +175,12 @@ function initTinyWorker(): ImplementationExport {
     constructor(scriptPath: string, options?: ThreadsWorkerOptions & { fromSource?: boolean }) {
       // Need to apply a work-around for Windows or it will choke upon the absolute path
       // (`Error [ERR_INVALID_PROTOCOL]: Protocol 'c:' not supported`)
-      const resolvedScriptPath =
-        options && options.fromSource ? null
-        : process.platform === 'win32' ? `file:///${resolveScriptPath(scriptPath).replaceAll('\\', '/')}`
-        : resolveScriptPath(scriptPath)
+      const resolvedScriptPath
+        = options && options.fromSource
+          ? null
+          : process.platform === 'win32'
+            ? `file:///${resolveScriptPath(scriptPath).replaceAll('\\', '/')}`
+            : resolveScriptPath(scriptPath)
 
       if (!resolvedScriptPath) {
         // `options.fromSource` is true
@@ -209,14 +211,14 @@ function initTinyWorker(): ImplementationExport {
     }
 
     terminate() {
-      allWorkers = allWorkers.filter((worker) => worker !== this)
+      allWorkers = allWorkers.filter(worker => worker !== this)
       return super.terminate()
     }
   }
 
   const terminateWorkersAndMaster = () => {
     // we should terminate all workers and then gracefully shutdown self process
-    Promise.all(allWorkers.map((worker) => worker.terminate())).then(
+    Promise.all(allWorkers.map(worker => worker.terminate())).then(
       () => process.exit(0),
       () => process.exit(1),
     )
@@ -271,10 +273,10 @@ export function isWorkerRuntime() {
     return self !== undefined && self['postMessage'] ? true : false
   } else {
     // Webpack hack
-    const isMainThread =
-      typeof __non_webpack_require__ === 'function' ?
-        __non_webpack_require__('worker_threads').isMainThread
-      : eval('require')('worker_threads').isMainThread
+    const isMainThread
+      = typeof __non_webpack_require__ === 'function'
+        ? __non_webpack_require__('worker_threads').isMainThread
+        : eval('require')('worker_threads').isMainThread
     return !isMainThread
   }
 }

package/src/master/invocation-proxy.ts

@@ -1,5 +1,4 @@
 /* eslint-disable import/no-internal-modules */
-/* eslint-disable sonarjs/no-all-duplicated-branches */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /*
  * This source file contains the code for proxying calls in the master thread to calls in the workers

package/src/master/pool-types.ts

@@ -19,41 +19,41 @@ export type TaskRunFunction<ThreadType extends Thread, Return> = (worker: Thread
 /** Pool event. Subscribe to those events using `pool.events()`. Useful for debugging. */
 export type PoolEvent<ThreadType extends Thread> =
   | {
-      type: PoolEventType.initialized
-      size: number
-    }
+    type: PoolEventType.initialized
+    size: number
+  }
   | {
-      type: PoolEventType.taskQueued
-      taskID: number
-    }
+    type: PoolEventType.taskQueued
+    taskID: number
+  }
   | {
-      type: PoolEventType.taskQueueDrained
-    }
+    type: PoolEventType.taskQueueDrained
+  }
   | {
-      type: PoolEventType.taskStart
-      taskID: number
-      workerID: number
-    }
+    type: PoolEventType.taskStart
+    taskID: number
+    workerID: number
+  }
   | {
-      type: PoolEventType.taskCompleted
-      returnValue: any
-      taskID: number
-      workerID: number
-    }
+    type: PoolEventType.taskCompleted
+    returnValue: any
+    taskID: number
+    workerID: number
+  }
   | {
-      type: PoolEventType.taskFailed
-      error: Error
-      taskID: number
-      workerID: number
-    }
+    type: PoolEventType.taskFailed
+    error: Error
+    taskID: number
+    workerID: number
+  }
   | {
-      type: PoolEventType.taskCanceled
-      taskID: number
-    }
+    type: PoolEventType.taskCanceled
+    taskID: number
+  }
   | {
-      type: PoolEventType.terminated
-      remainingQueue: Array<QueuedTask<ThreadType, any>>
-    }
+    type: PoolEventType.terminated
+    remainingQueue: Array<QueuedTask<ThreadType, any>>
+  }
 
 export interface WorkerDescriptor<ThreadType extends Thread> {
   init: Promise<ThreadType>

package/src/master/pool.ts

@@ -31,7 +31,7 @@ function createArray(size: number): number[] {
 }
 
 function delay(ms: number) {
-  return new Promise((resolve) => setTimeout(resolve, ms))
+  return new Promise(resolve => setTimeout(resolve, ms))
 }
 
 function flatMap<In, Out>(array: In[], mapper: (element: In) => Out[]): Out[] {
@@ -133,7 +133,7 @@ class WorkerPool<ThreadType extends Thread> implements Pool<ThreadType> {
 
     this.eventObservable = multicast(Observable.from(this.eventSubject))
 
-    Promise.all(this.workers.map((worker) => worker.init)).then(
+    Promise.all(this.workers.map(worker => worker.init)).then(
       () =>
         this.eventSubject.next({
           size: this.workers.length,
@@ -149,7 +149,7 @@ class WorkerPool<ThreadType extends Thread> implements Pool<ThreadType> {
 
   private findIdlingWorker(): WorkerDescriptor<ThreadType> | undefined {
     const { concurrency = 1 } = this.options
-    return this.workers.find((worker) => worker.runningTasks.length < concurrency)
+    return this.workers.find(worker => worker.runningTasks.length < concurrency)
   }
 
   private async runPoolTask(worker: WorkerDescriptor<ThreadType>, task: QueuedTask<ThreadType, any>) {
@@ -186,7 +186,7 @@ class WorkerPool<ThreadType extends Thread> implements Pool<ThreadType> {
   private async run(worker: WorkerDescriptor<ThreadType>, task: QueuedTask<ThreadType, any>) {
     const runPromise = (async () => {
       const removeTaskFromWorkersRunningTasks = () => {
-        worker.runningTasks = worker.runningTasks.filter((someRunPromise) => someRunPromise !== runPromise)
+        worker.runningTasks = worker.runningTasks.filter(someRunPromise => someRunPromise !== runPromise)
       }
 
       // Defer task execution by one tick to give handlers time to subscribe
@@ -240,7 +240,7 @@ class WorkerPool<ThreadType extends Thread> implements Pool<ThreadType> {
   }
 
   async settled(allowResolvingImmediately: boolean = false): Promise<Error[]> {
-    const getCurrentlyRunningTasks = () => flatMap(this.workers, (worker) => worker.runningTasks)
+    const getCurrentlyRunningTasks = () => flatMap(this.workers, worker => worker.runningTasks)
 
     const taskFailures: Error[] = []
 
@@ -327,7 +327,7 @@ class WorkerPool<ThreadType extends Thread> implements Pool<ThreadType> {
     const task: QueuedTask<ThreadType, any> = {
       cancel: () => {
         if (!this.taskQueue.includes(task)) return
-        this.taskQueue = this.taskQueue.filter((someTask) => someTask !== task)
+        this.taskQueue = this.taskQueue.filter(someTask => someTask !== task)
         this.eventSubject.next({
           taskID: task.id,
           type: PoolEventType.taskCanceled,
@@ -340,9 +340,9 @@ class WorkerPool<ThreadType extends Thread> implements Pool<ThreadType> {
 
     if (this.taskQueue.length >= maxQueuedJobs) {
       throw new Error(
-        'Maximum number of pool tasks queued. Refusing to queue another one.\n' +
-          'This usually happens for one of two reasons: We are either at peak ' +
-          "workload right now or some tasks just won't finish, thus blocking the pool.",
+        'Maximum number of pool tasks queued. Refusing to queue another one.\n'
+        + 'This usually happens for one of two reasons: We are either at peak '
+        + "workload right now or some tasks just won't finish, thus blocking the pool.",
       )
     }
 
@@ -368,7 +368,7 @@ class WorkerPool<ThreadType extends Thread> implements Pool<ThreadType> {
       type: PoolEventType.terminated,
     })
     this.eventSubject.complete()
-    await Promise.all(this.workers.map(async (worker) => Thread.terminate(await worker.init)))
+    await Promise.all(this.workers.map(async worker => Thread.terminate(await worker.init)))
   }
 }
 

package/src/master/spawn.ts

@@ -28,9 +28,9 @@ type ArbitraryThreadType = FunctionThread<any, any> & ModuleThread<any>
 
 export type ExposedToThreadType<Exposed extends WorkerFunction | WorkerModule<any>> =
   Exposed extends ArbitraryWorkerInterface ? ArbitraryThreadType
-  : Exposed extends WorkerFunction ? FunctionThread<Parameters<Exposed>, StripAsync<ReturnType<Exposed>>>
-  : Exposed extends WorkerModule<any> ? ModuleThread<Exposed>
-  : never
+    : Exposed extends WorkerFunction ? FunctionThread<Parameters<Exposed>, StripAsync<ReturnType<Exposed>>>
+      : Exposed extends WorkerModule<any> ? ModuleThread<Exposed>
+        : never
 
 const debugMessages = DebugLogger('threads:master:messages')
 const debugSpawn = DebugLogger('threads:master:spawn')
@@ -39,10 +39,10 @@ const debugThreadUtils = DebugLogger('threads:master:thread-utils')
 const isInitMessage = (data: any): data is WorkerInitMessage => data && data.type === ('init' as const)
 const isUncaughtErrorMessage = (data: any): data is WorkerUncaughtErrorMessage => data && data.type === ('uncaughtError' as const)
 
-const initMessageTimeout =
-  typeof process !== 'undefined' && process.env !== undefined && process.env.THREADS_WORKER_INIT_TIMEOUT ?
-    Number.parseInt(process.env.THREADS_WORKER_INIT_TIMEOUT, 10)
-  : 10_000
+const initMessageTimeout
+  = typeof process !== 'undefined' && process.env !== undefined && process.env.THREADS_WORKER_INIT_TIMEOUT
+    ? Number.parseInt(process.env.THREADS_WORKER_INIT_TIMEOUT, 10)
+    : 10_000
 
 async function withTimeout<T>(promise: Promise<T>, timeoutInMs: number, errorMessage: string): Promise<T> {
   let timeoutHandle: any
@@ -122,8 +122,8 @@ function setPrivateThreadProps<T>(
   terminate: () => Promise<void>,
 ): T & PrivateThreadProps {
   const workerErrors = workerEvents
-    .filter((event) => event.type === WorkerEventType.internalError)
-    .map((errorEvent) => (errorEvent as WorkerInternalErrorEvent).error)
+    .filter(event => event.type === WorkerEventType.internalError)
+    .map(errorEvent => (errorEvent as WorkerInternalErrorEvent).error)
 
   return Object.assign(raw as any, {
     [$errors]: workerErrors,

package/src/observable-promise.ts

@@ -166,17 +166,17 @@ export class ObservablePromise<T> extends Observable<T> implements Promise<T> {
   }
 
   static from<T>(thing: Observable<T> | ObservableLike<T> | ArrayLike<T> | Thenable<T>): ObservablePromise<T> {
-    return isThenable(thing) ?
-        new ObservablePromise((observer) => {
-          const onFulfilled = (value: T) => {
-            observer.next(value)
-            observer.complete()
-          }
-          const onRejected = (error: any) => {
-            observer.error(error)
-          }
-          thing.then(onFulfilled, onRejected)
-        })
+    return isThenable(thing)
+      ? new ObservablePromise((observer) => {
+        const onFulfilled = (value: T) => {
+          observer.next(value)
+          observer.complete()
+        }
+        const onRejected = (error: any) => {
+          observer.error(error)
+        }
+        thing.then(onFulfilled, onRejected)
+      })
       : (super.from(thing) as ObservablePromise<T>)
   }
 }

package/src/observable.ts

@@ -1,4 +1,3 @@
-/* eslint-disable sonarjs/prefer-immediate-return */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Observable, ObservableLike, SubscriptionObserver } from 'observable-fns'
 
@@ -20,7 +19,7 @@ export class Subject<T> extends Observable<T> implements ObservableLike<T> {
     super((observer) => {
       this[$observers] = [...(this[$observers] || []), observer]
       const unsubscribe = () => {
-        this[$observers] = this[$observers].filter((someObserver) => someObserver !== observer)
+        this[$observers] = this[$observers].filter(someObserver => someObserver !== observer)
       }
       return unsubscribe
     })

package/src/ponyfills.ts

@@ -1,13 +1,13 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 export type SettlementResult<T> =
   | {
-      status: 'fulfilled'
-      value: T
-    }
+    status: 'fulfilled'
+    value: T
+  }
   | {
-      reason: any
-      status: 'rejected'
-    }
+    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>>> {

package/src/transferable.ts

@@ -1,4 +1,3 @@
-/* eslint-disable sonarjs/prefer-single-boolean-return */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { $transferable } from './symbols'
 

package/src/types/master.ts

@@ -20,8 +20,8 @@ interface ObservableLike<T> {
 
 export type StripAsync<Type> =
   Type extends Promise<infer PromiseBaseType> ? PromiseBaseType
-  : Type extends ObservableLike<infer ObservableBaseType> ? ObservableBaseType
-  : Type
+    : Type extends ObservableLike<infer ObservableBaseType> ? ObservableBaseType
+      : Type
 
 export type StripTransfer<Type> = Type extends TransferDescriptor<infer BaseType> ? BaseType : Type
 
@@ -32,7 +32,7 @@ export type ProxyableArgs<Args extends any[]> =
 
 export type ProxyableFunction<Args extends any[], ReturnType> =
   Args extends [] ? () => ObservablePromise<StripTransfer<StripAsync<ReturnType>>>
-  : (...args: ProxyableArgs<Args>) => ObservablePromise<StripTransfer<StripAsync<ReturnType>>>
+    : (...args: ProxyableArgs<Args>) => ObservablePromise<StripTransfer<StripAsync<ReturnType>>>
 
 export type ModuleProxy<Methods extends ModuleMethods> = {
   [method in keyof Methods]: ProxyableFunction<Parameters<Methods[method]>, ReturnType<Methods[method]>>
@@ -55,6 +55,7 @@ interface AnyFunctionThread extends PrivateThreadProps {
 }
 
 // tslint:disable-next-line no-empty-interface
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
 interface AnyModuleThread extends PrivateThreadProps {
   // Not specifying an index signature here as that would make `ModuleThread` incompatible
 }

package/src/worker/implementation.tiny-worker.ts

@@ -1,5 +1,4 @@
 /* eslint-disable import/no-internal-modules */
-/* eslint-disable sonarjs/prefer-immediate-return */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /// <reference lib="dom" />
 // tslint:disable no-shadowed-variable

package/src/worker/index.ts

@@ -131,7 +131,7 @@ async function runFunction(jobUID: number, fn: WorkerFunction, args: any[]) {
 
   if (isObservable(syncResult)) {
     const subscription = syncResult.subscribe(
-      (value) => postJobResultMessage(jobUID, false, serialize(value)),
+      value => postJobResultMessage(jobUID, false, serialize(value)),
       (error) => {
         postJobErrorMessage(jobUID, serialize(error) as any)
         activeSubscriptions.delete(jobUID)
@@ -182,7 +182,7 @@ export function expose(exposed: WorkerFunction | WorkerModule<any>) {
       }
     })
 
-    const methodNames = Object.keys(exposed).filter((key) => typeof exposed[key] === 'function')
+    const methodNames = Object.keys(exposed).filter(key => typeof exposed[key] === 'function')
     postModuleInitMessage(methodNames)
   } else {
     throw new Error(`Invalid argument passed to expose(). Expected a function or an object, got: ${exposed}`)

package/test/lib/serialization.ts

@@ -28,8 +28,8 @@ export const fooSerializer: SerializerImplementation = {
   },
 
   serialize(data, fallback) {
-    return data instanceof Foo ?
-        {
+    return data instanceof Foo
+      ? {
           __type: '$$foo',
           val: data.getValue(),
         }

package/test/observable-promise.test.ts

@@ -1,12 +1,11 @@
 /* eslint-disable import/no-internal-modules */
-/* eslint-disable sonarjs/no-duplicate-string */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import test from 'ava'
 import { Observable } from 'observable-fns'
 
 import { ObservablePromise } from '../src/observable-promise'
 
-const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
+const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
 
 test('can create an observable promise', async (t) => {
   t.plan(1)
@@ -43,9 +42,9 @@ test('can proxy a promise fulfillment', async (t) => {
     }, 1)
   })
 
-  const promise1 = async.then((value) => t.is(value, 123), t.fail)
+  const promise1 = async.then(value => t.is(value, 123), t.fail)
   await delay(10)
-  const promise2 = async.then((value) => t.is(value, 123), t.fail)
+  const promise2 = async.then(value => t.is(value, 123), t.fail)
 
   await Promise.all([promise1, promise2])
 })
@@ -104,7 +103,7 @@ test('can subscribe to values and completion', async (t) => {
 
   for (let index = 0; index < 2; index++) {
     async.subscribe(
-      (value) => capturedValues.push(value),
+      value => capturedValues.push(value),
       () => {},
       () => capturedCompletions++,
     )
@@ -131,8 +130,8 @@ test('can subscribe to errors', async (t) => {
 
   for (let index = 0; index < 2; index++) {
     async.subscribe(
-      (value) => capturedValues.push(value),
-      (error) => capturedErrorMessages.push(error.message),
+      value => capturedValues.push(value),
+      error => capturedErrorMessages.push(error.message),
       () => capturedCompletions++,
     )
   }
@@ -161,8 +160,8 @@ test('from(Observable) works', async (t) => {
 
   for (let index = 0; index < 2; index++) {
     async.subscribe(
-      (value) => capturedValues.push(value),
-      (error) => capturedErrorMessages.push(error.message),
+      value => capturedValues.push(value),
+      error => capturedErrorMessages.push(error.message),
       () => capturedCompletions++,
     )
   }

package/test/observable.test.ts

@@ -17,17 +17,17 @@ test('Observable subject emits values and completion event', async (t) => {
   const observable = Observable.from(subject)
 
   const subscription1 = subject.subscribe(
-    (value) => values1.push(value),
+    value => values1.push(value),
     undefined,
     () => (completed1 = true),
   )
   subject.subscribe(
-    (value) => values2.push(value),
+    value => values2.push(value),
     undefined,
     () => (completed2 = true),
   )
   observable.subscribe(
-    (value) => values3.push(value),
+    value => values3.push(value),
     undefined,
     () => (completed3 = true),
   )
@@ -59,17 +59,17 @@ test('Observable subject propagates errors', async (t) => {
 
   const subscription1 = subject.subscribe(
     () => {},
-    (error) => (error1 = error),
+    error => (error1 = error),
     () => (completed1 = true),
   )
   subject.subscribe(
     () => {},
-    (error) => (error2 = error),
+    error => (error2 = error),
     () => (completed2 = true),
   )
   observable.subscribe(
     () => {},
-    (error) => (error3 = error),
+    error => (error3 = error),
     () => (completed3 = true),
   )
 

package/test/pool.test.ts

@@ -1,5 +1,5 @@
 /* eslint-disable import/no-internal-modules */
-/* eslint-disable @typescript-eslint/no-floating-promises */
+
 /* eslint-disable require-await */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
@@ -22,14 +22,14 @@ test.serial('thread pool basics work and events are emitted', async (t) => {
     return spawn<() => string>(new Worker(workerPath))
   }
   const pool = Pool(spawnHelloWorld, 3)
-  pool.events().subscribe((event) => events.push(event))
+  pool.events().subscribe(event => events.push(event))
 
   // Just to make sure all worker threads are initialized before starting to queue
   // This is only necessary for testing to make sure that this is the first event recorded
   await new Promise((resolve, reject) => {
     pool
       .events()
-      .filter((event) => event.type === PoolEventType.initialized)
+      .filter(event => event.type === PoolEventType.initialized)
       .subscribe(resolve, reject)
   })
 
@@ -112,7 +112,6 @@ test.serial('pool.completed(true) works', async (t) => {
 })
 
 test.serial('pool.settled() does not reject on task failure', async (t) => {
-  // eslint-disable-next-line sonarjs/no-unused-collection
   const returned: any[] = []
 
   const spawnHelloWorld = () => spawn(new Worker(workerPath))
@@ -130,7 +129,7 @@ test.serial('pool.settled() does not reject on task failure', async (t) => {
 
   const errors = await pool.settled()
   t.is(errors.length, 2)
-  t.deepEqual(errors.map((error) => error.message).sort(), ['Test error one', 'Test error two'])
+  t.deepEqual(errors.map(error => error.message).sort(), ['Test error one', 'Test error two'])
 })
 
 test.serial('pool.settled(true) works', async (t) => {
@@ -146,7 +145,7 @@ test.serial('task.cancel() works', async (t) => {
   const spawnHelloWorld = () => spawn(new Worker(workerPath))
   const pool = Pool(spawnHelloWorld, 1)
 
-  pool.events().subscribe((event) => events.push(event))
+  pool.events().subscribe(event => events.push(event))
 
   let executionCount = 0
   const tasks: QueuedTask<any, any>[] = []
@@ -165,7 +164,7 @@ test.serial('task.cancel() works', async (t) => {
   await pool.completed()
   t.is(executionCount, 2)
 
-  const cancellationEvents = events.filter((event) => event.type === 'taskCanceled')
+  const cancellationEvents = events.filter(event => event.type === 'taskCanceled')
   t.deepEqual(cancellationEvents, [
     {
       taskID: 3,

package/test/spawn.test.ts

@@ -1,5 +1,5 @@
 /* eslint-disable import/no-internal-modules */
-/* eslint-disable @typescript-eslint/no-var-requires */
+
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import test from 'ava'
 import { Observable } from 'observable-fns'
@@ -28,7 +28,7 @@ test('can subscribe to an observable returned by a thread call', async (t) => {
   const encounteredValues: any[] = []
 
   const observable = countToFive()
-  observable.subscribe((value) => encounteredValues.push(value))
+  observable.subscribe(value => encounteredValues.push(value))
   await observable
 
   t.deepEqual(encounteredValues, [1, 2, 3, 4, 5])
@@ -52,6 +52,7 @@ test('thread job errors are handled', async (t) => {
 })
 
 test('thread transfer errors are handled', async (t) => {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
   const builtin = require('node:module').builtinModules
   if (builtin.includes('worker_threads')) {
     // test is actual for native worker_threads only

package/test/streaming.test.ts

@@ -6,7 +6,7 @@ test('can use worker returning an observable subject', async (t) => {
   const captured: Array<{ max: number; min: number }> = []
 
   const minmax = await spawn(new Worker('./workers/minmax'))
-  minmax.values().subscribe((values) => captured.push(values))
+  minmax.values().subscribe(values => captured.push(values))
 
   await minmax.push(2)
   await minmax.push(3)

package/test/transferables.test.ts

@@ -25,7 +25,7 @@ function replaceArrayBufferWithPlaceholder<In extends any>(
   if ((obj as any) === arrayBuffer) {
     return arrayBufferPlaceholder as any
   } else if (Array.isArray(obj)) {
-    return (obj as any[]).map((element) => replaceArrayBufferWithPlaceholder(element, arrayBuffer)) as any
+    return (obj as any[]).map(element => replaceArrayBufferWithPlaceholder(element, arrayBuffer)) as any
   } else if (obj && typeof obj === 'object') {
     const result: In = Object.create(Object.getPrototypeOf(obj))
 
@@ -44,7 +44,7 @@ test('can pass transferable objects on thread call', async (t) => {
   const worker = new Worker('./workers/arraybuffer-xor')
   const postMessageCalls: Array<any[]> = []
 
-  worker.postMessage = spyOn(worker.postMessage.bind(worker), (postMessage) => (...args) => {
+  worker.postMessage = spyOn(worker.postMessage.bind(worker), postMessage => (...args) => {
     postMessageCalls.push(replaceArrayBufferWithPlaceholder(args, testData))
     return postMessage(...args)
   })

package/test-tooling/webpack/app.ts

@@ -1,4 +1,3 @@
-/* eslint-disable sonarjs/no-use-of-empty-return-value */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import { isWorkerRuntime, Pool, spawn, Worker } from '../../src/index'
@@ -9,10 +8,10 @@ type HelloWorker = (text: string) => string
 async function test() {
   const pool = Pool(() => spawn<HelloWorker>(new Worker('./pool-worker')))
   const results = await Promise.all([
-    pool.queue((hello) => hello('World')),
-    pool.queue((hello) => hello('World')),
-    pool.queue((hello) => hello('World')),
-    pool.queue((hello) => hello('World')),
+    pool.queue(hello => hello('World')),
+    pool.queue(hello => hello('World')),
+    pool.queue(hello => hello('World')),
+    pool.queue(hello => hello('World')),
   ])
   await pool.terminate()
 

package/test-tooling/webpack/webpack.chromium.mocha.ts

@@ -1,4 +1,4 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
+/* eslint-disable @typescript-eslint/no-require-imports */
 // NOTE:
 // We are gonna test the bundles previously built by the AVA tests (see webpack.test.ts)
 

package/test-tooling/webpack/webpack.test.ts

@@ -1,6 +1,8 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions */
+/* eslint-disable @typescript-eslint/no-require-imports */
 /* eslint-disable require-await */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-var-requires */
+
 import path from 'node:path'
 
 import test from 'ava'
@@ -10,16 +12,20 @@ const browserConfig = require('./webpack.web.config')
 const serverConfig = require('./webpack.node.config')
 
 const stringifyWebpackError = (error: any) =>
-  error ?
-    typeof error.stack === 'string' ? error.stack
-    : typeof error.message === 'string' ? error.message
-    : error
-  : ''
+  error
+    ? typeof error.stack === 'string'
+      ? error.stack
+      : typeof error.message === 'string'
+        ? error.message
+        : error
+    : ''
 
 async function runWebpack(config: any) {
   return new Promise<Webpack.Stats>((resolve, reject) => {
     Webpack(config).run((error, stats) => {
-      error ? reject(error) : resolve(stats)
+      if (stats) {
+        error ? reject(error) : resolve(stats)
+      }
     })
   })
 }