@xylabs/threads/dist/node/master-DBU-F6eB.d.ts

Web workers & worker threads as simple as a function call

import { Observable, SubscriptionObserver, ObservableLike as ObservableLike$1 } from 'observable-fns';
import { $ as $errors, b as $events, c as $terminate, d as $worker, T as TransferDescriptor } from './transferable-Blu_CzPT.js';

type Initializer<T> = (observer: SubscriptionObserver<T>) => UnsubscribeFn | void;
type Thenable<T> = {
    then: (onFulfilled?: (value: T) => any, onRejected?: (error: any) => any) => any;
};
type UnsubscribeFn = () => void;
/**
 * Creates a hybrid, combining the APIs of an Observable and a Promise.
 *
 * It is used to proxy async process states when we are initially not sure
 * if that async process will yield values once (-> Promise) or multiple
 * times (-> Observable).
 *
 * Note that the observable promise inherits some of the observable's characteristics:
 * The `init` function will be called *once for every time anyone subscribes to it*.
 *
 * If this is undesired, derive a hot observable from it using `makeHot()` and
 * subscribe to that.
 */
declare class ObservablePromise<T> extends Observable<T> implements Promise<T> {
    readonly [Symbol.toStringTag] = "[object ObservablePromise]";
    private initHasRun;
    private fulfillmentCallbacks;
    private rejectionCallbacks;
    private firstValue;
    private firstValueSet;
    private rejection;
    private state;
    constructor(init: Initializer<T>);
    private onNext;
    private onError;
    private onCompletion;
    then<TResult1 = T, TResult2 = never>(onFulfilledRaw?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onRejectedRaw?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
    catch<Result = never>(onRejected: ((error: Error) => Promise<Result> | Result) | null | undefined): Promise<Result>;
    finally(onCompleted?: (() => void) | null | undefined): Promise<T>;
    static from<T>(thing: Observable<T> | ObservableLike$1<T> | ArrayLike<T> | Thenable<T>): ObservablePromise<T>;
}

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;
}
type StripAsync<Type> = Type extends Promise<infer PromiseBaseType> ? PromiseBaseType : Type extends ObservableLike<infer ObservableBaseType> ? ObservableBaseType : Type;
type StripTransfer<Type> = Type extends TransferDescriptor<infer BaseType> ? BaseType : Type;
type ModuleMethods = {
    [methodName: string]: (...args: any) => any;
};
type ProxyableArgs<Args extends any[]> = Args extends [arg0: infer Arg0, ...rest: infer RestArgs] ? [Arg0 extends Transferable ? Arg0 | TransferDescriptor<Arg0> : Arg0, ...RestArgs] : Args;
type ProxyableFunction<Args extends any[], ReturnType> = Args extends [] ? () => ObservablePromise<StripTransfer<StripAsync<ReturnType>>> : (...args: ProxyableArgs<Args>) => ObservablePromise<StripTransfer<StripAsync<ReturnType>>>;
type ModuleProxy<Methods extends ModuleMethods> = {
    [method in keyof Methods]: ProxyableFunction<Parameters<Methods[method]>, ReturnType<Methods[method]>>;
};
interface PrivateThreadProps {
    [$errors]: Observable<Error>;
    [$events]: Observable<WorkerEvent>;
    [$terminate]: () => Promise<void>;
    [$worker]: Worker;
}
type FunctionThread<Args extends any[] = any[], ReturnType = any> = ProxyableFunction<Args, ReturnType> & PrivateThreadProps;
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`. */
type Thread = AnyFunctionThread | AnyModuleThread;
type TransferList = Transferable[];
/** Worker instance. Either a web worker or a node.js Worker provided by `worker_threads` or `tiny-worker`. */
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>;
}
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. */
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. */
declare class BlobWorker extends WorkerImplementation {
    constructor(blob: Blob, options?: ThreadsWorkerOptions);
    static fromText(source: string, options?: ThreadsWorkerOptions): WorkerImplementation;
}
interface ImplementationExport {
    blob: typeof BlobWorker;
    default: typeof WorkerImplementation;
}
/** Event as emitted by worker thread. Subscribe to using `Thread.events(thread)`. */
declare enum WorkerEventType {
    internalError = "internalError",
    message = "message",
    termination = "termination"
}
interface WorkerInternalErrorEvent {
    error: Error;
    type: WorkerEventType.internalError;
}
interface WorkerMessageEvent<Data> {
    data: Data;
    type: WorkerEventType.message;
}
interface WorkerTerminationEvent {
    type: WorkerEventType.termination;
}
type WorkerEvent = WorkerInternalErrorEvent | WorkerMessageEvent<any> | WorkerTerminationEvent;

export { BlobWorker as B, type FunctionThread as F, type ImplementationExport as I, type ModuleThread as M, type StripAsync as S, type Thread as T, type WorkerEvent as W, type Worker as a, WorkerImplementation as b };