@xylabs/threads 4.6.4 → 4.7.0

package/dist/worker/index.js

@@ -1,174 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isWorkerRuntime = exports.Transfer = exports.registerSerializer = void 0;
-exports.expose = expose;
-const is_observable_2_1_0_1 = __importDefault(require("is-observable-2-1-0"));
-const common_1 = require("../common");
-const transferable_1 = require("../transferable");
-const messages_1 = require("../types/messages");
-const implementation_1 = __importDefault(require("./implementation"));
-var common_2 = require("../common");
-Object.defineProperty(exports, "registerSerializer", { enumerable: true, get: function () { return common_2.registerSerializer; } });
-var transferable_2 = require("../transferable");
-Object.defineProperty(exports, "Transfer", { enumerable: true, get: function () { return transferable_2.Transfer; } });
-exports.isWorkerRuntime = implementation_1.default.isWorkerRuntime;
-let exposeCalled = false;
-const activeSubscriptions = new Map();
-const isMasterJobCancelMessage = (thing) => thing && thing.type === messages_1.MasterMessageType.cancel;
-const isMasterJobRunMessage = (thing) => thing && thing.type === messages_1.MasterMessageType.run;
-const isObservable = (thing) => (0, is_observable_2_1_0_1.default)(thing) || isZenObservable(thing);
-function isZenObservable(thing) {
-    return thing && typeof thing === 'object' && typeof thing.subscribe === 'function';
-}
-function deconstructTransfer(thing) {
-    return (0, transferable_1.isTransferDescriptor)(thing) ? { payload: thing.send, transferables: thing.transferables } : { payload: thing, transferables: undefined };
-}
-function postFunctionInitMessage() {
-    const initMessage = {
-        exposed: { type: 'function' },
-        type: messages_1.WorkerMessageType.init,
-    };
-    implementation_1.default.postMessageToMaster(initMessage);
-}
-function postModuleInitMessage(methodNames) {
-    const initMessage = {
-        exposed: {
-            methods: methodNames,
-            type: 'module',
-        },
-        type: messages_1.WorkerMessageType.init,
-    };
-    implementation_1.default.postMessageToMaster(initMessage);
-}
-function postJobErrorMessage(uid, rawError) {
-    const { payload: error, transferables } = deconstructTransfer(rawError);
-    const errorMessage = {
-        error: (0, common_1.serialize)(error),
-        type: messages_1.WorkerMessageType.error,
-        uid,
-    };
-    implementation_1.default.postMessageToMaster(errorMessage, transferables);
-}
-function postJobResultMessage(uid, completed, resultValue) {
-    const { payload, transferables } = deconstructTransfer(resultValue);
-    const resultMessage = {
-        complete: completed ? true : undefined,
-        payload,
-        type: messages_1.WorkerMessageType.result,
-        uid,
-    };
-    implementation_1.default.postMessageToMaster(resultMessage, transferables);
-}
-function postJobStartMessage(uid, resultType) {
-    const startMessage = {
-        resultType,
-        type: messages_1.WorkerMessageType.running,
-        uid,
-    };
-    implementation_1.default.postMessageToMaster(startMessage);
-}
-function postUncaughtErrorMessage(error) {
-    try {
-        const errorMessage = {
-            error: (0, common_1.serialize)(error),
-            type: messages_1.WorkerMessageType.uncaughtError,
-        };
-        implementation_1.default.postMessageToMaster(errorMessage);
-    }
-    catch (subError) {
-        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, fn, args) {
-    let syncResult;
-    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, (0, common_1.serialize)(value)), (error) => {
-            postJobErrorMessage(jobUID, (0, common_1.serialize)(error));
-            activeSubscriptions.delete(jobUID);
-        }, () => {
-            postJobResultMessage(jobUID, true);
-            activeSubscriptions.delete(jobUID);
-        });
-        activeSubscriptions.set(jobUID, subscription);
-    }
-    else {
-        try {
-            const result = await syncResult;
-            postJobResultMessage(jobUID, true, (0, common_1.serialize)(result));
-        }
-        catch (error) {
-            postJobErrorMessage(jobUID, (0, common_1.serialize)(error));
-        }
-    }
-}
-function expose(exposed) {
-    if (!implementation_1.default.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_1.default.subscribeToMasterMessages((messageData) => {
-            if (isMasterJobRunMessage(messageData) && !messageData.method) {
-                runFunction(messageData.uid, exposed, messageData.args.map(common_1.deserialize));
-            }
-        });
-        postFunctionInitMessage();
-    }
-    else if (typeof exposed === 'object' && exposed) {
-        implementation_1.default.subscribeToMasterMessages((messageData) => {
-            if (isMasterJobRunMessage(messageData) && messageData.method) {
-                runFunction(messageData.uid, exposed[messageData.method], messageData.args.map(common_1.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_1.default.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_1.default.isWorkerRuntime()) {
-    self.addEventListener('error', (event) => {
-        setTimeout(() => postUncaughtErrorMessage(event.error || event), 250);
-    });
-    self.addEventListener('unhandledrejection', (event) => {
-        const error = event.reason;
-        if (error && typeof error.message === 'string') {
-            setTimeout(() => postUncaughtErrorMessage(error), 250);
-        }
-    });
-}
-if (typeof process !== 'undefined' && typeof process.on === 'function' && implementation_1.default.isWorkerRuntime()) {
-    process.on('uncaughtException', (error) => {
-        setTimeout(() => postUncaughtErrorMessage(error), 250);
-    });
-    process.on('unhandledRejection', (error) => {
-        if (error && typeof error.message === 'string') {
-            setTimeout(() => postUncaughtErrorMessage(error), 250);
-        }
-    });
-}

package/dist/worker_threads.d.ts

@@ -1,8 +0,0 @@
-type MessagePort = any;
-interface WorkerThreadsModule {
-    MessagePort: typeof MessagePort;
-    isMainThread: boolean;
-    parentPort: MessagePort;
-}
-export default function getImplementation(): WorkerThreadsModule;
-export {};

package/dist/worker_threads.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = getImplementation;
-let implementation;
-function selectImplementation() {
-    return typeof __non_webpack_require__ === 'function' ? __non_webpack_require__('worker_threads') : eval('require')('worker_threads');
-}
-function getImplementation() {
-    if (!implementation) {
-        implementation = selectImplementation();
-    }
-    return implementation;
-}

package/observable.d.ts

@@ -1,2 +0,0 @@
-// eslint-disable-next-line import-x/no-internal-modules
-export * from './dist/observable'

package/observable.js

@@ -1,2 +0,0 @@
-/* eslint-disable @typescript-eslint/no-require-imports */
-module.exports = require('./dist/observable')

package/observable.mjs

@@ -1,4 +0,0 @@
-import * as Observables from './dist/observable.js'
-
-export const Observable = Observables.Observable
-export const Subject = Observables.Subject

package/register.d.ts

@@ -1,2 +0,0 @@
-// eslint-disable-next-line import-x/no-internal-modules
-export * from './dist/master/register'

package/register.js

@@ -1,2 +0,0 @@
-/* eslint-disable @typescript-eslint/no-require-imports */
-require('./dist/master/register')

package/register.mjs

@@ -1 +0,0 @@
-import './dist/master/register.js'

package/rollup.config.js

@@ -1,16 +0,0 @@
-/* eslint-disable @typescript-eslint/no-require-imports */
-const commonjs = require('@rollup/plugin-commonjs')
-/* eslint-disable @typescript-eslint/no-require-imports */
-const { nodeResolve } = require('@rollup/plugin-node-resolve')
-
-module.exports = {
-  plugins: [
-    nodeResolve({
-      browser: true,
-      mainFields: ['module', 'main'],
-      preferBuiltins: true,
-    }),
-
-    commonjs(),
-  ],
-}

package/src/worker/bundle-entry.ts

@@ -1,10 +0,0 @@
-/* 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/implementation.tiny-worker.ts

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

@@ -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/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)
-  },
-}