promise-handle.ts

class PromiseHandle<T> {
    private _resolve!: (value: T | PromiseLike<T>) => void;
    private _reject!: (reason?: unknown) => void;
    private _promise: Promise<T>;
    private _resolved: boolean = false;
    private _rejected: boolean = false;

    public constructor() {
        this._promise = new Promise<T>((resolve, reject) => {
            this._resolve = resolve;
            this._reject = reject;
        });
    }

    private _check() {
        if (this._resolved) {
            throw new TypeError("PromiseHandle previously resolved");
        } else if (this._rejected) {
            throw new TypeError("PromiseHandle previously rejected");
        }
    }

    public resolve(value: T | PromiseLike<T>) {
        this._check();
        this._resolved = true;
        this._resolve(value);
    }

    public reject(reason?: unknown) {
        this._check();
        this._rejected = true;
        this._reject(reason);
    }

    public get promise() {
        return this._promise;
    }

    public get resolved() {
        return this._resolved;
    }

    public get rejected() {
        return this._rejected;
    }
}