@xylabs/threads 4.6.3 → 4.7.0-rc.1

package/src/worker/implementation.ts

@@ -1,23 +0,0 @@
-/* eslint-disable import-x/no-internal-modules */
-// tslint:disable no-var-requires
-/*
- * This file is only a stub to make './implementation' resolve to the right module.
- */
-
-import type { AbstractedWorkerAPI } from '../types/worker'
-import WebWorkerImplementation from './implementation.browser'
-import TinyWorkerImplementation from './implementation.tiny-worker'
-import WorkerThreadsImplementation from './implementation.worker_threads'
-
-const runningInNode = typeof process !== 'undefined' && (process.arch as string) !== 'browser' && 'pid' in process
-
-function selectNodeImplementation(): AbstractedWorkerAPI {
-  try {
-    WorkerThreadsImplementation.testImplementation()
-    return WorkerThreadsImplementation
-  } catch {
-    return TinyWorkerImplementation
-  }
-}
-
-export default runningInNode ? selectNodeImplementation() : WebWorkerImplementation

package/src/worker/implementation.worker_threads.ts

@@ -1,50 +0,0 @@
-/* eslint-disable import-x/no-internal-modules */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-// tslint:disable no-shadowed-variable
-import type { MessagePort } from 'node:worker_threads'
-
-import type { AbstractedWorkerAPI } from '../types/worker'
-import WorkerThreads from '../worker_threads'
-
-function assertMessagePort(port: MessagePort | null | undefined): MessagePort {
-  if (!port) {
-    throw new Error('Invariant violation: MessagePort to parent is not available.')
-  }
-  return port
-}
-
-const isWorkerRuntime: AbstractedWorkerAPI['isWorkerRuntime'] = function isWorkerRuntime() {
-  return !WorkerThreads().isMainThread
-}
-
-const postMessageToMaster: AbstractedWorkerAPI['postMessageToMaster'] = function postMessageToMaster(data, transferList) {
-  assertMessagePort(WorkerThreads().parentPort).postMessage(data, transferList as any)
-}
-
-const subscribeToMasterMessages: AbstractedWorkerAPI['subscribeToMasterMessages'] = function subscribeToMasterMessages(onMessage) {
-  const parentPort = WorkerThreads().parentPort
-
-  if (!parentPort) {
-    throw new Error('Invariant violation: MessagePort to parent is not available.')
-  }
-  const messageHandler = (message: any) => {
-    onMessage(message)
-  }
-  const unsubscribe = () => {
-    assertMessagePort(parentPort).off('message', messageHandler)
-  }
-  assertMessagePort(parentPort).on('message', messageHandler)
-  return unsubscribe
-}
-
-function testImplementation() {
-  // Will throw if `worker_threads` are not available
-  WorkerThreads()
-}
-
-export default {
-  isWorkerRuntime,
-  postMessageToMaster,
-  subscribeToMasterMessages,
-  testImplementation,
-}

package/src/worker/index.ts

@@ -1,230 +0,0 @@
-/* eslint-disable import-x/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'
-import type { Observable, Subscription } from 'observable-fns'
-
-import { deserialize, serialize } from '../common'
-import type { TransferDescriptor } from '../transferable'
-import { isTransferDescriptor } from '../transferable'
-import type {
-  MasterJobCancelMessage,
-  MasterJobRunMessage,
-  SerializedError,
-  WorkerInitMessage,
-  WorkerJobErrorMessage,
-  WorkerJobResultMessage,
-  WorkerJobStartMessage,
-  WorkerUncaughtErrorMessage,
-} from '../types/messages'
-import {
-  MasterMessageType,
-  WorkerMessageType,
-} from '../types/messages'
-import type { WorkerFunction, WorkerModule } from '../types/worker'
-import Implementation from './implementation'
-
-export { registerSerializer } from '../common'
-export { Transfer } from '../transferable'
-
-/** Returns `true` if this code is currently running in a worker. */
-export const isWorkerRuntime = Implementation.isWorkerRuntime
-
-let exposeCalled = false
-
-const activeSubscriptions = new Map<number, Subscription<any>>()
-
-const isMasterJobCancelMessage = (thing: any): thing is MasterJobCancelMessage => thing && thing.type === MasterMessageType.cancel
-const isMasterJobRunMessage = (thing: any): thing is MasterJobRunMessage => thing && thing.type === MasterMessageType.run
-
-/**
- * There are issues with `is-observable` not recognizing zen-observable's instances.
- * We are using `observable-fns`, but it's based on zen-observable, too.
- */
-const isObservable = (thing: any): thing is Observable<any> => isSomeObservable(thing) || isZenObservable(thing)
-
-function isZenObservable(thing: any): thing is Observable<any> {
-  return thing && typeof thing === 'object' && typeof thing.subscribe === 'function'
-}
-
-function deconstructTransfer(thing: any) {
-  return isTransferDescriptor(thing) ? { payload: thing.send, transferables: thing.transferables } : { payload: thing, transferables: undefined }
-}
-
-function postFunctionInitMessage() {
-  const initMessage: WorkerInitMessage = {
-    exposed: { type: 'function' },
-    type: WorkerMessageType.init,
-  }
-  Implementation.postMessageToMaster(initMessage)
-}
-
-function postModuleInitMessage(methodNames: string[]) {
-  const initMessage: WorkerInitMessage = {
-    exposed: {
-      methods: methodNames,
-      type: 'module',
-    },
-    type: WorkerMessageType.init,
-  }
-  Implementation.postMessageToMaster(initMessage)
-}
-
-function postJobErrorMessage(uid: number, rawError: Error | TransferDescriptor<Error>) {
-  const { payload: error, transferables } = deconstructTransfer(rawError)
-  const errorMessage: WorkerJobErrorMessage = {
-    error: serialize(error) as any as SerializedError,
-    type: WorkerMessageType.error,
-    uid,
-  }
-  Implementation.postMessageToMaster(errorMessage, transferables)
-}
-
-function postJobResultMessage(uid: number, completed: boolean, resultValue?: any) {
-  const { payload, transferables } = deconstructTransfer(resultValue)
-  const resultMessage: WorkerJobResultMessage = {
-    complete: completed ? true : undefined,
-    payload,
-    type: WorkerMessageType.result,
-    uid,
-  }
-  Implementation.postMessageToMaster(resultMessage, transferables)
-}
-
-function postJobStartMessage(uid: number, resultType: WorkerJobStartMessage['resultType']) {
-  const startMessage: WorkerJobStartMessage = {
-    resultType,
-    type: WorkerMessageType.running,
-    uid,
-  }
-  Implementation.postMessageToMaster(startMessage)
-}
-
-function postUncaughtErrorMessage(error: Error) {
-  try {
-    const errorMessage: WorkerUncaughtErrorMessage = {
-      error: serialize(error) as any as SerializedError,
-      type: WorkerMessageType.uncaughtError,
-    }
-    Implementation.postMessageToMaster(errorMessage)
-  } catch (subError) {
-    // tslint:disable-next-line no-console
-    console.error(
-      'Not reporting uncaught error back to master thread as it ' + 'occured while reporting an uncaught error already.' + '\nLatest error:',
-      subError,
-      '\nOriginal error:',
-      error,
-    )
-  }
-}
-
-async function runFunction(jobUID: number, fn: WorkerFunction, args: any[]) {
-  let syncResult: any
-
-  try {
-    syncResult = fn(...args)
-  } catch (error) {
-    return postJobErrorMessage(jobUID, error)
-  }
-
-  const resultType = isObservable(syncResult) ? 'observable' : 'promise'
-  postJobStartMessage(jobUID, resultType)
-
-  if (isObservable(syncResult)) {
-    const subscription = syncResult.subscribe(
-      value => postJobResultMessage(jobUID, false, serialize(value)),
-      (error) => {
-        postJobErrorMessage(jobUID, serialize(error) as any)
-        activeSubscriptions.delete(jobUID)
-      },
-      () => {
-        postJobResultMessage(jobUID, true)
-        activeSubscriptions.delete(jobUID)
-      },
-    )
-    activeSubscriptions.set(jobUID, subscription)
-  } else {
-    try {
-      const result = await syncResult
-      postJobResultMessage(jobUID, true, serialize(result))
-    } catch (error) {
-      postJobErrorMessage(jobUID, serialize(error) as any)
-    }
-  }
-}
-
-/**
- * Expose a function or a module (an object whose values are functions)
- * to the main thread. Must be called exactly once in every worker thread
- * to signal its API to the main thread.
- *
- * @param exposed Function or object whose values are functions
- */
-export function expose(exposed: WorkerFunction | WorkerModule<any>) {
-  if (!Implementation.isWorkerRuntime()) {
-    throw new Error('expose() called in the master thread.')
-  }
-  if (exposeCalled) {
-    throw new Error('expose() called more than once. This is not possible. Pass an object to expose() if you want to expose multiple functions.')
-  }
-  exposeCalled = true
-
-  if (typeof exposed === 'function') {
-    Implementation.subscribeToMasterMessages((messageData) => {
-      if (isMasterJobRunMessage(messageData) && !messageData.method) {
-        runFunction(messageData.uid, exposed, messageData.args.map(deserialize))
-      }
-    })
-    postFunctionInitMessage()
-  } else if (typeof exposed === 'object' && exposed) {
-    Implementation.subscribeToMasterMessages((messageData) => {
-      if (isMasterJobRunMessage(messageData) && messageData.method) {
-        runFunction(messageData.uid, exposed[messageData.method], messageData.args.map(deserialize))
-      }
-    })
-
-    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}`)
-  }
-
-  Implementation.subscribeToMasterMessages((messageData) => {
-    if (isMasterJobCancelMessage(messageData)) {
-      const jobUID = messageData.uid
-      const subscription = activeSubscriptions.get(jobUID)
-
-      if (subscription) {
-        subscription.unsubscribe()
-        activeSubscriptions.delete(jobUID)
-      }
-    }
-  })
-}
-
-if (typeof globalThis !== 'undefined' && typeof self.addEventListener === 'function' && Implementation.isWorkerRuntime()) {
-  self.addEventListener('error', (event) => {
-    // Post with some delay, so the master had some time to subscribe to messages
-    setTimeout(() => postUncaughtErrorMessage(event.error || event), 250)
-  })
-  self.addEventListener('unhandledrejection', (event) => {
-    const error = (event as any).reason
-    if (error && typeof (error as any).message === 'string') {
-      // Post with some delay, so the master had some time to subscribe to messages
-      setTimeout(() => postUncaughtErrorMessage(error), 250)
-    }
-  })
-}
-
-if (typeof process !== 'undefined' && typeof process.on === 'function' && Implementation.isWorkerRuntime()) {
-  process.on('uncaughtException', (error) => {
-    // Post with some delay, so the master had some time to subscribe to messages
-    setTimeout(() => postUncaughtErrorMessage(error), 250)
-  })
-  process.on('unhandledRejection', (error) => {
-    if (error && typeof (error as any).message === 'string') {
-      // Post with some delay, so the master had some time to subscribe to messages
-      setTimeout(() => postUncaughtErrorMessage(error as any), 250)
-    }
-  })
-}

package/src/worker_threads.ts

@@ -1,27 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-// Webpack hack
-// tslint:disable no-eval
-
-declare function __non_webpack_require__(module: string): any
-
-// FIXME
-type MessagePort = any
-
-interface WorkerThreadsModule {
-  MessagePort: typeof MessagePort
-  isMainThread: boolean
-  parentPort: MessagePort
-}
-
-let implementation: WorkerThreadsModule | undefined
-
-function selectImplementation(): WorkerThreadsModule {
-  return typeof __non_webpack_require__ === 'function' ? __non_webpack_require__('worker_threads') : eval('require')('worker_threads')
-}
-
-export default function getImplementation(): WorkerThreadsModule {
-  if (!implementation) {
-    implementation = selectImplementation()
-  }
-  return implementation
-}

package/test/lib/index.ts

@@ -1 +0,0 @@
-export * from './serialization.js'

package/test/lib/serialization.ts

@@ -1,38 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-import type { JsonSerializable, SerializerImplementation } from '../../src/index'
-
-export class Foo<T> {
-  private readonly value: T
-
-  constructor(value: T) {
-    this.value = value
-  }
-
-  getValue() {
-    return this.value
-  }
-}
-
-interface SerializedFoo<T extends JsonSerializable> {
-  __type: '$$foo'
-  val: T
-}
-
-const isSerializedFoo = (thing: any): thing is SerializedFoo<JsonSerializable> =>
-  thing && typeof thing === 'object' && '__type' in thing && thing.__type === '$$foo'
-
-export const fooSerializer: SerializerImplementation = {
-  deserialize(serialized, fallback) {
-    return isSerializedFoo(serialized) ? new Foo(serialized.val) : fallback(serialized)
-  },
-
-  serialize(data, fallback) {
-    return data instanceof Foo
-      ? {
-          __type: '$$foo',
-          val: data.getValue(),
-        }
-      : fallback(data)
-  },
-}

package/test/observable-promise.test.ts

@@ -1,205 +0,0 @@
-/* eslint-disable import-x/no-internal-modules */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-import { Observable } from 'observable-fns'
-import { expect, test } from 'vitest'
-
-import { ObservablePromise } from '../src/observable-promise'
-
-const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
-
-test('can create an observable promise', async () => {
-  expect.assertions(1)
-
-  await new ObservablePromise((observer) => {
-    expect(true).toBe(true)
-    observer.complete()
-  })
-})
-
-test('init function is only called once', async () => {
-  let initCallCount = 0
-
-  const async = new ObservablePromise((observer) => {
-    initCallCount++
-    setTimeout(() => observer.complete(), 10)
-  })
-
-  await Promise.all([
-    async.then(() => expect(true).toBe(true)),
-    async.then(() => expect(true).toBe(true)),
-    async.then(() => expect(true).toBe(true)),
-  ])
-
-  expect(initCallCount).toBe(1)
-})
-
-test('can proxy a promise fulfillment', async () => {
-  expect.assertions(2) // Ensure two assertions are made
-
-  const async = new ObservablePromise((observer) => {
-    setTimeout(() => {
-      observer.next(123)
-
-      // Ignore all values after the first one
-      observer.next(456)
-      observer.complete()
-    }, 1)
-  })
-
-  const promise1 = async.then(
-    value => expect(value).toBe(123),
-    () => expect.fail('Promise was rejected unexpectedly'),
-  )
-
-  await delay(10)
-
-  const promise2 = async.then(
-    value => expect(value).toBe(123),
-    () => expect.fail('Promise was rejected unexpectedly'),
-  )
-
-  await Promise.all([promise1, promise2])
-})
-
-test('can proxy a promise rejection', async () => {
-  let handlerCallCount = 0
-
-  const async = new ObservablePromise((observer) => {
-    setTimeout(() => observer.error(new Error('I am supposed to be rejected.')), 1)
-  })
-
-  const promise1 = async.then(
-    () => expect.fail('Promise should not become fulfilled'),
-    () => handlerCallCount++,
-  )
-
-  await delay(10)
-
-  const promise2 = async.then(
-    () => expect.fail('Promise should not become fulfilled'),
-    () => handlerCallCount++,
-  )
-
-  await Promise.all([promise1.catch(() => true), promise2.catch(() => true)])
-  expect(handlerCallCount).toBe(2)
-})
-
-test('can proxy a promise rejection caused by a sync throw', async () => {
-  let handlerCallCount = 0
-
-  const async = new ObservablePromise(() => {
-    throw new Error('I am supposed to be rejected.')
-  })
-
-  const promise1 = async.then(
-    () => expect.fail('Promise should not become fulfilled'),
-    () => handlerCallCount++,
-  )
-
-  await delay(10)
-
-  const promise2 = async.then(
-    () => expect.fail('Promise should not become fulfilled'),
-    () => handlerCallCount++,
-  )
-
-  await Promise.all([promise1.catch(() => true), promise2.catch(() => true)])
-  expect(handlerCallCount).toBe(2)
-})
-
-test('can subscribe to values and completion', async () => {
-  const capturedValues: any[] = []
-  let capturedCompletions = 0
-
-  const async = new ObservablePromise((observer) => {
-    setTimeout(() => observer.next(1), 10)
-    setTimeout(() => observer.next(2), 20)
-    setTimeout(() => observer.complete(), 30)
-  })
-
-  for (let index = 0; index < 2; index++) {
-    async.subscribe(
-      value => capturedValues.push(value),
-      () => {},
-      () => capturedCompletions++,
-    )
-  }
-
-  await async.finally()
-  await delay(1)
-
-  expect(capturedValues).toEqual([1, 1, 2, 2])
-  expect(capturedCompletions).toBe(2)
-})
-
-test('can subscribe to errors', async () => {
-  const capturedErrorMessages: string[] = []
-  const capturedValues: any[] = []
-  let capturedCompletions = 0
-
-  const async = new ObservablePromise((observer) => {
-    setTimeout(() => observer.next(1), 10)
-    setTimeout(() => observer.error(new Error('Fails as expected.')), 20)
-    setTimeout(() => observer.next(2), 30) // This won't be called due to error
-    setTimeout(() => observer.complete(), 40) // This also won't be called
-  })
-
-  for (let index = 0; index < 2; index++) {
-    async.subscribe(
-      value => capturedValues.push(value),
-      error => capturedErrorMessages.push(error.message),
-      () => capturedCompletions++,
-    )
-  }
-
-  await async.finally()
-  await delay(35) // Wait to ensure the error and all async events are captured
-
-  expect(capturedValues).toEqual([1, 1])
-  expect(capturedErrorMessages).toEqual(['Fails as expected.', 'Fails as expected.'])
-  expect(capturedCompletions).toBe(0)
-})
-
-test('from(Observable) works', async () => {
-  const capturedErrorMessages: string[] = []
-  const capturedValues: any[] = []
-  let capturedCompletions = 0
-
-  const async = ObservablePromise.from(
-    new Observable((observer) => {
-      setTimeout(() => observer.next(1), 10)
-      setTimeout(() => observer.error(new Error('Fails as expected.')), 20)
-      setTimeout(() => observer.next(2), 30) // This won't be called due to error
-      setTimeout(() => observer.complete(), 40) // This also won't be called
-    }),
-  )
-
-  for (let index = 0; index < 2; index++) {
-    async.subscribe(
-      value => capturedValues.push(value),
-      error => capturedErrorMessages.push(error.message),
-      () => capturedCompletions++,
-    )
-  }
-
-  await async.finally()
-  await delay(35) // Allow time for error and async processing
-
-  expect(capturedValues).toEqual([1, 1])
-  expect(capturedErrorMessages).toEqual(['Fails as expected.', 'Fails as expected.'])
-  expect(capturedCompletions).toBe(0)
-})
-
-test('from(Promise) works', async () => {
-  const resolved = ObservablePromise.from(
-    new Promise((resolve) => {
-      setTimeout(() => resolve('Works'), 10)
-    }),
-  )
-
-  await expect(resolved).resolves.toBe('Works')
-
-  const rejected = ObservablePromise.from(Promise.reject(new Error('Fails')))
-  await expect(rejected).rejects.toThrow('Fails')
-})

package/test/observable.test.ts

@@ -1,87 +0,0 @@
-/* eslint-disable import-x/no-internal-modules */
-/* eslint-disable require-await */
-
-import { expect, test } from 'vitest'
-
-import { Observable, Subject } from '../src/observable'
-
-test('Observable subject emits values and completion event', async () => {
-  let completed1 = false
-  const values1: number[] = []
-  let completed2 = false
-  const values2: number[] = []
-  let completed3 = false
-  const values3: number[] = []
-
-  const subject = new Subject<number>()
-  const observable = Observable.from(subject)
-
-  const subscription1 = subject.subscribe(
-    value => values1.push(value),
-    undefined,
-    () => (completed1 = false),
-  )
-  subject.subscribe(
-    value => values2.push(value),
-    undefined,
-    () => (completed2 = true),
-  )
-  observable.subscribe(
-    value => values3.push(value),
-    undefined,
-    () => (completed3 = true),
-  )
-
-  subject.next(1)
-  subscription1.unsubscribe()
-
-  subject.next(2)
-  subject.complete()
-
-  expect(values1).toEqual([1])
-  expect(values2).toEqual([1, 2])
-  expect(values3).toEqual([1, 2])
-  expect(completed1).toBe(false)
-  expect(completed2).toBe(true)
-  expect(completed3).toBe(true)
-})
-
-test('Observable subject propagates errors', async () => {
-  let completed1 = false
-  let error1: Error | undefined
-  let completed2 = false
-  let error2: Error | undefined
-  let completed3 = false
-  let error3: Error | undefined
-
-  const subject = new Subject<number>()
-  const observable = Observable.from(subject)
-
-  const subscription1 = subject.subscribe(
-    () => {},
-    error => (error1 = error),
-    () => (completed1 = true),
-  )
-  subject.subscribe(
-    () => {},
-    error => (error2 = error),
-    () => (completed2 = true),
-  )
-  observable.subscribe(
-    () => {},
-    error => (error3 = error),
-    () => (completed3 = true),
-  )
-
-  const testingError = new Error('Test, test!')
-
-  subscription1.unsubscribe()
-  subject.error(testingError)
-
-  expect(completed1).toBe(false)
-  expect(error1).toBeUndefined()
-  expect(completed2).toBe(false)
-  expect(error2).toBe(testingError)
-  expect(completed3).toBe(false)
-  expect(error3).toBe(testingError)
-})