JSFiddle - React, Tailwind, and code Playground

JavaScript

function Deferred(fn) {
    fn = fn || function () {};

    //make tolerant of forgotton `new`
    if (!this instanceof Deferred) {
        return new Deferred(fn);
    }

    var resolve_, reject_;

    var promise = new Promise(function (resolve, reject) {
        resolve_ = resolve;
        reject_ = reject;
        fn(resolve, reject);
    });

    promise.resolve = function (val) {
        (val === undefined) ? resolve_() : resolve_(val);
        return promise;
    }
    promise.reject = function (reason) {
        (reason === undefined) ? reject_() : reject_(reason);
        return promise;
    }
    promise.promise = function () {
        return promise;
    }

    return promise;
}

Deferred().resolve('resolved via method').then(function(val) {
    alert(val);
});

Deferred().reject('rejected via method').catch(function(reason) {
    alert(reason);
});

Deferred(function(resolve, reject) {
	resolve('resolved via revealer');
}).promise().then(function(val) {
	alert(val);
});

Deferred(function(resolve, reject) {
	reject('rejected via revealer');
}).promise().catch(function(reason) {
    alert(reason);
});
//.promise() is optional in each case.