@xylabs/threads 3.6.6 → 3.6.8

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

@@ -1,3 +1,4 @@
+/* eslint-disable import/no-internal-modules */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-floating-promises */
 import DebugLogger from 'debug'
@@ -27,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')
@@ -38,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
@@ -121,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/master/thread.ts

@@ -1,3 +1,4 @@
+/* eslint-disable import/no-internal-modules */
 import { Observable } from 'observable-fns'
 
 import { $errors, $events, $terminate } from '../symbols'

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/serializers.ts

@@ -1,3 +1,4 @@
+/* eslint-disable import/no-internal-modules */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { SerializedError } from './types/messages'
 

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.browser.ts

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

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

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

package/src/worker/implementation.ts

@@ -1,3 +1,4 @@
+/* eslint-disable import/no-internal-modules */
 // tslint:disable no-var-requires
 /*
  * This file is only a stub to make './implementation' resolve to the right module.

package/src/worker/implementation.worker_threads.ts

@@ -1,3 +1,4 @@
+/* eslint-disable import/no-internal-modules */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 // tslint:disable no-shadowed-variable
 import { MessagePort } from 'node:worker_threads'

package/src/worker/index.ts

@@ -1,3 +1,4 @@
+/* eslint-disable import/no-internal-modules */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-floating-promises */
 import isSomeObservable from 'is-observable-2-1-0'
@@ -130,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)
@@ -181,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,11 +1,11 @@
-/* eslint-disable sonarjs/no-duplicate-string */
+/* eslint-disable import/no-internal-modules */
 /* 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)
@@ -42,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])
 })
@@ -103,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++,
     )
@@ -130,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++,
     )
   }
@@ -160,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

@@ -1,3 +1,4 @@
+/* eslint-disable import/no-internal-modules */
 /* eslint-disable require-await */
 
 import test from 'ava'
@@ -16,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),
   )
@@ -58,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,4 +1,5 @@
-/* eslint-disable @typescript-eslint/no-floating-promises */
+/* eslint-disable import/no-internal-modules */
+
 /* eslint-disable require-await */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
@@ -21,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)
   })
 
@@ -111,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))
@@ -129,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) => {
@@ -145,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>[] = []
@@ -164,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/serialization.test.ts

@@ -1,3 +1,4 @@
+/* eslint-disable import/no-internal-modules */
 import test from 'ava'
 
 import { registerSerializer, spawn, Thread, Worker } from '../src/index'

package/test/spawn.chromium.mocha.ts

@@ -1,3 +1,4 @@
+/* eslint-disable import/no-internal-modules */
 /* eslint-disable no-restricted-imports */
 /*
  * This code here will be run in a headless Chromium browser using `puppet-run`.

package/test/spawn.test.ts

@@ -1,4 +1,5 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
+/* eslint-disable import/no-internal-modules */
+
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import test from 'ava'
 import { Observable } from 'observable-fns'
@@ -27,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])
@@ -51,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

@@ -1,3 +1,4 @@
+/* eslint-disable import/no-internal-modules */
 /* eslint-disable @typescript-eslint/no-unnecessary-type-constraint */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
@@ -24,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))
 
@@ -43,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/workers/minmax.ts

@@ -1,3 +1,4 @@
+/* eslint-disable import/no-internal-modules */
 import { Observable, Subject } from '../../src/observable'
 import { expose } from '../../src/worker'
 

package/test/workers/serialization.ts

@@ -1,3 +1,4 @@
+/* eslint-disable import/no-internal-modules */
 /* eslint-disable require-await */
 
 import { expose, registerSerializer } from '../../src/worker'

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.node.config.js

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
 const path = require('node:path')
 const ThreadsPlugin = require('threads-plugin')