@xylabs/threads 4.7.1 → 4.7.2

package/src/master/get-bundle-url.browser.ts

@@ -1,31 +0,0 @@
-// Source: <https://github.com/parcel-bundler/parcel/blob/master/packages/core/parcel-bundler/src/builtins/bundle-url.js>
-
-let bundleURL: string | undefined
-
-function getBundleURLCached(): string {
-  if (!bundleURL) {
-    bundleURL = getBundleURL()
-  }
-
-  return bundleURL
-}
-
-function getBundleURL(): string {
-  // Attempt to find the URL of the current script and use that as the base URL
-  try {
-    throw new Error('getBundleURL failed')
-  } catch (err) {
-    const matches = ('' + err.stack).match(/(https?|file|ftp|chrome-extension|moz-extension):\/\/[^\n)]+/g)
-    if (matches) {
-      return getBaseURL(matches[0])
-    }
-  }
-
-  return '/'
-}
-
-function getBaseURL(url: string): string {
-  return ('' + url).replace(/^((?:https?|file|ftp|chrome-extension|moz-extension):\/\/.+)?\/[^/]+(?:\?.*)?$/, '$1') + '/'
-}
-
-export { getBundleURLCached as getBundleURL }

package/src/master/implementation.browser.ts

@@ -1,82 +0,0 @@
-/* eslint-disable @stylistic/max-len */
-/* eslint-disable import-x/no-internal-modules */
-// tslint:disable max-classes-per-file
-
-import type { ImplementationExport, ThreadsWorkerOptions } from '../types/master'
-import { getBundleURL } from './get-bundle-url.browser'
-
-export const defaultPoolSize = typeof navigator !== 'undefined' && navigator.hardwareConcurrency ? navigator.hardwareConcurrency : 4
-
-const isAbsoluteURL = (value: string) => /^[A-Za-z][\d+.A-Za-z\-]*:/.test(value)
-
-function createSourceBlobURL(code: string): string {
-  const blob = new Blob([code], { type: 'application/javascript' })
-  return URL.createObjectURL(blob)
-}
-
-function selectWorkerImplementation(): ImplementationExport {
-  if (typeof Worker === 'undefined') {
-    // Might happen on Safari, for instance
-    // The idea is to only fail if the constructor is actually used
-    return class NoWebWorker {
-      constructor() {
-        throw new Error(
-          "No web worker implementation available. You might have tried to spawn a worker within a worker in a browser that doesn't support workers in workers.",
-        )
-      }
-    } as unknown as ImplementationExport
-  }
-
-  class WebWorker extends Worker {
-    constructor(url: string | URL, options?: ThreadsWorkerOptions) {
-      if (typeof url === 'string' && options && options._baseURL) {
-        url = new URL(url, options._baseURL)
-      } else if (typeof url === 'string' && !isAbsoluteURL(url) && /^file:\/\//i.test(getBundleURL())) {
-        url = new URL(url, getBundleURL().replace(/\/[^/]+$/, '/'))
-        if (options?.CORSWorkaround ?? true) {
-          url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`)
-        }
-      }
-      if (
-        typeof url === 'string'
-        && isAbsoluteURL(url) // Create source code blob loading JS file via `importScripts()`
-        // to circumvent worker CORS restrictions
-        && (options?.CORSWorkaround ?? true)
-      ) {
-        url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`)
-      }
-      super(url, options)
-    }
-  }
-
-  class BlobWorker extends WebWorker {
-    constructor(blob: Blob, options?: ThreadsWorkerOptions) {
-      const url = globalThis.URL.createObjectURL(blob)
-      super(url, options)
-    }
-
-    static fromText(source: string, options?: ThreadsWorkerOptions): WebWorker {
-      const blob = new globalThis.Blob([source], { type: 'text/javascript' })
-      return new BlobWorker(blob, options)
-    }
-  }
-
-  return {
-    blob: BlobWorker,
-    default: WebWorker,
-  }
-}
-
-let implementation: ImplementationExport
-
-export function getWorkerImplementation(): ImplementationExport {
-  if (!implementation) {
-    implementation = selectWorkerImplementation()
-  }
-  return implementation
-}
-
-export function isWorkerRuntime() {
-  const isWindowContext = typeof globalThis !== 'undefined' && typeof Window !== 'undefined' && globalThis instanceof Window
-  return typeof globalThis !== 'undefined' && self['postMessage'] && !isWindowContext ? true : false
-}

package/src/master/implementation.node.ts

@@ -1,285 +0,0 @@
-/* eslint-disable @typescript-eslint/no-require-imports */
-/* eslint-disable import-x/no-internal-modules */
-/* eslint-disable unicorn/no-process-exit */
-/* eslint-disable unicorn/prefer-logical-operator-over-ternary */
-/* eslint-disable unicorn/prefer-regexp-test */
-
-/* eslint-disable unicorn/prefer-add-event-listener */
-/* eslint-disable unicorn/prefer-event-target */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable unicorn/text-encoding-identifier-case */
-/// <reference lib="dom" />
-
-import { EventEmitter } from 'node:events'
-import { cpus } from 'node:os'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-import type { CallSite } from 'callsites-3-1-0'
-import getCallsites from 'callsites-3-1-0'
-
-import type {
-  ImplementationExport, ThreadsWorkerOptions, WorkerImplementation,
-} from '../types/master'
-
-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 __non_webpack_require__: typeof require
-declare const self: WorkerGlobalScope
-
-type WorkerEventName = 'error' | 'message'
-
-let tsNodeAvailable: boolean | undefined
-
-export const defaultPoolSize = cpus().length
-
-function detectTsNode() {
-  if (typeof __non_webpack_require__ === 'function') {
-    // Webpack build: => No ts-node required or possible
-    return false
-  }
-  if (tsNodeAvailable) {
-    return tsNodeAvailable
-  }
-
-  try {
-    eval('require').resolve('ts-node')
-    tsNodeAvailable = true
-  } catch (error) {
-    if (error && error.code === 'MODULE_NOT_FOUND') {
-      tsNodeAvailable = false
-    } else {
-      // Re-throw
-      throw error
-    }
-  }
-  return tsNodeAvailable
-}
-
-function createTsNodeModule(scriptPath: string) {
-  return `
-    require("ts-node/register/transpile-only");
-    require(${JSON.stringify(scriptPath)});
-  `
-}
-
-function rebaseScriptPath(scriptPath: string, ignoreRegex: RegExp) {
-  const parentCallSite = getCallsites().find((callsite: CallSite) => {
-    const filename = callsite.getFileName()
-    return Boolean(
-      filename && !filename.match(ignoreRegex) && !/[/\\]master[/\\]implementation/.test(filename) && !/^internal\/process/.test(filename),
-    )
-  })
-
-  const rawCallerPath = parentCallSite ? parentCallSite.getFileName() : null
-  let callerPath = rawCallerPath ? rawCallerPath : null
-  if (callerPath && callerPath.startsWith('file:')) {
-    callerPath = fileURLToPath(callerPath)
-  }
-  return callerPath ? path.join(path.dirname(callerPath), scriptPath) : scriptPath
-}
-
-function resolveScriptPath(scriptPath: string, baseURL?: string | undefined) {
-  const makeRelative = (filePath: string) => {
-    // eval() hack is also webpack-related
-    return path.isAbsolute(filePath) ? filePath : path.join(baseURL || eval('__dirname'), filePath)
-  }
-
-  return typeof __non_webpack_require__ === 'function'
-    ? __non_webpack_require__.resolve(makeRelative(scriptPath))
-    : eval('require').resolve(makeRelative(rebaseScriptPath(scriptPath, /[/\\]worker_threads[/\\]/)))
-}
-
-function initWorkerThreadsWorker(): ImplementationExport {
-  // Webpack hack
-  const NativeWorker
-    = typeof __non_webpack_require__ === 'function' ? __non_webpack_require__('worker_threads').Worker : eval('require')('worker_threads').Worker
-
-  let allWorkers: Array<typeof NativeWorker> = []
-
-  class Worker extends NativeWorker {
-    private mappedEventListeners: WeakMap<EventListener, EventListener>
-
-    constructor(scriptPath: string, options?: ThreadsWorkerOptions & { fromSource: boolean }) {
-      const resolvedScriptPath = options && options.fromSource ? null : resolveScriptPath(scriptPath, (options || {})._baseURL)
-
-      if (!resolvedScriptPath) {
-        // `options.fromSource` is true
-        const sourceCode = scriptPath
-        super(sourceCode, { ...options, eval: true })
-      } else if (/\.tsx?$/i.test(resolvedScriptPath) && detectTsNode()) {
-        super(createTsNodeModule(resolvedScriptPath), { ...options, eval: true })
-      } else if (/\.asar[/\\]/.test(resolvedScriptPath)) {
-        // See <https://github.com/andywer/threads-plugin/issues/17>
-        super(resolvedScriptPath.replace(/\.asar([/\\])/, '.asar.unpacked$1'), options)
-      } else {
-        super(resolvedScriptPath, options)
-      }
-
-      this.mappedEventListeners = new WeakMap()
-      allWorkers.push(this)
-    }
-
-    addEventListener(eventName: string, rawListener: EventListener) {
-      const listener = (message: any) => {
-        rawListener({ data: message } as any)
-      }
-      this.mappedEventListeners.set(rawListener, listener)
-      this.on(eventName, listener)
-    }
-
-    removeEventListener(eventName: string, rawListener: EventListener) {
-      const listener = this.mappedEventListeners.get(rawListener) || rawListener
-      this.off(eventName, listener)
-    }
-  }
-
-  const terminateWorkersAndMaster = () => {
-    // we should terminate all workers and then gracefully shutdown self process
-    Promise.all(allWorkers.map(worker => worker.terminate())).then(
-      () => process.exit(0),
-      () => process.exit(1),
-    )
-    allWorkers = []
-  }
-
-  // Take care to not leave orphaned processes behind. See #147.
-  process.on('SIGINT', () => terminateWorkersAndMaster())
-  process.on('SIGTERM', () => terminateWorkersAndMaster())
-
-  class BlobWorker extends Worker {
-    constructor(blob: Uint8Array, options?: ThreadsWorkerOptions) {
-      super(Buffer.from(blob).toString('utf-8'), { ...options, fromSource: true })
-    }
-
-    static fromText(source: string, options?: ThreadsWorkerOptions): WorkerImplementation {
-      return new Worker(source, { ...options, fromSource: true }) as any
-    }
-  }
-
-  return {
-    blob: BlobWorker as any,
-    default: Worker as any,
-  }
-}
-
-function initTinyWorker(): ImplementationExport {
-  const TinyWorker = require('tiny-worker')
-
-  let allWorkers: Array<typeof TinyWorker> = []
-
-  class Worker extends TinyWorker {
-    private emitter: EventEmitter
-
-    constructor(scriptPath: string, options?: ThreadsWorkerOptions & { fromSource?: boolean }) {
-      // Need to apply a work-around for Windows or it will choke upon the absolute path
-      // (`Error [ERR_INVALID_PROTOCOL]: Protocol 'c:' not supported`)
-      const resolvedScriptPath
-        = options && options.fromSource
-          ? null
-          : process.platform === 'win32'
-            ? `file:///${resolveScriptPath(scriptPath).replaceAll('\\', '/')}`
-            : resolveScriptPath(scriptPath)
-
-      if (!resolvedScriptPath) {
-        // `options.fromSource` is true
-        const sourceCode = scriptPath
-        super(new Function(sourceCode), [], { esm: true })
-      } else if (/\.tsx?$/i.test(resolvedScriptPath) && detectTsNode()) {
-        super(new Function(createTsNodeModule(resolveScriptPath(scriptPath))), [], { esm: true })
-      } else if (/\.asar[/\\]/.test(resolvedScriptPath)) {
-        // See <https://github.com/andywer/threads-plugin/issues/17>
-        super(resolvedScriptPath.replace(/\.asar([/\\])/, '.asar.unpacked$1'), [], { esm: true })
-      } else {
-        super(resolvedScriptPath, [], { esm: true })
-      }
-
-      allWorkers.push(this)
-
-      this.emitter = new EventEmitter()
-      this.onerror = (error: Error) => this.emitter.emit('error', error)
-      this.onmessage = (message: MessageEvent) => this.emitter.emit('message', message)
-    }
-
-    addEventListener(eventName: WorkerEventName, listener: EventListener) {
-      this.emitter.addListener(eventName, listener)
-    }
-
-    removeEventListener(eventName: WorkerEventName, listener: EventListener) {
-      this.emitter.removeListener(eventName, listener)
-    }
-
-    terminate() {
-      allWorkers = allWorkers.filter(worker => worker !== this)
-      return super.terminate()
-    }
-  }
-
-  const terminateWorkersAndMaster = () => {
-    // we should terminate all workers and then gracefully shutdown self process
-    Promise.all(allWorkers.map(worker => worker.terminate())).then(
-      () => process.exit(0),
-      () => process.exit(1),
-    )
-    allWorkers = []
-  }
-
-  // Take care to not leave orphaned processes behind
-  // See <https://github.com/avoidwork/tiny-worker#faq>
-  process.on('SIGINT', () => terminateWorkersAndMaster())
-  process.on('SIGTERM', () => terminateWorkersAndMaster())
-
-  class BlobWorker extends Worker {
-    constructor(blob: Uint8Array, options?: ThreadsWorkerOptions) {
-      super(Buffer.from(blob).toString('utf-8'), { ...options, fromSource: true })
-    }
-
-    static fromText(source: string, options?: ThreadsWorkerOptions): WorkerImplementation {
-      return new Worker(source, { ...options, fromSource: true }) as any
-    }
-  }
-
-  return {
-    blob: BlobWorker as any,
-    default: Worker as any,
-  }
-}
-
-let implementation: ImplementationExport
-let isTinyWorker: boolean
-
-function selectWorkerImplementation(): ImplementationExport {
-  try {
-    isTinyWorker = false
-    return initWorkerThreadsWorker()
-  } catch {
-    // tslint:disable-next-line no-console
-    console.debug('Node worker_threads not available. Trying to fall back to tiny-worker polyfill...')
-    isTinyWorker = true
-    return initTinyWorker()
-  }
-}
-
-export function getWorkerImplementation(): ImplementationExport {
-  if (!implementation) {
-    implementation = selectWorkerImplementation()
-  }
-  return implementation
-}
-
-export function isWorkerRuntime() {
-  if (isTinyWorker) {
-    return self !== undefined && self['postMessage'] ? true : false
-  } else {
-    // Webpack hack
-    const isMainThread
-      = typeof __non_webpack_require__ === 'function'
-        ? __non_webpack_require__('worker_threads').isMainThread
-        : eval('require')('worker_threads').isMainThread
-    return !isMainThread
-  }
-}

package/src/master/implementation.ts

@@ -1,21 +0,0 @@
-/*
- * This file is only a stub to make './implementation' resolve to the right module.
- */
-
-// We alias `src/master/implementation` to `src/master/implementation.browser` for web
-// browsers already in the package.json, so if get here, it's safe to pass-through the
-// node implementation
-
-import * as BrowserImplementation from './implementation.browser'
-import * as NodeImplementation from './implementation.node'
-
-const runningInNode = typeof process !== 'undefined' && (process.arch as string) !== 'browser' && 'pid' in process
-const implementation = runningInNode ? NodeImplementation : BrowserImplementation
-
-/** Default size of pools. Depending on the platform the value might vary from device to device. */
-export const defaultPoolSize = implementation.defaultPoolSize
-
-export const getWorkerImplementation = implementation.getWorkerImplementation
-
-/** Returns `true` if this code is currently running in a worker. */
-export const isWorkerRuntime = implementation.isWorkerRuntime

package/src/master/index.ts

@@ -1,19 +0,0 @@
-/* eslint-disable import-x/no-internal-modules */
-import type { BlobWorker as BlobWorkerClass, Worker as WorkerType } from '../types/master'
-import { getWorkerImplementation } from './implementation'
-
-export { FunctionThread, ModuleThread } from '../types/master'
-export { Pool } from './pool'
-export { spawn } from './spawn'
-export { Thread } from './thread'
-
-export type BlobWorker = typeof BlobWorkerClass
-export type Worker = WorkerType
-
-/** Separate class to spawn workers from source code blobs or strings. */
-export const BlobWorker = getWorkerImplementation().blob
-
-/** Worker implementation. Either web worker or a node.js Worker class. */
-export const Worker = getWorkerImplementation().default
-
-export { isWorkerRuntime } from './implementation'

package/src/master/invocation-proxy.ts

@@ -1,151 +0,0 @@
-/* eslint-disable import-x/no-internal-modules */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/*
- * This source file contains the code for proxying calls in the master thread to calls in the workers
- * by `.postMessage()`-ing.
- *
- * Keep in mind that this code can make or break the program's performance! Need to optimize more…
- */
-
-import DebugLogger from 'debug'
-import { multicast, Observable } from 'observable-fns'
-
-import { deserialize, serialize } from '../common'
-import { ObservablePromise } from '../observable-promise'
-import { isTransferDescriptor } from '../transferable'
-import type {
-  ModuleMethods, ModuleProxy, ProxyableFunction, Worker as WorkerType,
-} from '../types/master'
-import type {
-  MasterJobCancelMessage,
-  MasterJobRunMessage,
-  WorkerJobErrorMessage,
-  WorkerJobResultMessage,
-  WorkerJobStartMessage,
-} from '../types/messages'
-import {
-  MasterMessageType,
-  WorkerMessageType,
-} from '../types/messages'
-
-const debugMessages = DebugLogger('threads:master:messages')
-
-let nextJobUID = 1
-
-const dedupe = <T>(array: T[]): T[] => [...new Set(array)]
-
-const isJobErrorMessage = (data: any): data is WorkerJobErrorMessage => data && data.type === WorkerMessageType.error
-const isJobResultMessage = (data: any): data is WorkerJobResultMessage => data && data.type === WorkerMessageType.result
-const isJobStartMessage = (data: any): data is WorkerJobStartMessage => data && data.type === WorkerMessageType.running
-
-function createObservableForJob<ResultType>(worker: WorkerType, jobUID: number): Observable<ResultType> {
-  return new Observable((observer) => {
-    let asyncType: 'observable' | 'promise' | undefined
-
-    const messageHandler = ((event: MessageEvent) => {
-      debugMessages('Message from worker:', event.data)
-      if (!event.data || event.data.uid !== jobUID) return
-
-      if (isJobStartMessage(event.data)) {
-        asyncType = event.data.resultType
-      } else if (isJobResultMessage(event.data)) {
-        if (asyncType === 'promise') {
-          if (event.data.payload !== undefined) {
-            observer.next(deserialize(event.data.payload))
-          }
-          observer.complete()
-          worker.removeEventListener('message', messageHandler)
-        } else {
-          if (event.data.payload) {
-            observer.next(deserialize(event.data.payload))
-          }
-          if (event.data.complete) {
-            observer.complete()
-            worker.removeEventListener('message', messageHandler)
-          }
-        }
-      } else if (isJobErrorMessage(event.data)) {
-        const error = deserialize(event.data.error as any)
-        if (asyncType === 'promise' || !asyncType) {
-          observer.error(error)
-        } else {
-          observer.error(error)
-        }
-        worker.removeEventListener('message', messageHandler)
-      }
-    }) as EventListener
-
-    worker.addEventListener('message', messageHandler)
-
-    return () => {
-      if (asyncType === 'observable' || !asyncType) {
-        const cancelMessage: MasterJobCancelMessage = {
-          type: MasterMessageType.cancel,
-          uid: jobUID,
-        }
-        worker.postMessage(cancelMessage)
-      }
-      worker.removeEventListener('message', messageHandler)
-    }
-  })
-}
-
-function prepareArguments(rawArgs: any[]): { args: any[]; transferables: Transferable[] } {
-  if (rawArgs.length === 0) {
-    // Exit early if possible
-    return {
-      args: [],
-      transferables: [],
-    }
-  }
-
-  const args: any[] = []
-  const transferables: Transferable[] = []
-
-  for (const arg of rawArgs) {
-    if (isTransferDescriptor(arg)) {
-      args.push(serialize(arg.send))
-      transferables.push(...arg.transferables)
-    } else {
-      args.push(serialize(arg))
-    }
-  }
-
-  return {
-    args,
-    transferables: transferables.length === 0 ? transferables : dedupe(transferables),
-  }
-}
-
-export function createProxyFunction<Args extends any[], ReturnType>(worker: WorkerType, method?: string) {
-  return ((...rawArgs: Args) => {
-    const uid = nextJobUID++
-    const { args, transferables } = prepareArguments(rawArgs)
-    const runMessage: MasterJobRunMessage = {
-      args,
-      method,
-      type: MasterMessageType.run,
-      uid,
-    }
-
-    debugMessages('Sending command to run function to worker:', runMessage)
-
-    try {
-      worker.postMessage(runMessage, transferables)
-    } catch (error) {
-      return ObservablePromise.from(Promise.reject(error))
-    }
-
-    return ObservablePromise.from(multicast(createObservableForJob<ReturnType>(worker, uid)))
-  }) as any as ProxyableFunction<Args, ReturnType>
-}
-
-export function createProxyModule<Methods extends ModuleMethods>(worker: WorkerType, methodNames: string[]): ModuleProxy<Methods> {
-  const proxy: any = {}
-
-  for (const methodName of methodNames) {
-    proxy[methodName] = createProxyFunction(worker, methodName)
-  }
-
-  return proxy
-}

package/src/master/pool-types.ts

@@ -1,83 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/member-ordering */
-import type { Thread } from './thread'
-
-/** Pool event type. Specifies the type of each `PoolEvent`. */
-export enum PoolEventType {
-  initialized = 'initialized',
-  taskCanceled = 'taskCanceled',
-  taskCompleted = 'taskCompleted',
-  taskFailed = 'taskFailed',
-  taskQueued = 'taskQueued',
-  taskQueueDrained = 'taskQueueDrained',
-  taskStart = 'taskStart',
-  terminated = 'terminated',
-}
-
-export type TaskRunFunction<ThreadType extends Thread, Return> = (worker: ThreadType) => Promise<Return>
-
-/** 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.taskQueued
-    taskID: number
-  }
-  | {
-    type: PoolEventType.taskQueueDrained
-  }
-  | {
-    type: PoolEventType.taskStart
-    taskID: number
-    workerID: number
-  }
-  | {
-    type: PoolEventType.taskCompleted
-    returnValue: any
-    taskID: number
-    workerID: number
-  }
-  | {
-    type: PoolEventType.taskFailed
-    error: Error
-    taskID: number
-    workerID: number
-  }
-  | {
-    type: PoolEventType.taskCanceled
-    taskID: number
-  }
-  | {
-    type: PoolEventType.terminated
-    remainingQueue: Array<QueuedTask<ThreadType, any>>
-  }
-
-export interface WorkerDescriptor<ThreadType extends Thread> {
-  init: Promise<ThreadType>
-  runningTasks: Array<Promise<any>>
-}
-
-/**
- * Task that has been `pool.queued()`-ed.
- */
-export interface QueuedTask<ThreadType extends Thread, Return> {
-  /** @private */
-  id: number
-
-  /** @private */
-  run: TaskRunFunction<ThreadType, Return>
-
-  /**
-   * Queued tasks can be cancelled until the pool starts running them on a worker thread.
-   */
-  cancel(): void
-
-  /**
-   * `QueuedTask` is thenable, so you can `await` it.
-   * Resolves when the task has successfully been executed. Rejects if the task fails.
-   */
-  then: Promise<Return>['then']
-}