@xylabs/threads 4.7.1 → 4.7.3

package/test/pool.test.ts

@@ -1,183 +0,0 @@
-/* eslint-disable import-x/no-internal-modules */
-
-/* eslint-disable require-await */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-// eslint-disable import-x/no-internal-modules
-import { expect, test } from 'vitest'
-
-import type { FunctionThread } from '../src/index'
-import {
-  Pool, spawn, Worker,
-} from '../src/index'
-import type { PoolEvent, QueuedTask } from '../src/master/pool'
-import { PoolEventType } from '../src/master/pool'
-
-const workerPath = './workers/hello-world.ts'
-const HELLO_WORLD = 'Hello World'
-
-test('thread pool basics work and events are emitted', async () => {
-  const events: Pool.Event[] = []
-  let spawnCalled = 0
-  let taskFnCalled = 0
-
-  const spawnHelloWorld = () => {
-    spawnCalled++
-    return spawn<() => string>(new Worker(workerPath))
-  }
-
-  const pool = Pool(spawnHelloWorld, 3)
-  pool.events().subscribe(event => events.push(event))
-
-  // Ensure all worker threads are initialized before starting to queue tasks
-  await new Promise<PoolEvent<FunctionThread<[], string>>>((resolve, reject) => {
-    pool
-      .events()
-      .filter(event => event.type === Pool.EventType.initialized)
-      .subscribe(resolve, reject)
-  })
-
-  await pool.queue(async (helloWorld) => {
-    taskFnCalled++
-    const result = await helloWorld()
-    expect(result).toBe(HELLO_WORLD)
-    return result
-  })
-
-  await pool.terminate()
-
-  expect(spawnCalled).toBe(3)
-  expect(taskFnCalled).toBe(1)
-
-  expect(events).toEqual([
-    {
-      size: 3,
-      type: Pool.EventType.initialized,
-    },
-    {
-      taskID: 1,
-      type: Pool.EventType.taskQueued,
-    },
-    {
-      taskID: 1,
-      type: Pool.EventType.taskStart,
-      workerID: 1,
-    },
-    {
-      returnValue: HELLO_WORLD,
-      taskID: 1,
-      type: Pool.EventType.taskCompleted,
-      workerID: 1,
-    },
-    { type: Pool.EventType.taskQueueDrained },
-    {
-      remainingQueue: [],
-      type: Pool.EventType.terminated,
-    },
-  ])
-})
-
-test('pool.completed() works', async () => {
-  const returned: any[] = []
-
-  const spawnHelloWorld = () => spawn(new Worker(workerPath))
-  const pool = Pool(spawnHelloWorld, 2)
-
-  for (let i = 0; i < 3; i++) {
-    pool.queue(async (helloWorld) => {
-      returned.push(await helloWorld())
-    })
-  }
-
-  await pool.completed()
-
-  expect(returned).toEqual([HELLO_WORLD, HELLO_WORLD, HELLO_WORLD])
-})
-
-test('pool.completed() proxies errors', async () => {
-  const spawnHelloWorld = () => spawn(new Worker(workerPath))
-  const pool = Pool(spawnHelloWorld, 2)
-
-  pool.queue(async () => {
-    throw new Error('Ooopsie')
-  })
-
-  await expect(pool.completed()).rejects.toThrow('Ooopsie')
-})
-
-test('pool.completed(true) works', async () => {
-  const spawnHelloWorld = () => spawn(new Worker(workerPath))
-  const pool = Pool(spawnHelloWorld, 2)
-
-  await pool.completed(true)
-
-  expect(true).toBe(true) // Equivalent to t.pass() in Vitest
-})
-
-test('pool.settled() does not reject on task failure', async () => {
-  const returned: any[] = []
-
-  const spawnHelloWorld = () => spawn(new Worker(workerPath))
-  const pool = Pool(spawnHelloWorld, 2)
-
-  pool.queue(async (helloWorld) => {
-    returned.push(await helloWorld())
-  })
-  pool.queue(async () => {
-    throw new Error('Test error one')
-  })
-  pool.queue(async () => {
-    throw new Error('Test error two')
-  })
-
-  const errors = await pool.settled()
-
-  expect(errors.length).toBe(2)
-  expect(errors.map(error => error.message).sort()).toEqual(['Test error one', 'Test error two'])
-})
-
-test('pool.settled(true) works', async () => {
-  const spawnHelloWorld = () => spawn(new Worker(workerPath))
-  const pool = Pool(spawnHelloWorld, 2)
-
-  await pool.settled(true)
-
-  expect(true).toBe(true) // Equivalent to t.pass() in Vitest
-})
-
-test('task.cancel() works', async () => {
-  const events: Pool.Event[] = []
-  const spawnHelloWorld = () => spawn(new Worker(workerPath))
-  const pool = Pool(spawnHelloWorld, 1)
-
-  pool.events().subscribe(event => events.push(event))
-
-  let executionCount = 0
-  const tasks: QueuedTask<any, any>[] = []
-
-  for (let i = 0; i < 4; i++) {
-    const task = pool.queue((helloWorld) => {
-      executionCount++
-      return helloWorld()
-    })
-    tasks.push(task)
-  }
-
-  tasks[2].cancel()
-  tasks[3].cancel()
-
-  await pool.completed()
-  expect(executionCount).toBe(2)
-
-  const cancellationEvents = events.filter(event => event.type === PoolEventType.taskCanceled)
-  expect(cancellationEvents).toEqual([
-    {
-      taskID: 3,
-      type: PoolEventType.taskCanceled,
-    },
-    {
-      taskID: 4,
-      type: PoolEventType.taskCanceled,
-    },
-  ])
-})

package/test/serialization.test.ts

@@ -1,23 +0,0 @@
-/* eslint-disable import-x/no-internal-modules */
-import { expect, test } from 'vitest'
-
-import {
-  registerSerializer, spawn, Thread, Worker,
-} from '../src/index'
-import { Foo, fooSerializer } from './lib/serialization'
-
-registerSerializer(fooSerializer)
-
-test('can use a custom serializer', async () => {
-  const run = await spawn(new Worker('./workers/serialization.ts'))
-
-  try {
-    const input = new Foo('Test')
-    const result: Foo<string> = await run(input)
-
-    expect(result).toBeInstanceOf(Foo)
-    expect(result.getValue()).toBe('TestTest')
-  } finally {
-    await Thread.terminate(run)
-  }
-})

package/test/spawn.chromium.mocha.ts

@@ -1,53 +0,0 @@
-/* eslint-disable import-x/no-internal-modules */
-/* eslint-disable no-restricted-imports */
-/*
- * This code here will be run in a headless Chromium browser using `puppet-run`.
- * Check the package.json scripts `test:puppeteer:*`.
- */
-
-// We need this as a work-around to make our threads Worker global, since
-// the bundler would otherwise not recognize `new Worker()` as a web worker
-import '../src/master/register'
-
-import {
-  describe, expect, it,
-} from 'vitest'
-
-import {
-  BlobWorker, spawn, Thread,
-} from '..'
-
-describe('threads in browser', function () {
-  it('can spawn and terminate a thread', async function () {
-    const helloWorld = await spawn<() => string>(new Worker('./workers/hello-world.ts'))
-    expect(await helloWorld()).to.equal('Hello World')
-    await Thread.terminate(helloWorld)
-  })
-
-  it('can call a function thread more than once', async function () {
-    const increment = await spawn<() => number>(new Worker('./workers/increment.ts'))
-    expect(await increment()).to.equal(1)
-    expect(await increment()).to.equal(2)
-    expect(await increment()).to.equal(3)
-    await Thread.terminate(increment)
-  })
-
-  it('can spawn and use a blob worker', async function () {
-    const baseUrl = new URL(globalThis.location.href).origin
-    const workerSource = `
-      // Makes expose() available on global scope
-      importScripts(${JSON.stringify(baseUrl + '/worker.js')})
-
-      let counter = 0
-
-      expose(function() {
-        return ++counter
-      })
-    `
-    const increment = await spawn<() => number>(BlobWorker.fromText(workerSource))
-    expect(await increment()).to.equal(1)
-    expect(await increment()).to.equal(2)
-    expect(await increment()).to.equal(3)
-    await Thread.terminate(increment)
-  })
-})

package/test/spawn.test.ts

@@ -1,87 +0,0 @@
-/* eslint-disable import-x/no-internal-modules */
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-import { builtinModules } from 'node:module'
-
-import type { Observable } from 'observable-fns'
-import { expect, test } from 'vitest'
-
-import {
-  spawn, Thread, Worker,
-} from '../src/index'
-import type { Counter } from './workers/counter.ts'
-
-test('can spawn and terminate a thread', async () => {
-  // We also test here that running spawn() without type parameters works
-  const helloWorld = await spawn(new Worker('./workers/hello-world.ts'))
-
-  expect(await helloWorld()).toBe('Hello World')
-  await Thread.terminate(helloWorld)
-
-  expect(true).toBe(true) // Equivalent to t.pass() in Vitest
-})
-
-test('can call a function thread more than once', async () => {
-  const increment = await spawn<() => number>(new Worker('./workers/increment.ts'))
-
-  expect(await increment()).toBe(1)
-  expect(await increment()).toBe(2)
-  expect(await increment()).toBe(3)
-
-  await Thread.terminate(increment)
-})
-
-test('can subscribe to an observable returned by a thread call', async () => {
-  const countToFive = await spawn<() => Observable<number>>(new Worker('./workers/count-to-five.ts'))
-  const encounteredValues: any[] = []
-
-  const observable = countToFive()
-  observable.subscribe(value => encounteredValues.push(value))
-  await observable
-
-  expect(encounteredValues).toEqual([1, 2, 3, 4, 5])
-  await Thread.terminate(countToFive)
-})
-
-test('can spawn a module thread', async () => {
-  const counter = await spawn<Counter>(new Worker('./workers/counter.ts'))
-
-  expect(await counter.getCount()).toBe(0)
-
-  await Promise.all([counter.increment(), counter.increment()])
-  expect(await counter.getCount()).toBe(2)
-
-  await counter.decrement()
-  expect(await counter.getCount()).toBe(1)
-
-  await Thread.terminate(counter)
-})
-
-test('thread job errors are handled', async () => {
-  const fail = await spawn<() => Promise<never>>(new Worker('./workers/faulty-function.ts'))
-
-  await expect(fail()).rejects.toThrow('I am supposed to fail.')
-
-  await Thread.terminate(fail)
-})
-
-test('thread transfer errors are handled', async () => {
-  if (builtinModules.includes('worker_threads')) {
-    // Test is applicable only for native worker_threads
-    const helloWorld = await spawn(new Worker('./workers/hello-world.ts'))
-    const badTransferObj = { fn: () => {} }
-
-    await expect(helloWorld(badTransferObj)).rejects.toThrow()
-
-    await Thread.terminate(helloWorld)
-  } else {
-    expect(true).toBe(true) // Equivalent to t.pass() in Vitest
-  }
-})
-
-/* test('catches top-level thread errors', async () => {
-  await expect(spawn(new Worker('./workers/top-level-throw.ts'))).rejects.toThrow()
-}) */
-
-test.todo('can subscribe to thread events')

package/test/streaming.test.ts

@@ -1,29 +0,0 @@
-import { expect, test } from 'vitest'
-
-import {
-  spawn, Thread, Worker,
-} from '../src/index'
-
-test('can use worker returning an observable subject', async () => {
-  const captured: Array<{ max: number; min: number }> = []
-
-  const minmax = await spawn(new Worker('./workers/minmax.ts'))
-  minmax.values().subscribe(values => captured.push(values))
-
-  await minmax.push(2)
-  await minmax.push(3)
-  await minmax.push(4)
-  await minmax.push(1)
-  await minmax.push(5)
-  await minmax.finish()
-
-  await Thread.terminate(minmax)
-
-  expect(captured).toEqual([
-    { max: 2, min: 2 },
-    { max: 3, min: 2 },
-    { max: 4, min: 2 },
-    { max: 4, min: 1 },
-    { max: 5, min: 1 },
-  ])
-})

package/test/transferables.test.ts

@@ -1,71 +0,0 @@
-/* eslint-disable import-x/no-internal-modules */
-/* eslint-disable @typescript-eslint/no-unnecessary-type-constraint */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-import { expect, test } from 'vitest'
-
-import {
-  spawn, Thread, Transfer, Worker,
-} from '../src/index'
-import type { XorBuffer } from './workers/arraybuffer-xor.ts'
-
-type SpyInit<Args extends any[], OriginalReturn, NewReturn> = (originalFn: (...args: Args) => OriginalReturn) => (...args: Args) => NewReturn
-
-const arrayBufferPlaceholder = Symbol('ArrayBufferPlaceholder')
-
-function spyOn<Args extends any[], OriginalReturn, NewReturn>(
-  target: (...args: Args) => OriginalReturn,
-  spy: SpyInit<Args, OriginalReturn, NewReturn>,
-): (...args: Args) => NewReturn {
-  return spy(target)
-}
-
-function replaceArrayBufferWithPlaceholder<In extends any>(
-  obj: In,
-  arrayBuffer: ArrayBufferLike,
-): In extends ArrayBufferLike ? In | typeof arrayBufferPlaceholder : In {
-  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
-  } else if (obj && typeof obj === 'object') {
-    const result: In = Object.create(Object.getPrototypeOf(obj))
-
-    for (const key of Object.getOwnPropertyNames(obj)) {
-      (result as any)[key] = replaceArrayBufferWithPlaceholder((obj as any)[key], arrayBuffer)
-    }
-    return result as any
-  } else {
-    return obj as any
-  }
-}
-
-test('can pass transferable objects on thread call', async () => {
-  const testData = new ArrayBuffer(64)
-
-  const worker = new Worker('./workers/arraybuffer-xor.ts')
-  const postMessageCalls: Array<any[]> = []
-
-  worker.postMessage = spyOn(worker.postMessage.bind(worker), postMessage => (...args) => {
-    postMessageCalls.push(replaceArrayBufferWithPlaceholder(args, testData))
-    return postMessage(...args)
-  })
-
-  const xorBuffer = await spawn<XorBuffer>(worker)
-  const returnedBuffer = await xorBuffer(Transfer(testData), 15)
-
-  expect(returnedBuffer.byteLength).toBe(64)
-  expect(postMessageCalls.length).toBe(1)
-  expect(postMessageCalls[0].length).toBe(2)
-  expect(postMessageCalls[0][0]).toEqual({
-    args: [arrayBufferPlaceholder, 15],
-    method: undefined,
-    type: 'run',
-    uid: postMessageCalls[0][0].uid,
-  })
-  expect(postMessageCalls[0][1]).toEqual([arrayBufferPlaceholder])
-
-  await Thread.terminate(xorBuffer)
-})
-
-test.todo('can pass transferable objects as observable values')

package/test/workers/arraybuffer-xor.ts

@@ -1,10 +0,0 @@
-import { expose, Transfer } from '../../src/worker'
-
-function xor(buffer: ArrayBufferLike, value: number) {
-  const view = new Uint8Array(buffer)
-  for (const [offset, byte] of view.entries()) view.set([byte ^ value], offset)
-  return Transfer(buffer)
-}
-
-expose(xor)
-export type XorBuffer = typeof xor

package/test/workers/count-to-five.ts

@@ -1,12 +0,0 @@
-import { Observable } from 'observable-fns'
-
-import { expose } from '../../src/worker'
-
-expose(function countToFive() {
-  return new Observable((observer) => {
-    for (let counter = 1; counter <= 5; counter++) {
-      observer.next(counter)
-    }
-    observer.complete()
-  })
-})

package/test/workers/counter.ts

@@ -1,19 +0,0 @@
-import { expose } from '../../src/worker'
-
-let currentCount = 0
-
-const counter = {
-  decrement() {
-    return --currentCount
-  },
-  getCount() {
-    return currentCount
-  },
-  increment() {
-    return ++currentCount
-  },
-}
-
-expose(counter)
-
-export type Counter = typeof counter

package/test/workers/faulty-function.ts

@@ -1,5 +0,0 @@
-import { expose } from '../../src/worker'
-
-expose(function fail() {
-  throw new Error('I am supposed to fail.')
-})

package/test/workers/hello-world.ts

@@ -1,5 +0,0 @@
-import { expose } from '../../src/worker'
-
-expose(function helloWorld() {
-  return 'Hello World'
-})

package/test/workers/increment.ts

@@ -1,8 +0,0 @@
-import { expose } from '../../src/worker'
-
-let counter = 0
-
-expose(function increment(by: number = 1) {
-  counter += by
-  return counter
-})

package/test/workers/minmax.ts

@@ -1,25 +0,0 @@
-// eslint-disable-next-line import-x/no-internal-modules
-import { Observable, Subject } from '../../src/observable'
-import { expose } from '../../src/worker'
-
-let max = Number.NEGATIVE_INFINITY
-let min = Number.POSITIVE_INFINITY
-
-let subject = new Subject()
-
-const minmax = {
-  finish() {
-    subject.complete()
-    subject = new Subject()
-  },
-  push(value) {
-    max = Math.max(max, value)
-    min = Math.min(min, value)
-    subject.next({ max, min })
-  },
-  values() {
-    return Observable.from(subject)
-  },
-}
-
-expose(minmax)

package/test/workers/serialization.ts

@@ -1,13 +0,0 @@
-/* eslint-disable import-x/no-internal-modules */
-/* eslint-disable require-await */
-
-import { expose, registerSerializer } from '../../src/worker'
-import { Foo, fooSerializer } from '../lib/serialization'
-
-registerSerializer(fooSerializer)
-
-async function run(foo: Foo<string>) {
-  return new Foo(foo.getValue() + foo.getValue())
-}
-
-expose(run)

package/test/workers/top-level-throw.ts

@@ -1 +0,0 @@
-throw new Error('Top-level worker error')

package/test-tooling/rollup/app.js

@@ -1,21 +0,0 @@
-/* eslint-disable no-restricted-imports */
-import {
-  spawn, Thread, Worker,
-} from '../..'
-
-async function run() {
-  const add = await spawn(new Worker('./worker.js'))
-  const result = await add(2, 3)
-  await Thread.terminate(add)
-  return result
-}
-
-run()
-  .then((result) => {
-    console.log(`Result: ${result}`)
-    puppet.exit(0)
-  })
-  .catch((error) => {
-    console.error(error)
-    puppet.exit(1)
-  })

package/test-tooling/rollup/rollup.config.ts

@@ -1,14 +0,0 @@
-import commonjs from '@rollup/plugin-commonjs'
-import { nodeResolve } from '@rollup/plugin-node-resolve'
-
-export default {
-  plugins: [
-    nodeResolve({
-      browser: true,
-      mainFields: ['module', 'main'],
-      preferBuiltins: true,
-    }),
-
-    commonjs(),
-  ],
-}

package/test-tooling/rollup/worker.js

@@ -1,7 +0,0 @@
-/* eslint-disable require-await */
-
-import { expose } from '../../dist/esm/worker'
-
-expose(async function add(a, b) {
-  return a + b
-})

package/test-tooling/tsconfig/minimal.ts

@@ -1,12 +0,0 @@
-/* eslint-disable no-restricted-imports */
-/* eslint-disable @typescript-eslint/no-floating-promises */
-import {
-  spawn, Thread, Worker,
-} from '../..'
-
-async function main() {
-  const helloWorld = await spawn(new Worker('./workers/hello-world.ts'))
-  await Thread.terminate(helloWorld)
-}
-
-main()

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

@@ -1,9 +0,0 @@
-import { expose, isWorkerRuntime } from '../../src/worker'
-
-if (!isWorkerRuntime()) {
-  throw new Error('isWorkerRuntime() says we are not in a worker.')
-}
-
-expose(function add(a: number, b: number) {
-  return a + b
-})

package/test-tooling/webpack/app-with-inlined-worker.ts

@@ -1,28 +0,0 @@
-/* eslint-disable import-x/no-unresolved */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-/// <reference types="./raw-loader" />
-
-import AdditionWorkerNodeBundle from 'raw-loader!./dist/addition-worker.node/worker.js'
-import AdditionWorkerWebBundle from 'raw-loader!./dist/addition-worker.web/worker.js'
-
-import { BlobWorker, spawn } from '../../src/index'
-
-const AdditionWorkerBundle = (process as any).browser ? AdditionWorkerWebBundle : AdditionWorkerNodeBundle
-type AdditionWorker = (a: number, b: number) => number
-
-async function test() {
-  // We also want to test if referencing multiple different workers in a module
-  // built using webpack works
-
-  const add = await spawn<AdditionWorker>(BlobWorker.fromText(AdditionWorkerBundle))
-  const result = await add(2, 3)
-
-  if (result !== 5) {
-    throw new Error('Unexpected result returned by addition worker: ' + result)
-  }
-
-  return 'test succeeded'
-}
-
-export default test