@xylabs/threads 3.0.4

package/dist/master/pool.js

@@ -0,0 +1,281 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Thread = exports.PoolEventType = exports.Pool = void 0;
+/* eslint-disable unicorn/no-thenable */
+/* eslint-disable @typescript-eslint/no-floating-promises */
+/* eslint-disable require-await */
+/* eslint-disable @typescript-eslint/member-ordering */
+/* eslint-disable unicorn/no-array-reduce */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable import/export */
+/* eslint-disable @typescript-eslint/no-namespace */
+const debug_1 = __importDefault(require("debug"));
+const observable_fns_1 = require("observable-fns");
+const ponyfills_1 = require("../ponyfills");
+const implementation_1 = require("./implementation");
+const pool_types_1 = require("./pool-types");
+const thread_1 = require("./thread");
+let nextPoolID = 1;
+function createArray(size) {
+    const array = [];
+    for (let index = 0; index < size; index++) {
+        array.push(index);
+    }
+    return array;
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function flatMap(array, mapper) {
+    return array.reduce((flattened, element) => [...flattened, ...mapper(element)], []);
+}
+function slugify(text) {
+    return text.replaceAll(/\W/g, ' ').trim().replaceAll(/\s+/g, '-');
+}
+function spawnWorkers(spawnWorker, count) {
+    return createArray(count).map(() => ({
+        init: spawnWorker(),
+        runningTasks: [],
+    }));
+}
+class WorkerPool {
+    static EventType = pool_types_1.PoolEventType;
+    debug;
+    eventObservable;
+    options;
+    workers;
+    eventSubject = new observable_fns_1.Subject();
+    initErrors = [];
+    isClosing = false;
+    nextTaskID = 1;
+    taskQueue = [];
+    constructor(spawnWorker, optionsOrSize) {
+        const options = typeof optionsOrSize === 'number' ? { size: optionsOrSize } : optionsOrSize || {};
+        const { size = implementation_1.defaultPoolSize } = options;
+        this.debug = (0, debug_1.default)(`threads:pool:${slugify(options.name || String(nextPoolID++))}`);
+        this.options = options;
+        this.workers = spawnWorkers(spawnWorker, size);
+        this.eventObservable = (0, observable_fns_1.multicast)(observable_fns_1.Observable.from(this.eventSubject));
+        Promise.all(this.workers.map((worker) => worker.init)).then(() => this.eventSubject.next({
+            size: this.workers.length,
+            type: pool_types_1.PoolEventType.initialized,
+        }), (error) => {
+            this.debug('Error while initializing pool worker:', error);
+            this.eventSubject.error(error);
+            this.initErrors.push(error);
+        });
+    }
+    findIdlingWorker() {
+        const { concurrency = 1 } = this.options;
+        return this.workers.find((worker) => worker.runningTasks.length < concurrency);
+    }
+    async runPoolTask(worker, task) {
+        const workerID = this.workers.indexOf(worker) + 1;
+        this.debug(`Running task #${task.id} on worker #${workerID}...`);
+        this.eventSubject.next({
+            taskID: task.id,
+            type: pool_types_1.PoolEventType.taskStart,
+            workerID,
+        });
+        try {
+            const returnValue = await task.run(await worker.init);
+            this.debug(`Task #${task.id} completed successfully`);
+            this.eventSubject.next({
+                returnValue,
+                taskID: task.id,
+                type: pool_types_1.PoolEventType.taskCompleted,
+                workerID,
+            });
+        }
+        catch (error) {
+            this.debug(`Task #${task.id} failed`);
+            this.eventSubject.next({
+                error,
+                taskID: task.id,
+                type: pool_types_1.PoolEventType.taskFailed,
+                workerID,
+            });
+        }
+    }
+    async run(worker, task) {
+        const runPromise = (async () => {
+            const removeTaskFromWorkersRunningTasks = () => {
+                worker.runningTasks = worker.runningTasks.filter((someRunPromise) => someRunPromise !== runPromise);
+            };
+            // Defer task execution by one tick to give handlers time to subscribe
+            await delay(0);
+            try {
+                await this.runPoolTask(worker, task);
+            }
+            finally {
+                removeTaskFromWorkersRunningTasks();
+                if (!this.isClosing) {
+                    this.scheduleWork();
+                }
+            }
+        })();
+        worker.runningTasks.push(runPromise);
+    }
+    scheduleWork() {
+        this.debug('Attempt de-queueing a task in order to run it...');
+        const availableWorker = this.findIdlingWorker();
+        if (!availableWorker)
+            return;
+        const nextTask = this.taskQueue.shift();
+        if (!nextTask) {
+            this.debug('Task queue is empty');
+            this.eventSubject.next({ type: pool_types_1.PoolEventType.taskQueueDrained });
+            return;
+        }
+        this.run(availableWorker, nextTask);
+    }
+    taskCompletion(taskID) {
+        return new Promise((resolve, reject) => {
+            const eventSubscription = this.events().subscribe((event) => {
+                if (event.type === pool_types_1.PoolEventType.taskCompleted && event.taskID === taskID) {
+                    eventSubscription.unsubscribe();
+                    resolve(event.returnValue);
+                }
+                else if (event.type === pool_types_1.PoolEventType.taskFailed && event.taskID === taskID) {
+                    eventSubscription.unsubscribe();
+                    reject(event.error);
+                }
+                else if (event.type === pool_types_1.PoolEventType.terminated) {
+                    eventSubscription.unsubscribe();
+                    reject(Error('Pool has been terminated before task was run.'));
+                }
+            });
+        });
+    }
+    async settled(allowResolvingImmediately = false) {
+        const getCurrentlyRunningTasks = () => flatMap(this.workers, (worker) => worker.runningTasks);
+        const taskFailures = [];
+        const failureSubscription = this.eventObservable.subscribe((event) => {
+            if (event.type === pool_types_1.PoolEventType.taskFailed) {
+                taskFailures.push(event.error);
+            }
+        });
+        if (this.initErrors.length > 0) {
+            throw this.initErrors[0];
+        }
+        if (allowResolvingImmediately && this.taskQueue.length === 0) {
+            await (0, ponyfills_1.allSettled)(getCurrentlyRunningTasks());
+            return taskFailures;
+        }
+        await new Promise((resolve, reject) => {
+            const subscription = this.eventObservable.subscribe({
+                error: reject,
+                next(event) {
+                    if (event.type === pool_types_1.PoolEventType.taskQueueDrained) {
+                        subscription.unsubscribe();
+                        resolve(void 0);
+                    }
+                }, // make a pool-wide error reject the completed() result promise
+            });
+        });
+        await (0, ponyfills_1.allSettled)(getCurrentlyRunningTasks());
+        failureSubscription.unsubscribe();
+        return taskFailures;
+    }
+    async completed(allowResolvingImmediately = false) {
+        const settlementPromise = this.settled(allowResolvingImmediately);
+        const earlyExitPromise = new Promise((resolve, reject) => {
+            const subscription = this.eventObservable.subscribe({
+                error: reject,
+                next(event) {
+                    if (event.type === pool_types_1.PoolEventType.taskQueueDrained) {
+                        subscription.unsubscribe();
+                        resolve(settlementPromise);
+                    }
+                    else if (event.type === pool_types_1.PoolEventType.taskFailed) {
+                        subscription.unsubscribe();
+                        reject(event.error);
+                    }
+                }, // make a pool-wide error reject the completed() result promise
+            });
+        });
+        const errors = await Promise.race([settlementPromise, earlyExitPromise]);
+        if (errors.length > 0) {
+            throw errors[0];
+        }
+    }
+    events() {
+        return this.eventObservable;
+    }
+    queue(taskFunction) {
+        const { maxQueuedJobs = Number.POSITIVE_INFINITY } = this.options;
+        if (this.isClosing) {
+            throw new Error('Cannot schedule pool tasks after terminate() has been called.');
+        }
+        if (this.initErrors.length > 0) {
+            throw this.initErrors[0];
+        }
+        const taskID = this.nextTaskID++;
+        const taskCompletion = this.taskCompletion(taskID);
+        taskCompletion.catch((error) => {
+            // Prevent unhandled rejections here as we assume the user will use
+            // `pool.completed()`, `pool.settled()` or `task.catch()` to handle errors
+            this.debug(`Task #${taskID} errored:`, error);
+        });
+        const task = {
+            cancel: () => {
+                if (!this.taskQueue.includes(task))
+                    return;
+                this.taskQueue = this.taskQueue.filter((someTask) => someTask !== task);
+                this.eventSubject.next({
+                    taskID: task.id,
+                    type: pool_types_1.PoolEventType.taskCanceled,
+                });
+            },
+            id: taskID,
+            run: taskFunction,
+            then: taskCompletion.then.bind(taskCompletion),
+        };
+        if (this.taskQueue.length >= maxQueuedJobs) {
+            throw new Error('Maximum number of pool tasks queued. Refusing to queue another one.\n' +
+                'This usually happens for one of two reasons: We are either at peak ' +
+                "workload right now or some tasks just won't finish, thus blocking the pool.");
+        }
+        this.debug(`Queueing task #${task.id}...`);
+        this.taskQueue.push(task);
+        this.eventSubject.next({
+            taskID: task.id,
+            type: pool_types_1.PoolEventType.taskQueued,
+        });
+        this.scheduleWork();
+        return task;
+    }
+    async terminate(force) {
+        this.isClosing = true;
+        if (!force) {
+            await this.completed(true);
+        }
+        this.eventSubject.next({
+            remainingQueue: [...this.taskQueue],
+            type: pool_types_1.PoolEventType.terminated,
+        });
+        this.eventSubject.complete();
+        await Promise.all(this.workers.map(async (worker) => thread_1.Thread.terminate(await worker.init)));
+    }
+}
+/**
+ * Thread pool constructor. Creates a new pool and spawns its worker threads.
+ */
+function PoolConstructor(spawnWorker, optionsOrSize) {
+    // The function exists only so we don't need to use `new` to create a pool (we still can, though).
+    // If the Pool is a class or not is an implementation detail that should not concern the user.
+    return new WorkerPool(spawnWorker, optionsOrSize);
+}
+;
+PoolConstructor.EventType = pool_types_1.PoolEventType;
+/**
+ * Thread pool constructor. Creates a new pool and spawns its worker threads.
+ */
+exports.Pool = PoolConstructor;
+var pool_types_2 = require("./pool-types");
+Object.defineProperty(exports, "PoolEventType", { enumerable: true, get: function () { return pool_types_2.PoolEventType; } });
+var thread_2 = require("./thread");
+Object.defineProperty(exports, "Thread", { enumerable: true, get: function () { return thread_2.Thread; } });

package/dist/master/register.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/master/register.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const index_1 = require("./index");
+if (typeof global !== 'undefined') {
+    ;
+    global.Worker = index_1.Worker;
+}
+else if (window !== undefined) {
+    ;
+    window.Worker = index_1.Worker;
+}

package/dist/master/spawn.d.ts

@@ -0,0 +1,20 @@
+import { FunctionThread, ModuleThread, StripAsync, Worker as WorkerType } from '../types/master';
+import { WorkerFunction, WorkerModule } from '../types/worker';
+type ArbitraryWorkerInterface = WorkerFunction & WorkerModule<string> & {
+    somekeythatisneverusedinproductioncode123: 'magicmarker123';
+};
+type ArbitraryThreadType = FunctionThread<any, any> & ModuleThread<any>;
+export type ExposedToThreadType<Exposed extends WorkerFunction | WorkerModule<any>> = Exposed extends ArbitraryWorkerInterface ? ArbitraryThreadType : Exposed extends WorkerFunction ? FunctionThread<Parameters<Exposed>, StripAsync<ReturnType<Exposed>>> : Exposed extends WorkerModule<any> ? ModuleThread<Exposed> : never;
+/**
+ * Spawn a new thread. Takes a fresh worker instance, wraps it in a thin
+ * abstraction layer to provide the transparent API and verifies that
+ * the worker has initialized successfully.
+ *
+ * @param worker Instance of `Worker`. Either a web worker, `worker_threads` worker or `tiny-worker` worker.
+ * @param [options]
+ * @param [options.timeout] Init message timeout. Default: 10000 or set by environment variable.
+ */
+export declare function spawn<Exposed extends WorkerFunction | WorkerModule<any> = ArbitraryWorkerInterface>(worker: WorkerType, options?: {
+    timeout?: number;
+}): Promise<ExposedToThreadType<Exposed>>;
+export {};

package/dist/master/spawn.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spawn = void 0;
+/* eslint-disable @typescript-eslint/no-floating-promises */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const debug_1 = __importDefault(require("debug"));
+const observable_fns_1 = require("observable-fns");
+const common_1 = require("../common");
+const promise_1 = require("../promise");
+const symbols_1 = require("../symbols");
+const master_1 = require("../types/master");
+const invocation_proxy_1 = require("./invocation-proxy");
+const debugMessages = (0, debug_1.default)('threads:master:messages');
+const debugSpawn = (0, debug_1.default)('threads:master:spawn');
+const debugThreadUtils = (0, debug_1.default)('threads:master:thread-utils');
+const isInitMessage = (data) => data && data.type === 'init';
+const isUncaughtErrorMessage = (data) => data && data.type === 'uncaughtError';
+const initMessageTimeout = typeof process !== 'undefined' && process.env !== undefined && process.env.THREADS_WORKER_INIT_TIMEOUT ?
+    Number.parseInt(process.env.THREADS_WORKER_INIT_TIMEOUT, 10)
+    : 10000;
+async function withTimeout(promise, timeoutInMs, errorMessage) {
+    let timeoutHandle;
+    const timeout = new Promise((resolve, reject) => {
+        timeoutHandle = setTimeout(() => reject(Error(errorMessage)), timeoutInMs);
+    });
+    const result = await Promise.race([promise, timeout]);
+    clearTimeout(timeoutHandle);
+    return result;
+}
+function receiveInitMessage(worker) {
+    return new Promise((resolve, reject) => {
+        const messageHandler = ((event) => {
+            debugMessages('Message from worker before finishing initialization:', event.data);
+            if (isInitMessage(event.data)) {
+                worker.removeEventListener('message', messageHandler);
+                resolve(event.data);
+            }
+            else if (isUncaughtErrorMessage(event.data)) {
+                worker.removeEventListener('message', messageHandler);
+                reject((0, common_1.deserialize)(event.data.error));
+            }
+        });
+        worker.addEventListener('message', messageHandler);
+    });
+}
+function createEventObservable(worker, workerTermination) {
+    return new observable_fns_1.Observable((observer) => {
+        const messageHandler = ((messageEvent) => {
+            const workerEvent = {
+                data: messageEvent.data,
+                type: master_1.WorkerEventType.message,
+            };
+            observer.next(workerEvent);
+        });
+        const rejectionHandler = ((errorEvent) => {
+            debugThreadUtils('Unhandled promise rejection event in thread:', errorEvent);
+            const workerEvent = {
+                error: Error(errorEvent.reason),
+                type: master_1.WorkerEventType.internalError,
+            };
+            observer.next(workerEvent);
+        });
+        worker.addEventListener('message', messageHandler);
+        worker.addEventListener('unhandledrejection', rejectionHandler);
+        workerTermination.then(() => {
+            const terminationEvent = {
+                type: master_1.WorkerEventType.termination,
+            };
+            worker.removeEventListener('message', messageHandler);
+            worker.removeEventListener('unhandledrejection', rejectionHandler);
+            observer.next(terminationEvent);
+            observer.complete();
+        });
+    });
+}
+function createTerminator(worker) {
+    const [termination, resolver] = (0, promise_1.createPromiseWithResolver)();
+    const terminate = async () => {
+        debugThreadUtils('Terminating worker');
+        // Newer versions of worker_threads workers return a promise
+        await worker.terminate();
+        resolver();
+    };
+    return { terminate, termination };
+}
+function setPrivateThreadProps(raw, worker, workerEvents, terminate) {
+    const workerErrors = workerEvents
+        .filter((event) => event.type === master_1.WorkerEventType.internalError)
+        .map((errorEvent) => errorEvent.error);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return Object.assign(raw, {
+        [symbols_1.$errors]: workerErrors,
+        [symbols_1.$events]: workerEvents,
+        [symbols_1.$terminate]: terminate,
+        [symbols_1.$worker]: worker,
+    });
+}
+/**
+ * Spawn a new thread. Takes a fresh worker instance, wraps it in a thin
+ * abstraction layer to provide the transparent API and verifies that
+ * the worker has initialized successfully.
+ *
+ * @param worker Instance of `Worker`. Either a web worker, `worker_threads` worker or `tiny-worker` worker.
+ * @param [options]
+ * @param [options.timeout] Init message timeout. Default: 10000 or set by environment variable.
+ */
+async function spawn(worker, options) {
+    debugSpawn('Initializing new thread');
+    const timeout = options && options.timeout ? options.timeout : initMessageTimeout;
+    const initMessage = await withTimeout(receiveInitMessage(worker), timeout, `Timeout: Did not receive an init message from worker after ${timeout}ms. Make sure the worker calls expose().`);
+    const exposed = initMessage.exposed;
+    const { termination, terminate } = createTerminator(worker);
+    const events = createEventObservable(worker, termination);
+    if (exposed.type === 'function') {
+        const proxy = (0, invocation_proxy_1.createProxyFunction)(worker);
+        return setPrivateThreadProps(proxy, worker, events, terminate);
+    }
+    else if (exposed.type === 'module') {
+        const proxy = (0, invocation_proxy_1.createProxyModule)(worker, exposed.methods);
+        return setPrivateThreadProps(proxy, worker, events, terminate);
+    }
+    else {
+        const type = exposed.type;
+        throw new Error(`Worker init message states unexpected type of expose(): ${type}`);
+    }
+}
+exports.spawn = spawn;

package/dist/master/thread.d.ts

@@ -0,0 +1,12 @@
+import { Observable } from 'observable-fns';
+import { Thread as ThreadType, WorkerEvent } from '../types/master';
+export type Thread = ThreadType;
+/** Thread utility functions. Use them to manage or inspect a `spawn()`-ed thread. */
+export declare const Thread: {
+    /** Return an observable that can be used to subscribe to all errors happening in the thread. */
+    errors<ThreadT extends ThreadType>(thread: ThreadT): Observable<Error>;
+    /** Return an observable that can be used to subscribe to internal events happening in the thread. Useful for debugging. */
+    events<ThreadT_1 extends ThreadType>(thread: ThreadT_1): Observable<WorkerEvent>;
+    /** Terminate a thread. Remember to terminate every thread when you are done using it. */
+    terminate<ThreadT_2 extends ThreadType>(thread: ThreadT_2): Promise<void>;
+};

package/dist/master/thread.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Thread = void 0;
+const symbols_1 = require("../symbols");
+function fail(message) {
+    throw new Error(message);
+}
+/** Thread utility functions. Use them to manage or inspect a `spawn()`-ed thread. */
+exports.Thread = {
+    /** Return an observable that can be used to subscribe to all errors happening in the thread. */
+    errors(thread) {
+        return thread[symbols_1.$errors] || fail('Error observable not found. Make sure to pass a thread instance as returned by the spawn() promise.');
+    },
+    /** Return an observable that can be used to subscribe to internal events happening in the thread. Useful for debugging. */
+    events(thread) {
+        return thread[symbols_1.$events] || fail('Events observable not found. Make sure to pass a thread instance as returned by the spawn() promise.');
+    },
+    /** Terminate a thread. Remember to terminate every thread when you are done using it. */
+    terminate(thread) {
+        return thread[symbols_1.$terminate]();
+    },
+};

package/dist/observable-promise.d.ts

@@ -0,0 +1,38 @@
+import { Observable, ObservableLike, SubscriptionObserver } from 'observable-fns';
+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.
+ */
+export 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<T> | ArrayLike<T> | Thenable<T>): ObservablePromise<T>;
+}
+export {};

package/dist/observable-promise.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservablePromise = void 0;
+/* eslint-disable unicorn/no-thenable */
+/* eslint-disable @typescript-eslint/member-ordering */
+/* eslint-disable @typescript-eslint/no-floating-promises */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-this-alias */
+/* eslint-disable unicorn/no-this-assignment */
+const observable_fns_1 = require("observable-fns");
+const doNothing = () => { };
+const returnInput = (input) => input;
+const runDeferred = (fn) => Promise.resolve().then(fn);
+function fail(error) {
+    throw error;
+}
+function isThenable(thing) {
+    return thing && typeof thing.then === 'function';
+}
+/**
+ * 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.
+ */
+class ObservablePromise extends observable_fns_1.Observable {
+    [Symbol.toStringTag] = '[object ObservablePromise]';
+    initHasRun = false;
+    fulfillmentCallbacks = [];
+    rejectionCallbacks = [];
+    firstValue;
+    firstValueSet = false;
+    rejection;
+    state = 'pending';
+    constructor(init) {
+        super((originalObserver) => {
+            // tslint:disable-next-line no-this-assignment
+            const self = this;
+            const observer = {
+                ...originalObserver,
+                complete() {
+                    originalObserver.complete();
+                    self.onCompletion();
+                },
+                error(error) {
+                    originalObserver.error(error);
+                    self.onError(error);
+                },
+                next(value) {
+                    originalObserver.next(value);
+                    self.onNext(value);
+                },
+            };
+            try {
+                this.initHasRun = true;
+                return init(observer);
+            }
+            catch (error) {
+                observer.error(error);
+            }
+        });
+    }
+    onNext(value) {
+        if (!this.firstValueSet) {
+            this.firstValue = value;
+            this.firstValueSet = true;
+        }
+    }
+    onError(error) {
+        this.state = 'rejected';
+        this.rejection = error;
+        for (const onRejected of this.rejectionCallbacks) {
+            // Promisifying the call to turn errors into unhandled promise rejections
+            // instead of them failing sync and cancelling the iteration
+            runDeferred(() => onRejected(error));
+        }
+    }
+    onCompletion() {
+        this.state = 'fulfilled';
+        for (const onFulfilled of this.fulfillmentCallbacks) {
+            // Promisifying the call to turn errors into unhandled promise rejections
+            // instead of them failing sync and cancelling the iteration
+            runDeferred(() => onFulfilled(this.firstValue));
+        }
+    }
+    then(onFulfilledRaw, onRejectedRaw) {
+        const onFulfilled = onFulfilledRaw || returnInput;
+        const onRejected = onRejectedRaw || fail;
+        let onRejectedCalled = false;
+        return new Promise((resolve, reject) => {
+            const rejectionCallback = (error) => {
+                if (onRejectedCalled)
+                    return;
+                onRejectedCalled = true;
+                try {
+                    resolve(onRejected(error));
+                }
+                catch (anotherError) {
+                    reject(anotherError);
+                }
+            };
+            const fulfillmentCallback = (value) => {
+                try {
+                    resolve(onFulfilled(value));
+                }
+                catch (error) {
+                    rejectionCallback(error);
+                }
+            };
+            if (!this.initHasRun) {
+                this.subscribe({ error: rejectionCallback });
+            }
+            if (this.state === 'fulfilled') {
+                return resolve(onFulfilled(this.firstValue));
+            }
+            if (this.state === 'rejected') {
+                onRejectedCalled = true;
+                return resolve(onRejected(this.rejection));
+            }
+            this.fulfillmentCallbacks.push(fulfillmentCallback);
+            this.rejectionCallbacks.push(rejectionCallback);
+        });
+    }
+    catch(onRejected) {
+        return this.then(undefined, onRejected);
+    }
+    finally(onCompleted) {
+        const handler = onCompleted || doNothing;
+        return this.then((value) => {
+            handler();
+            return value;
+        }, () => handler());
+    }
+    static from(thing) {
+        return isThenable(thing) ?
+            new ObservablePromise((observer) => {
+                const onFulfilled = (value) => {
+                    observer.next(value);
+                    observer.complete();
+                };
+                const onRejected = (error) => {
+                    observer.error(error);
+                };
+                thing.then(onFulfilled, onRejected);
+            })
+            : super.from(thing);
+    }
+}
+exports.ObservablePromise = ObservablePromise;