@xylabs/threads 3.0.4

package/test/transferables.test.ts

@@ -0,0 +1,69 @@
+/* eslint-disable @typescript-eslint/no-unnecessary-type-constraint */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable import/no-internal-modules */
+import test from 'ava'
+
+import { spawn, Thread, Transfer, Worker } from '../src/index'
+import { XorBuffer } from './workers/arraybuffer-xor'
+
+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: ArrayBuffer,
+): In extends ArrayBuffer ? 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 (t) => {
+  const testData = new ArrayBuffer(64)
+
+  const worker = new Worker('./workers/arraybuffer-xor')
+  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)
+
+  t.is(returnedBuffer.byteLength, 64)
+
+  t.is(postMessageCalls.length, 1)
+  t.is(postMessageCalls[0].length, 2)
+  t.deepEqual(postMessageCalls[0][0], {
+    args: [arrayBufferPlaceholder, 15],
+    method: undefined,
+    type: 'run',
+    uid: postMessageCalls[0][0].uid,
+  })
+  t.deepEqual(postMessageCalls[0][1], [arrayBufferPlaceholder])
+
+  await Thread.terminate(xorBuffer)
+})
+
+test.todo('can pass transferable objects as observable values')

package/test/workers/arraybuffer-xor.ts

@@ -0,0 +1,11 @@
+/* eslint-disable import/no-internal-modules */
+import { expose, Transfer } from '../../src/worker'
+
+function xor(buffer: ArrayBuffer, 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

@@ -0,0 +1,13 @@
+/* eslint-disable import/no-internal-modules */
+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

@@ -0,0 +1,20 @@
+/* eslint-disable import/no-internal-modules */
+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

@@ -0,0 +1,6 @@
+/* eslint-disable import/no-internal-modules */
+import { expose } from '../../src/worker'
+
+expose(function fail() {
+  throw new Error('I am supposed to fail.')
+})

package/test/workers/hello-world.ts

@@ -0,0 +1,6 @@
+/* eslint-disable import/no-internal-modules */
+import { expose } from '../../src/worker'
+
+expose(function helloWorld() {
+  return 'Hello World'
+})

package/test/workers/increment.ts

@@ -0,0 +1,9 @@
+/* eslint-disable import/no-internal-modules */
+import { expose } from '../../src/worker'
+
+let counter = 0
+
+expose(function increment(by: number = 1) {
+  counter += by
+  return counter
+})

package/test/workers/minmax.ts

@@ -0,0 +1,25 @@
+/* eslint-disable import/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

@@ -0,0 +1,12 @@
+/* eslint-disable require-await */
+/* eslint-disable import/no-internal-modules */
+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

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

package/test-tooling/rollup/app.js

@@ -0,0 +1,20 @@
+/* eslint-disable no-undef */
+/* 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

@@ -0,0 +1,15 @@
+/* eslint-disable import/no-default-export */
+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/rollup.test.ts

@@ -0,0 +1,44 @@
+import * as path from 'node:path'
+
+import test from 'ava'
+import execa from 'execa'
+import { rollup } from 'rollup'
+
+import config from './rollup.config'
+
+test('can be bundled using rollup', async (t) => {
+  t.timeout(2_000_000) // milliseconds
+
+  const appBundleP = rollup({
+    input: path.resolve(__dirname, 'app.js'),
+    ...config,
+  })
+
+  const workerBundleP = rollup({
+    input: path.resolve(__dirname, 'worker.js'),
+    ...config,
+  })
+
+  const appBundleWriteP = (await appBundleP).write({
+    dir: path.resolve(__dirname, 'dist'),
+    format: 'iife',
+  })
+
+  const workerBundleWriteP = (await workerBundleP).write({
+    dir: path.resolve(__dirname, 'dist'),
+    format: 'iife',
+  })
+
+  await Promise.all([appBundleWriteP, workerBundleWriteP])
+
+  if (process.platform === 'win32') {
+    // Quick-fix for weird Windows issue in CI
+    return t.pass()
+  }
+
+  const result = await execa.command('puppet-run --serve ./dist/worker.js:/worker.js ./dist/app.js', {
+    cwd: __dirname,
+    stderr: process.stderr,
+  })
+  t.is(result.exitCode, 0)
+})

package/test-tooling/rollup/worker.js

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

package/test-tooling/tsconfig/minimal-tsconfig.test.ts

@@ -0,0 +1,7 @@
+import test from 'ava'
+import execa from 'execa'
+
+test('can compile with a minimal TypeScript config', async (t) => {
+  const result = await execa('tsc', ['--project', require.resolve('./minimal-tsconfig.json')])
+  t.is(result.exitCode, 0, `tsc exited with non-zero exit code.\nStderr:\n${result.stderr}`)
+})

package/test-tooling/tsconfig/minimal.ts

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

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

@@ -0,0 +1,10 @@
+/* eslint-disable import/no-internal-modules */
+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

@@ -0,0 +1,29 @@
+/* eslint-disable import/no-default-export */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable import/no-internal-modules */
+/* eslint-disable import/no-unresolved */
+/// <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

package/test-tooling/webpack/app.ts

@@ -0,0 +1,58 @@
+/* eslint-disable import/no-default-export */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable import/no-internal-modules */
+import { isWorkerRuntime, Pool, spawn, Worker } from '../../src/index'
+
+type AdditionWorker = (a: number, b: number) => number
+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')),
+  ])
+  await pool.terminate()
+
+  for (const result of results) {
+    if (result !== 'Hello, World') {
+      throw new Error('Unexpected result returned by pool worker: ' + result)
+    }
+  }
+}
+
+async function test2() {
+  // We also want to test if referencing multiple different workers in a module
+  // built using webpack works
+
+  const add = await spawn<AdditionWorker>(new Worker('./addition-worker'))
+  const result = await add(2, 3)
+
+  if (result !== 5) {
+    throw new Error('Unexpected result returned by addition worker: ' + result)
+  }
+}
+
+async function test3() {
+  if (!(process as any).browser) {
+    // Running workers from remote URLs is disabled in node.js
+    return
+  }
+
+  const hello = await spawn<HelloWorker>(new Worker('https://infallible-turing-115958.netlify.com/hello-worker.js'))
+  const result = await hello('World')
+
+  if (result !== 'Hello, World') {
+    throw new Error('Unexpected result returned by hello worker: ' + result)
+  }
+}
+
+function test4() {
+  if (isWorkerRuntime() !== false) {
+    throw new Error('Expected isWorkerRuntime() to return false. Got: ' + isWorkerRuntime())
+  }
+}
+
+export default () => Promise.all([test(), test2(), test3(), test4()])

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

@@ -0,0 +1,6 @@
+/* eslint-disable import/no-internal-modules */
+import { expose } from '../../src/worker'
+
+expose(function hello(text: string) {
+  return `Hello, ${text}`
+})

package/test-tooling/webpack/raw-loader.d.ts

@@ -0,0 +1,4 @@
+declare module 'raw-loader!*' {
+  const content: string
+  export = content
+}

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

@@ -0,0 +1,21 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+// NOTE:
+// We are gonna test the bundles previously built by the AVA tests (see webpack.test.ts)
+
+describe('threads webpack browser bundle', function () {
+  this.timeout(80_000)
+
+  it('works fine', async function () {
+    const bundle = require('./dist/app.web/main')
+    await bundle.test()
+  })
+})
+
+describe('threads webpack browser bundle with inlined worker', function () {
+  this.timeout(80_000)
+
+  it('works fine', async function () {
+    const bundle = require('./dist/app-inlined.web/main')
+    await bundle.test()
+  })
+})

package/test-tooling/webpack/webpack.node.config.js

@@ -0,0 +1,38 @@
+/* eslint-disable no-undef */
+/* eslint-disable @typescript-eslint/no-var-requires */
+const path = require('node:path')
+const ThreadsPlugin = require('threads-plugin')
+
+module.exports = {
+  context: __dirname,
+  devtool: false,
+  entry: require.resolve('./app.ts'),
+  externals: {
+    'tiny-worker': 'tiny-worker',
+  },
+  mode: 'development',
+  module: {
+    rules: [
+      {
+        loader: 'ts-loader',
+        options: {
+          compilerOptions: {
+            module: 'esnext',
+          },
+        },
+        test: /\.ts$/,
+      },
+    ],
+  },
+  output: {
+    library: 'test',
+    libraryExport: 'default',
+    libraryTarget: 'commonjs',
+    path: path.resolve(__dirname, './dist/app.node'),
+  },
+  plugins: [new ThreadsPlugin()],
+  resolve: {
+    extensions: ['.js', '.ts'],
+  },
+  target: 'node',
+}

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

@@ -0,0 +1,90 @@
+/* eslint-disable require-await */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-var-requires */
+import * as path from 'node:path'
+
+import test from 'ava'
+import Webpack from 'webpack'
+
+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
+  : ''
+
+async function runWebpack(config: any) {
+  return new Promise<Webpack.Stats>((resolve, reject) => {
+    Webpack(config).run((error, stats) => {
+      error ? reject(error) : resolve(stats)
+    })
+  })
+}
+
+test('can create a browser bundle with webpack', async (t) => {
+  const stats = await runWebpack(browserConfig)
+  t.deepEqual(stats.compilation.errors, [], stringifyWebpackError(stats.compilation.errors[0]))
+})
+
+test('can create a working server bundle with webpack', async (t) => {
+  const stats = await runWebpack(serverConfig)
+  t.deepEqual(stats.compilation.errors, [], stringifyWebpackError(stats.compilation.errors[0]))
+
+  const bundle = require('./dist/app.node/main')
+  await bundle.test()
+})
+
+test('can inline a worker into an app bundle', async (t) => {
+  // Bundle browser worker
+  let stats = await runWebpack({
+    ...browserConfig,
+    entry: require.resolve('./addition-worker'),
+    output: {
+      filename: 'worker.js',
+      path: path.resolve(__dirname, 'dist/addition-worker.web'),
+    },
+    target: 'webworker',
+  })
+  t.deepEqual(stats.compilation.errors, [], stringifyWebpackError(stats.compilation.errors[0]))
+
+  // Bundle server worker
+  stats = await runWebpack({
+    ...serverConfig,
+    entry: require.resolve('./addition-worker'),
+    output: {
+      filename: 'worker.js',
+      path: path.resolve(__dirname, 'dist/addition-worker.node'),
+    },
+  })
+  t.deepEqual(stats.compilation.errors, [], stringifyWebpackError(stats.compilation.errors[0]))
+
+  // Bundle browser app
+  stats = await runWebpack({
+    ...browserConfig,
+    entry: require.resolve('./app-with-inlined-worker'),
+    output: {
+      ...serverConfig.output,
+      path: path.resolve(__dirname, 'dist/app-inlined.web'),
+    },
+  })
+  t.deepEqual(stats.compilation.errors, [], stringifyWebpackError(stats.compilation.errors[0]))
+
+  // Bundle server app
+  stats = await runWebpack({
+    ...serverConfig,
+    entry: require.resolve('./app-with-inlined-worker'),
+    output: {
+      ...serverConfig.output,
+      path: path.resolve(__dirname, 'dist/app-inlined.node'),
+    },
+  })
+  t.deepEqual(stats.compilation.errors, [], stringifyWebpackError(stats.compilation.errors[0]))
+
+  const bundle = require('./dist/app-inlined.node/main')
+  const result = await bundle.test()
+
+  t.is(result, 'test succeeded')
+})

package/test-tooling/webpack/webpack.web.config.js

@@ -0,0 +1,35 @@
+/* eslint-disable no-undef */
+/* eslint-disable @typescript-eslint/no-var-requires */
+const path = require('node:path')
+const ThreadsPlugin = require('threads-plugin')
+
+module.exports = {
+  context: __dirname,
+  devtool: false,
+  entry: require.resolve('./app.ts'),
+  mode: 'development',
+  module: {
+    rules: [
+      {
+        loader: 'ts-loader',
+        options: {
+          compilerOptions: {
+            module: 'esnext',
+          },
+        },
+        test: /\.ts$/,
+      },
+    ],
+  },
+  output: {
+    library: 'test',
+    libraryExport: 'default',
+    libraryTarget: 'commonjs',
+    path: path.resolve(__dirname, './dist/app.web'),
+  },
+  plugins: [new ThreadsPlugin()],
+  resolve: {
+    extensions: ['.js', '.ts'],
+  },
+  target: 'web',
+}

package/types/is-observable.d.ts

@@ -0,0 +1,7 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+declare module 'is-observable' {
+  import { Observable } from 'observable-fns'
+
+  function isObservable(thing: any): thing is Observable<any>
+  export = isObservable
+}

package/types/tiny-worker.d.ts

@@ -0,0 +1,4 @@
+declare module 'tiny-worker' {
+  const TinyWorker: typeof Worker
+  export = TinyWorker
+}

package/types/webworker.d.ts

@@ -0,0 +1,9 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/// <reference no-default-lib="true"/>
+/// <reference lib="webworker" />
+
+interface WorkerGlobalScope {
+  addEventListener(eventName: string, listener: (event: Event) => void): void
+  postMessage(message: any, transferables?: any[]): void
+  removeEventListener(eventName: string, listener: (event: Event) => void): void
+}

package/worker.d.ts

@@ -0,0 +1,2 @@
+/* eslint-disable import/no-internal-modules */
+export * from './dist/worker/index'

package/worker.js

@@ -0,0 +1,3 @@
+/* eslint-disable import/no-internal-modules */
+/* eslint-disable no-undef */
+module.exports = require('./dist/worker/index')

package/worker.mjs

@@ -0,0 +1,7 @@
+/* eslint-disable import/no-internal-modules */
+import * as WorkerContext from './dist/worker/index.js'
+
+export const expose = WorkerContext.expose
+export const registerSerializer = WorkerContext.registerSerializer
+export const Transfer = WorkerContext.Transfer
+export const isWorkerRuntime = WorkerContext.isWorkerRuntime