@xylabs/threads 4.7.0 → 4.7.1

package/src/master/spawn.ts

@@ -4,11 +4,11 @@
 import DebugLogger from 'debug'
 import { Observable } from 'observable-fns'
 
-import { deserialize } from '../common.ts'
-import { createPromiseWithResolver } from '../promise.ts'
+import { deserialize } from '../common'
+import { createPromiseWithResolver } from '../promise'
 import {
   $errors, $events, $terminate, $worker,
-} from '../symbols.ts'
+} from '../symbols'
 import type {
   FunctionThread,
   ModuleThread,
@@ -19,11 +19,11 @@ import type {
   WorkerInternalErrorEvent,
   WorkerMessageEvent,
   WorkerTerminationEvent,
-} from '../types/master.ts'
-import { WorkerEventType } from '../types/master.ts'
-import type { WorkerInitMessage, WorkerUncaughtErrorMessage } from '../types/messages.ts'
-import type { WorkerFunction, WorkerModule } from '../types/worker.ts'
-import { createProxyFunction, createProxyModule } from './invocation-proxy.ts'
+} from '../types/master'
+import { WorkerEventType } from '../types/master'
+import type { WorkerInitMessage, WorkerUncaughtErrorMessage } from '../types/messages'
+import type { WorkerFunction, WorkerModule } from '../types/worker'
+import { createProxyFunction, createProxyModule } from './invocation-proxy'
 
 type ArbitraryWorkerInterface = WorkerFunction & WorkerModule<string> & { somekeythatisneverusedinproductioncode123: 'magicmarker123' }
 type ArbitraryThreadType = FunctionThread<any, any> & ModuleThread<any>

package/src/master/thread.ts

@@ -3,8 +3,8 @@ import type { Observable } from 'observable-fns'
 
 import {
   $errors, $events, $terminate,
-} from '../symbols.ts'
-import type { Thread as ThreadType, WorkerEvent } from '../types/master.ts'
+} from '../symbols'
+import type { Thread as ThreadType, WorkerEvent } from '../types/master'
 
 function fail(message: string): never {
   throw new Error(message)

package/src/observable-promise.ts

@@ -132,8 +132,7 @@ export class ObservablePromise<T> extends Observable<T> implements Promise<T> {
       const fulfillmentCallback = (value: T) => {
         try {
           resolve(onFulfilled(value))
-        } catch (ex) {
-          const error = ex as Error
+        } catch (error) {
           rejectionCallback(error)
         }
       }
@@ -167,7 +166,7 @@ export class ObservablePromise<T> extends Observable<T> implements Promise<T> {
     ) as Promise<T>
   }
 
-  static override from<T>(thing: Observable<T> | ObservableLike<T> | ArrayLike<T> | Thenable<T>): ObservablePromise<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) => {

package/src/serializers.ts

@@ -1,6 +1,6 @@
 /* eslint-disable import-x/no-internal-modules */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import type { SerializedError } from './types/messages.ts'
+import type { SerializedError } from './types/messages'
 
 export interface Serializer<Msg = JsonSerializable, Input = any> {
   deserialize(message: Msg): Input

package/src/transferable.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { $transferable } from './symbols.ts'
+import { $transferable } from './symbols'
 
 export interface TransferDescriptor<T = any> {
   [$transferable]: true
@@ -55,7 +55,6 @@ export function Transfer(transferable: Transferable): TransferDescriptor
 export function Transfer<T>(payload: T, transferables: Transferable[]): TransferDescriptor
 
 export function Transfer<T>(payload: T, transferables?: Transferable[]): TransferDescriptor {
-  console.log('Transfer')
   if (!transferables) {
     if (!isTransferable(payload)) throw new Error('Not transferable')
     transferables = [payload]

package/src/types/master.ts

@@ -6,11 +6,11 @@
 // See <https://github.com/microsoft/TypeScript/issues/28009>
 import type { Observable } from 'observable-fns'
 
-import type { ObservablePromise } from '../observable-promise.ts'
+import type { ObservablePromise } from '../observable-promise'
 import type {
   $errors, $events, $terminate, $worker,
-} from '../symbols.ts'
-import type { TransferDescriptor } from '../transferable.ts'
+} from '../symbols'
+import type { TransferDescriptor } from '../transferable'
 
 interface ObservableLikeSubscription {
   unsubscribe(): any

package/src/worker/bundle-entry.ts

@@ -0,0 +1,10 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { expose } from './index'
+export * from './index'
+
+if (typeof globalThis !== 'undefined') {
+  ;(globalThis as any).expose = expose
+}
+if (typeof globalThis !== 'undefined') {
+  ;(globalThis as any).expose = expose
+}

package/src/worker/{worker.browser.ts → implementation.browser.ts}

@@ -1,11 +1,15 @@
 /* eslint-disable import-x/no-internal-modules */
-
-/// <reference lib="webworker" />
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/// <reference lib="dom" />
 // tslint:disable no-shadowed-variable
 
-import type { AbstractedWorkerAPI } from '../types/worker.ts'
-import { createExpose } from './expose.ts'
-import type { WorkerGlobalScope } from './WorkerGlobalScope.ts'
+import type { AbstractedWorkerAPI } from '../types/worker'
+
+interface WorkerGlobalScope {
+  addEventListener(eventName: string, listener: (event: Event) => void): void
+  postMessage(message: any, transferables?: any[]): void
+  removeEventListener(eventName: string, listener: (event: Event) => void): void
+}
 
 declare const self: WorkerGlobalScope
 
@@ -29,28 +33,8 @@ const subscribeToMasterMessages: AbstractedWorkerAPI['subscribeToMasterMessages'
   return unsubscribe
 }
 
-const addEventListener = self.addEventListener
-const postMessage = self.postMessage
-const removeEventListener = self.removeEventListener
-
-export {
-  addEventListener,
-  postMessage,
-  removeEventListener,
-}
-
-const expose = createExpose({
-  isWorkerRuntime, postMessageToMaster, subscribeToMasterMessages,
-}, {
-  addEventListener, postMessage, removeEventListener,
-})
-
-export {
+export default {
   isWorkerRuntime,
   postMessageToMaster,
   subscribeToMasterMessages,
 }
-
-export { registerSerializer } from '../common.ts'
-export { Transfer } from '../transferable.ts'
-export { expose }

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

@@ -0,0 +1,55 @@
+/* eslint-disable import-x/no-internal-modules */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/// <reference lib="dom" />
+// tslint:disable no-shadowed-variable
+
+import type { AbstractedWorkerAPI } from '../types/worker'
+
+interface WorkerGlobalScope {
+  addEventListener(eventName: string, listener: (event: Event) => void): void
+  postMessage(message: any, transferables?: any[]): void
+  removeEventListener(eventName: string, listener: (event: Event) => void): void
+}
+
+declare const self: WorkerGlobalScope
+try {
+  if (self === undefined) {
+    ;(globalThis as any).self = globalThis
+  }
+} catch {
+  ;(globalThis as any).self = globalThis
+}
+
+const isWorkerRuntime: AbstractedWorkerAPI['isWorkerRuntime'] = function isWorkerRuntime() {
+  return self !== undefined && self['postMessage'] ? true : false
+}
+
+const postMessageToMaster: AbstractedWorkerAPI['postMessageToMaster'] = function postMessageToMaster(data) {
+  // TODO: Warn that Transferables are not supported on first attempt to use feature
+  self.postMessage(data)
+}
+
+let muxingHandlerSetUp = false
+const messageHandlers = new Set<(data: any) => void>()
+
+const subscribeToMasterMessages: AbstractedWorkerAPI['subscribeToMasterMessages'] = function subscribeToMasterMessages(onMessage) {
+  if (!muxingHandlerSetUp) {
+    // We have one multiplexing message handler as tiny-worker's
+    // addEventListener() only allows you to set a single message handler
+    self.addEventListener('message', ((event: MessageEvent) => {
+      for (const handler of messageHandlers) handler(event.data)
+    }) as EventListener)
+    muxingHandlerSetUp = true
+  }
+
+  messageHandlers.add(onMessage)
+
+  const unsubscribe = () => messageHandlers.delete(onMessage)
+  return unsubscribe
+}
+
+export default {
+  isWorkerRuntime,
+  postMessageToMaster,
+  subscribeToMasterMessages,
+}

package/src/worker/implementation.ts

@@ -0,0 +1,23 @@
+/* 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/{worker.node.ts → implementation.worker_threads.ts}

@@ -1,16 +1,10 @@
 /* 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 { MessagePort, TransferListItem } from 'node:worker_threads'
-import { parentPort as optionalParentPort } from 'node:worker_threads'
-
-import { assertEx } from '@xylabs/assert'
-
-import type { AbstractedWorkerAPI } from '../types/worker.ts'
-import { createExpose } from './expose.ts'
-
-const parentPort = assertEx(optionalParentPort, () => 'Invariant violation: MessagePort to parent is not available.')
+import type { AbstractedWorkerAPI } from '../types/worker'
+import WorkerThreads from '../worker_threads'
 
 function assertMessagePort(port: MessagePort | null | undefined): MessagePort {
   if (!port) {
@@ -20,14 +14,16 @@ function assertMessagePort(port: MessagePort | null | undefined): MessagePort {
 }
 
 const isWorkerRuntime: AbstractedWorkerAPI['isWorkerRuntime'] = function isWorkerRuntime() {
-  return true // isMainThread
+  return !WorkerThreads().isMainThread
 }
 
 const postMessageToMaster: AbstractedWorkerAPI['postMessageToMaster'] = function postMessageToMaster(data, transferList) {
-  assertMessagePort(parentPort).postMessage(data, transferList as TransferListItem[])
+  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.')
   }
@@ -41,28 +37,14 @@ const subscribeToMasterMessages: AbstractedWorkerAPI['subscribeToMasterMessages'
   return unsubscribe
 }
 
-const addEventListener = parentPort?.on.bind(parentPort)
-const postMessage = parentPort?.postMessage.bind(parentPort)
-const removeEventListener = parentPort?.off.bind(parentPort)
-
-export {
-  addEventListener,
-  postMessage,
-  removeEventListener,
+function testImplementation() {
+  // Will throw if `worker_threads` are not available
+  WorkerThreads()
 }
 
-const expose = createExpose({
-  isWorkerRuntime, postMessageToMaster, subscribeToMasterMessages,
-}, {
-  addEventListener, postMessage, removeEventListener,
-})
-
-export {
+export default {
   isWorkerRuntime,
   postMessageToMaster,
   subscribeToMasterMessages,
+  testImplementation,
 }
-
-export { registerSerializer } from '../common.ts'
-export { Transfer } from '../transferable.ts'
-export { expose }

package/src/worker/index.ts

@@ -0,0 +1,230 @@
+/* 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

@@ -0,0 +1,27 @@
+/* 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

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

package/test/lib/serialization.ts

@@ -0,0 +1,38 @@
+/* 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)
+  },
+}