@xylabs/threads 3.0.4

package/dist/observable.d.ts

@@ -0,0 +1,19 @@
+import { Observable, ObservableLike } from 'observable-fns';
+declare const $observers: unique symbol;
+/**
+ * Observable subject. Implements the Observable interface, but also exposes
+ * the `next()`, `error()`, `complete()` methods to initiate observable
+ * updates "from the outside".
+ *
+ * Use `Observable.from(subject)` to derive an observable that proxies all
+ * values, errors and the completion raised on this subject, but does not
+ * expose the `next()`, `error()`, `complete()` methods.
+ */
+export declare class Subject<T> extends Observable<T> implements ObservableLike<T> {
+    private [$observers];
+    constructor();
+    complete(): void;
+    error(error: any): void;
+    next(value: T): void;
+}
+export { Observable } from 'observable-fns';

package/dist/observable.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Observable = exports.Subject = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const observable_fns_1 = require("observable-fns");
+const $observers = Symbol('observers');
+/**
+ * Observable subject. Implements the Observable interface, but also exposes
+ * the `next()`, `error()`, `complete()` methods to initiate observable
+ * updates "from the outside".
+ *
+ * Use `Observable.from(subject)` to derive an observable that proxies all
+ * values, errors and the completion raised on this subject, but does not
+ * expose the `next()`, `error()`, `complete()` methods.
+ */
+class Subject extends observable_fns_1.Observable {
+    [$observers];
+    constructor() {
+        super((observer) => {
+            this[$observers] = [...(this[$observers] || []), observer];
+            const unsubscribe = () => {
+                this[$observers] = this[$observers].filter((someObserver) => someObserver !== observer);
+            };
+            return unsubscribe;
+        });
+        this[$observers] = [];
+    }
+    complete() {
+        for (const observer of this[$observers])
+            observer.complete();
+    }
+    error(error) {
+        for (const observer of this[$observers])
+            observer.error(error);
+    }
+    next(value) {
+        for (const observer of this[$observers])
+            observer.next(value);
+    }
+}
+exports.Subject = Subject;
+var observable_fns_2 = require("observable-fns");
+Object.defineProperty(exports, "Observable", { enumerable: true, get: function () { return observable_fns_2.Observable; } });

package/dist/ponyfills.d.ts

@@ -0,0 +1,8 @@
+export type SettlementResult<T> = {
+    status: 'fulfilled';
+    value: T;
+} | {
+    reason: any;
+    status: 'rejected';
+};
+export declare function allSettled<T>(values: T[]): Promise<Array<SettlementResult<T>>>;

package/dist/ponyfills.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allSettled = void 0;
+// Based on <https://github.com/es-shims/Promise.allSettled/blob/master/implementation.js>
+function allSettled(values) {
+    return Promise.all(values.map((item) => {
+        const onFulfill = (value) => {
+            return { status: 'fulfilled', value };
+        };
+        const onReject = (reason) => {
+            return { reason, status: 'rejected' };
+        };
+        const itemPromise = Promise.resolve(item);
+        try {
+            return itemPromise.then(onFulfill, onReject);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }));
+}
+exports.allSettled = allSettled;

package/dist/promise.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Creates a new promise and exposes its resolver function.
+ * Use with care!
+ */
+export declare function createPromiseWithResolver<T>(): [Promise<T>, (result: T) => void];

package/dist/promise.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPromiseWithResolver = void 0;
+// eslint-disable-next-line unicorn/no-useless-undefined
+const doNothing = () => undefined;
+/**
+ * Creates a new promise and exposes its resolver function.
+ * Use with care!
+ */
+function createPromiseWithResolver() {
+    let alreadyResolved = false;
+    let resolvedTo;
+    let resolver = doNothing;
+    const promise = new Promise((resolve) => {
+        if (alreadyResolved) {
+            resolve(resolvedTo);
+        }
+        else {
+            resolver = resolve;
+        }
+    });
+    const exposedResolver = (value) => {
+        alreadyResolved = true;
+        resolvedTo = value;
+        resolver(resolvedTo);
+    };
+    return [promise, exposedResolver];
+}
+exports.createPromiseWithResolver = createPromiseWithResolver;

package/dist/serializers.d.ts

@@ -0,0 +1,16 @@
+export interface Serializer<Msg = JsonSerializable, Input = any> {
+    deserialize(message: Msg): Input;
+    serialize(input: Input): Msg;
+}
+export interface SerializerImplementation<Msg = JsonSerializable, Input = any> {
+    deserialize(message: Msg, defaultDeserialize: (msg: Msg) => Input): Input;
+    serialize(input: Input, defaultSerialize: (inp: Input) => Msg): Msg;
+}
+export declare function extendSerializer<MessageType, InputType = any>(extend: Serializer<MessageType, InputType>, implementation: SerializerImplementation<MessageType, InputType>): Serializer<MessageType, InputType>;
+type JsonSerializablePrimitive = string | number | boolean | null;
+type JsonSerializableObject = {
+    [key: string]: JsonSerializablePrimitive | JsonSerializablePrimitive[] | JsonSerializableObject | JsonSerializableObject[] | undefined;
+};
+export type JsonSerializable = JsonSerializablePrimitive | JsonSerializablePrimitive[] | JsonSerializableObject | JsonSerializableObject[];
+export declare const DefaultSerializer: Serializer<JsonSerializable>;
+export {};

package/dist/serializers.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultSerializer = exports.extendSerializer = void 0;
+function extendSerializer(extend, implementation) {
+    const fallbackDeserializer = extend.deserialize.bind(extend);
+    const fallbackSerializer = extend.serialize.bind(extend);
+    return {
+        deserialize(message) {
+            return implementation.deserialize(message, fallbackDeserializer);
+        },
+        serialize(input) {
+            return implementation.serialize(input, fallbackSerializer);
+        },
+    };
+}
+exports.extendSerializer = extendSerializer;
+const DefaultErrorSerializer = {
+    deserialize(message) {
+        return Object.assign(Error(message.message), {
+            name: message.name,
+            stack: message.stack,
+        });
+    },
+    serialize(error) {
+        return {
+            __error_marker: '$$error',
+            message: error.message,
+            name: error.name,
+            stack: error.stack,
+        };
+    },
+};
+const isSerializedError = (thing) => thing && typeof thing === 'object' && '__error_marker' in thing && thing.__error_marker === '$$error';
+exports.DefaultSerializer = {
+    deserialize(message) {
+        return isSerializedError(message) ? DefaultErrorSerializer.deserialize(message) : message;
+    },
+    serialize(input) {
+        return input instanceof Error ? DefaultErrorSerializer.serialize(input) : input;
+    },
+};

package/dist/symbols.d.ts

@@ -0,0 +1,5 @@
+export declare const $errors: unique symbol;
+export declare const $events: unique symbol;
+export declare const $terminate: unique symbol;
+export declare const $transferable: unique symbol;
+export declare const $worker: unique symbol;

package/dist/symbols.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$worker = exports.$transferable = exports.$terminate = exports.$events = exports.$errors = void 0;
+exports.$errors = Symbol('thread.errors');
+exports.$events = Symbol('thread.events');
+exports.$terminate = Symbol('thread.terminate');
+exports.$transferable = Symbol('thread.transferable');
+exports.$worker = Symbol('thread.worker');

package/dist/transferable.d.ts

@@ -0,0 +1,42 @@
+import { $transferable } from './symbols';
+export interface TransferDescriptor<T = any> {
+    [$transferable]: true;
+    send: T;
+    transferables: Transferable[];
+}
+export declare function isTransferDescriptor(thing: any): thing is TransferDescriptor;
+/**
+ * Mark a transferable object as such, so it will no be serialized and
+ * deserialized on messaging with the main thread, but to transfer
+ * ownership of it to the receiving thread.
+ *
+ * Only works with array buffers, message ports and few more special
+ * types of objects, but it's much faster than serializing and
+ * deserializing them.
+ *
+ * Note:
+ * The transferable object cannot be accessed by this thread again
+ * unless the receiving thread transfers it back again!
+ *
+ * @param transferable Array buffer, message port or similar.
+ * @see <https://developers.google.com/web/updates/2011/12/Transferable-Objects-Lightning-Fast>
+ */
+export declare function Transfer(transferable: Transferable): TransferDescriptor;
+/**
+ * Mark transferable objects within an arbitrary object or array as
+ * being a transferable object. They will then not be serialized
+ * and deserialized on messaging with the main thread, but ownership
+ * of them will be tranferred to the receiving thread.
+ *
+ * Only array buffers, message ports and few more special types of
+ * objects can be transferred, but it's much faster than serializing and
+ * deserializing them.
+ *
+ * Note:
+ * The transferable object cannot be accessed by this thread again
+ * unless the receiving thread transfers it back again!
+ *
+ * @param transferable Array buffer, message port or similar.
+ * @see <https://developers.google.com/web/updates/2011/12/Transferable-Objects-Lightning-Fast>
+ */
+export declare function Transfer<T>(payload: T, transferables: Transferable[]): TransferDescriptor;

package/dist/transferable.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transfer = exports.isTransferDescriptor = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const symbols_1 = require("./symbols");
+function isTransferable(thing) {
+    if (!thing || typeof thing !== 'object')
+        return false;
+    // Don't check too thoroughly, since the list of transferable things in JS might grow over time
+    return true;
+}
+function isTransferDescriptor(thing) {
+    return thing && typeof thing === 'object' && thing[symbols_1.$transferable];
+}
+exports.isTransferDescriptor = isTransferDescriptor;
+function Transfer(payload, transferables) {
+    if (!transferables) {
+        if (!isTransferable(payload))
+            throw new Error('Not transferable');
+        transferables = [payload];
+    }
+    return {
+        [symbols_1.$transferable]: true,
+        send: payload,
+        transferables,
+    };
+}
+exports.Transfer = Transfer;

package/dist/types/master.d.ts

@@ -0,0 +1,99 @@
+/// <reference lib="dom" />
+import { Observable } from 'observable-fns';
+import { ObservablePromise } from '../observable-promise';
+import { $errors, $events, $terminate, $worker } from '../symbols';
+import { TransferDescriptor } from '../transferable';
+interface ObservableLikeSubscription {
+    unsubscribe(): any;
+}
+interface ObservableLike<T> {
+    subscribe(onNext: (value: T) => any, onError?: (error: any) => any, onComplete?: () => any): ObservableLikeSubscription;
+    subscribe(listeners: {
+        complete?(): any;
+        error?(error: any): any;
+        next?(value: T): any;
+    }): ObservableLikeSubscription;
+}
+export type StripAsync<Type> = Type extends Promise<infer PromiseBaseType> ? PromiseBaseType : Type extends ObservableLike<infer ObservableBaseType> ? ObservableBaseType : Type;
+export type StripTransfer<Type> = Type extends TransferDescriptor<infer BaseType> ? BaseType : Type;
+export type ModuleMethods = {
+    [methodName: string]: (...args: any) => any;
+};
+export type ProxyableArgs<Args extends any[]> = Args extends [arg0: infer Arg0, ...rest: infer RestArgs] ? [Arg0 extends Transferable ? Arg0 | TransferDescriptor<Arg0> : Arg0, ...RestArgs] : Args;
+export type ProxyableFunction<Args extends any[], ReturnType> = Args extends [] ? () => ObservablePromise<StripTransfer<StripAsync<ReturnType>>> : (...args: ProxyableArgs<Args>) => ObservablePromise<StripTransfer<StripAsync<ReturnType>>>;
+export type ModuleProxy<Methods extends ModuleMethods> = {
+    [method in keyof Methods]: ProxyableFunction<Parameters<Methods[method]>, ReturnType<Methods[method]>>;
+};
+export interface PrivateThreadProps {
+    [$errors]: Observable<Error>;
+    [$events]: Observable<WorkerEvent>;
+    [$terminate]: () => Promise<void>;
+    [$worker]: Worker;
+}
+export type FunctionThread<Args extends any[] = any[], ReturnType = any> = ProxyableFunction<Args, ReturnType> & PrivateThreadProps;
+export type ModuleThread<Methods extends ModuleMethods = any> = ModuleProxy<Methods> & PrivateThreadProps;
+interface AnyFunctionThread extends PrivateThreadProps {
+    (...args: any[]): ObservablePromise<any>;
+}
+interface AnyModuleThread extends PrivateThreadProps {
+}
+/** Worker thread. Either a `FunctionThread` or a `ModuleThread`. */
+export type Thread = AnyFunctionThread | AnyModuleThread;
+export type TransferList = Transferable[];
+/** Worker instance. Either a web worker or a node.js Worker provided by `worker_threads` or `tiny-worker`. */
+export interface Worker extends EventTarget {
+    postMessage(value: any, transferList?: TransferList): void;
+    /** In nodejs 10+ return type is Promise while with tiny-worker and in browser return type is void */
+    terminate(callback?: (error?: Error, exitCode?: number) => void): void | Promise<number>;
+}
+export interface ThreadsWorkerOptions extends WorkerOptions {
+    /** Whether to apply CORS protection workaround. Defaults to true. */
+    CORSWorkaround?: boolean;
+    /** Prefix for the path passed to the Worker constructor. Web worker only. */
+    _baseURL?: string;
+    /** Resource limits passed on to Node worker_threads */
+    resourceLimits?: {
+        /** The size of a pre-allocated memory range used for generated code. */
+        codeRangeSizeMb?: number;
+        /** The maximum size of the main heap in MB. */
+        maxOldGenerationSizeMb?: number;
+        /** The maximum size of a heap space for recently created objects. */
+        maxYoungGenerationSizeMb?: number;
+    };
+    /** Data passed on to node.js worker_threads. */
+    workerData?: any;
+}
+/** Worker implementation. Either web worker or a node.js Worker class. */
+export declare class WorkerImplementation extends EventTarget implements Worker {
+    constructor(path: string, options?: ThreadsWorkerOptions);
+    postMessage(value: any, transferList?: TransferList): void;
+    terminate(): void | Promise<number>;
+}
+/** Class to spawn workers from a blob or source string. */
+export declare class BlobWorker extends WorkerImplementation {
+    constructor(blob: Blob, options?: ThreadsWorkerOptions);
+    static fromText(source: string, options?: ThreadsWorkerOptions): WorkerImplementation;
+}
+export interface ImplementationExport {
+    blob: typeof BlobWorker;
+    default: typeof WorkerImplementation;
+}
+/** Event as emitted by worker thread. Subscribe to using `Thread.events(thread)`. */
+export declare enum WorkerEventType {
+    internalError = "internalError",
+    message = "message",
+    termination = "termination"
+}
+export interface WorkerInternalErrorEvent {
+    error: Error;
+    type: WorkerEventType.internalError;
+}
+export interface WorkerMessageEvent<Data> {
+    data: Data;
+    type: WorkerEventType.message;
+}
+export interface WorkerTerminationEvent {
+    type: WorkerEventType.termination;
+}
+export type WorkerEvent = WorkerInternalErrorEvent | WorkerMessageEvent<any> | WorkerTerminationEvent;
+export {};

package/dist/types/master.js

@@ -0,0 +1,14 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/// <reference lib="dom" />
+// tslint:disable max-classes-per-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerEventType = void 0;
+const symbols_1 = require("../symbols");
+/** Event as emitted by worker thread. Subscribe to using `Thread.events(thread)`. */
+var WorkerEventType;
+(function (WorkerEventType) {
+    WorkerEventType["internalError"] = "internalError";
+    WorkerEventType["message"] = "message";
+    WorkerEventType["termination"] = "termination";
+})(WorkerEventType || (exports.WorkerEventType = WorkerEventType = {}));

package/dist/types/messages.d.ts

@@ -0,0 +1,62 @@
+export interface SerializedError {
+    __error_marker: '$$error';
+    message: string;
+    name: string;
+    stack?: string;
+}
+export declare enum MasterMessageType {
+    cancel = "cancel",
+    run = "run"
+}
+export type MasterJobCancelMessage = {
+    type: MasterMessageType.cancel;
+    uid: number;
+};
+export type MasterJobRunMessage = {
+    type: MasterMessageType.run;
+    uid: number;
+    method?: string;
+    args: any[];
+};
+export type MasterSentMessage = MasterJobCancelMessage | MasterJobRunMessage;
+export declare enum WorkerMessageType {
+    error = "error",
+    init = "init",
+    result = "result",
+    running = "running",
+    uncaughtError = "uncaughtError"
+}
+export type WorkerUncaughtErrorMessage = {
+    type: WorkerMessageType.uncaughtError;
+    error: {
+        message: string;
+        name: string;
+        stack?: string;
+    };
+};
+export type WorkerInitMessage = {
+    type: WorkerMessageType.init;
+    exposed: {
+        type: 'function';
+    } | {
+        type: 'module';
+        methods: string[];
+    };
+};
+export type WorkerJobErrorMessage = {
+    type: WorkerMessageType.error;
+    uid: number;
+    error: SerializedError;
+};
+export type WorkerJobResultMessage = {
+    type: WorkerMessageType.result;
+    uid: number;
+    complete?: true;
+    payload?: any;
+};
+export type WorkerJobStartMessage = {
+    type: WorkerMessageType.running;
+    uid: number;
+    resultType: 'observable' | 'promise';
+};
+export type WorkerSentMessage = WorkerInitMessage | WorkerJobErrorMessage | WorkerJobResultMessage | WorkerJobStartMessage | WorkerUncaughtErrorMessage;

package/dist/types/messages.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerMessageType = exports.MasterMessageType = void 0;
+/////////////////////////////
+// Messages sent by master:
+var MasterMessageType;
+(function (MasterMessageType) {
+    MasterMessageType["cancel"] = "cancel";
+    MasterMessageType["run"] = "run";
+})(MasterMessageType || (exports.MasterMessageType = MasterMessageType = {}));
+////////////////////////////
+// Messages sent by worker:
+var WorkerMessageType;
+(function (WorkerMessageType) {
+    WorkerMessageType["error"] = "error";
+    WorkerMessageType["init"] = "init";
+    WorkerMessageType["result"] = "result";
+    WorkerMessageType["running"] = "running";
+    WorkerMessageType["uncaughtError"] = "uncaughtError";
+})(WorkerMessageType || (exports.WorkerMessageType = WorkerMessageType = {}));

package/dist/types/worker.d.ts

@@ -0,0 +1,11 @@
+type UnsubscribeFn = () => void;
+export interface AbstractedWorkerAPI {
+    isWorkerRuntime(): boolean;
+    postMessageToMaster(message: any, transferList?: Transferable[]): void;
+    subscribeToMasterMessages(onMessage: (data: any) => void): UnsubscribeFn;
+}
+export type WorkerFunction = ((...args: any[]) => any) | (() => any);
+export type WorkerModule<Keys extends string> = {
+    [key in Keys]: WorkerFunction;
+};
+export {};

package/dist/types/worker.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/worker/bundle-entry.d.ts

@@ -0,0 +1 @@
+export * from './index';

package/dist/worker/bundle-entry.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const index_1 = require("./index");
+__exportStar(require("./index"), exports);
+if (typeof global !== 'undefined') {
+    ;
+    global.expose = index_1.expose;
+}
+if (typeof self !== 'undefined') {
+    ;
+    self.expose = index_1.expose;
+}

package/dist/worker/implementation.browser.d.ts

@@ -0,0 +1,7 @@
+/// <reference lib="dom" />
+declare const _default: {
+    isWorkerRuntime: () => boolean;
+    postMessageToMaster: (message: any, transferList?: Transferable[] | undefined) => void;
+    subscribeToMasterMessages: (onMessage: (data: any) => void) => () => void;
+};
+export default _default;

package/dist/worker/implementation.browser.js

@@ -0,0 +1,28 @@
+"use strict";
+/* eslint-disable import/no-default-export */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/// <reference lib="dom" />
+// tslint:disable no-shadowed-variable
+Object.defineProperty(exports, "__esModule", { value: true });
+const isWorkerRuntime = function isWorkerRuntime() {
+    const isWindowContext = self !== undefined && typeof Window !== 'undefined' && self instanceof Window;
+    return self !== undefined && self['postMessage'] && !isWindowContext ? true : false;
+};
+const postMessageToMaster = function postMessageToMaster(data, transferList) {
+    self.postMessage(data, transferList);
+};
+const subscribeToMasterMessages = function subscribeToMasterMessages(onMessage) {
+    const messageHandler = (messageEvent) => {
+        onMessage(messageEvent.data);
+    };
+    const unsubscribe = () => {
+        self.removeEventListener('message', messageHandler);
+    };
+    self.addEventListener('message', messageHandler);
+    return unsubscribe;
+};
+exports.default = {
+    isWorkerRuntime,
+    postMessageToMaster,
+    subscribeToMasterMessages,
+};

package/dist/worker/implementation.d.ts

@@ -0,0 +1,3 @@
+import { AbstractedWorkerAPI } from '../types/worker';
+declare const _default: AbstractedWorkerAPI;
+export default _default;

package/dist/worker/implementation.js

@@ -0,0 +1,24 @@
+"use strict";
+/* eslint-disable import/no-default-export */
+// tslint:disable no-var-requires
+/*
+ * This file is only a stub to make './implementation' resolve to the right module.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const implementation_browser_1 = __importDefault(require("./implementation.browser"));
+const implementation_tiny_worker_1 = __importDefault(require("./implementation.tiny-worker"));
+const implementation_worker_threads_1 = __importDefault(require("./implementation.worker_threads"));
+const runningInNode = typeof process !== 'undefined' && process.arch !== 'browser' && 'pid' in process;
+function selectNodeImplementation() {
+    try {
+        implementation_worker_threads_1.default.testImplementation();
+        return implementation_worker_threads_1.default;
+    }
+    catch {
+        return implementation_tiny_worker_1.default;
+    }
+}
+exports.default = runningInNode ? selectNodeImplementation() : implementation_browser_1.default;

package/dist/worker/implementation.tiny-worker.d.ts

@@ -0,0 +1,7 @@
+/// <reference lib="dom" />
+declare const _default: {
+    isWorkerRuntime: () => boolean;
+    postMessageToMaster: (message: any, transferList?: Transferable[] | undefined) => void;
+    subscribeToMasterMessages: (onMessage: (data: any) => void) => () => void;
+};
+export default _default;

package/dist/worker/implementation.tiny-worker.js

@@ -0,0 +1,38 @@
+"use strict";
+/* eslint-disable import/no-default-export */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/// <reference lib="dom" />
+// tslint:disable no-shadowed-variable
+Object.defineProperty(exports, "__esModule", { value: true });
+if (self === undefined) {
+    ;
+    global.self = global;
+}
+const isWorkerRuntime = function isWorkerRuntime() {
+    return self !== undefined && self['postMessage'] ? true : false;
+};
+const 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();
+const 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) => {
+            for (const handler of messageHandlers)
+                handler(event.data);
+        }));
+        muxingHandlerSetUp = true;
+    }
+    messageHandlers.add(onMessage);
+    const unsubscribe = () => messageHandlers.delete(onMessage);
+    return unsubscribe;
+};
+exports.default = {
+    isWorkerRuntime,
+    postMessageToMaster,
+    subscribeToMasterMessages,
+};

package/dist/worker/implementation.worker_threads.d.ts

@@ -0,0 +1,8 @@
+declare function testImplementation(): void;
+declare const _default: {
+    isWorkerRuntime: () => boolean;
+    postMessageToMaster: (message: any, transferList?: Transferable[] | undefined) => void;
+    subscribeToMasterMessages: (onMessage: (data: any) => void) => () => void;
+    testImplementation: typeof testImplementation;
+};
+export default _default;