simple-deferred-promise

A dead simple deferred promise with TypeScript support

Usage

This module is an ESM only module.

import Deferred from 'simple-deferred-promise';

const a = new Deferred<string>();

a.then(res => console.log(res));

a.resolve('foo'); // or a.reject('bar');

// You can also access the non-deferred promise:
a.promise.then(res => console.log(res));

// this will not work:
a.promise.resolve('123');

You don't have to install this module, you can just copy paste the entire source code, it's just 50 lines:

class Deferred<T = void> implements Promise<T> {
    [Symbol.toStringTag] = 'Promise';

    private _promise: Promise<T>;
    private _resolve!: (value: T | PromiseLike<T>) => void;
    private _reject!: (reason?: any) => void;
    private _state: 'pending' | 'fulfilled' | 'rejected' = 'pending';

    public get state(): 'pending' | 'fulfilled' | 'rejected' {
        return this._state;
    }

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

    public then<TResult1, TResult2>(
        onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>,
        onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>
    ): Promise<TResult1 | TResult2> {
        return this._promise.then(onfulfilled, onrejected);
    }

    public catch<TResult>(
        onrejected?: (reason: any) => TResult | PromiseLike<TResult>
    ): Promise<T | TResult> {
        return this._promise.catch(onrejected);
    }

    public finally(onfinally?: (() => void) | undefined | null): Promise<T> {
        return this._promise.finally(onfinally);
    }

    public get promise(): Promise<T> {
        return this._promise;
    }

    public resolve(value: T | PromiseLike<T>): void {
        this._resolve(value);
        this._state = 'fulfilled';
    }

    public reject(reason?: any): void {
        this._reject(reason);
        this._state = 'rejected';
    }
}