vulpix/dist/async/cancelable-promise/cancelable-promise.js

CSP-like channels library

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.CancelationError = exports.CancelablePromise = void 0;
const extensible_promise_1 = require("../extensible-promise");
const stateful_promise_1 = require("../stateful-promise");
class CancelationError extends Error {
    constructor() {
        super('Canceled promise');
    }
}
exports.CancelationError = CancelationError;
/* ALTERNATIVE IMPLEMENTATION

function createCancelablePromise<T>(executor: CancelablePromiseExecutor<T>) {
    let cleanupFunction!: CleanupFunction;
    let reject!: PromiseReject;
    let isFulfilled = false;

    const promise = new Promise<T>((promiseResolve, promiseReject) => {
        const decoratedResolve: PromiseResolve<T> = (value) => {
            isFulfilled = true;
            return promiseResolve(value);
        };
        const decoratedReject: PromiseReject = (reason) => {
            isFulfilled = true;
            return promiseReject(reason);
        };

        reject = decoratedReject;

        cleanupFunction = executor(decoratedResolve, decoratedReject);
    });

    function cancel() {
        if (isFulfilled) {
            return;
        }

        reject(new CancelationError());
        cleanupFunction();
    }

    return Object.assign(promise, { cancel });
}
*/
class CancelablePromise extends extensible_promise_1.ExtensiblePromise {
    constructor(executor) {
        let promiseReject;
        let cleanupFunction;
        super(new stateful_promise_1.StatefulPromise((resolve, reject) => {
            promiseReject = reject;
            cleanupFunction = executor(resolve, reject);
        }));
        this.reject = promiseReject;
        this.cleanupFunction = cleanupFunction;
    }
    cancel(error = new CancelationError()) {
        if (this.promise.isFulfilled) {
            return;
        }
        this.reject(error);
        this.cleanupFunction();
    }
}
exports.CancelablePromise = CancelablePromise;