Return a promise with detached resolve and reject functions
Some async results are produced far away from the code that waits for them. A chat client sends a message over a WebSocket and wants a promise for the server’s acknowledgement, which arrives later in an unrelated onmessage handler. The usual tool is a deferred: a promise together with the functions that settle it, so they can be stored in a map and called from anywhere.
Implement createDeferred(). It returns a new deferred object every time it is called.
const deferred = createDeferred();
deferred.promise; // a native Promise
deferred.resolve(value); // => true if this call settled the deferred, else false
deferred.reject(reason); // => true if this call settled the deferred, else false
deferred.state; // => 'pending' | 'fulfilled' | 'rejected'
promise is an instance of Promise.resolve(value) resolves promise with value; reject(reason) rejects it with reason. Both work when called on their own, for example const { resolve } = createDeferred(); resolve(1); or setTimeout(deferred.resolve, 0).resolve or reject counts. It returns true. Every later call to either function returns false and has no effect.resolve: the deferred settles the same way that promise does, and it counts as the first call even while that promise is still pending.state is a getter that reports how promise actually settled: 'pending' until then, and 'fulfilled' or 'rejected' afterwards. It must be correct by the time any code awaiting promise runs. While a deferred is following a pending promise, its state is still 'pending'.const pendingAcks = new Map();
function send(socket, message) {
const ack = createDeferred();
pendingAcks.set(message.id, ack);
socket.send(JSON.stringify(message));
return ack.promise;
}
socket.onmessage = (event) => {
const { id, ok, error } = JSON.parse(event.data);
const ack = pendingAcks.get(id);
if (!ack) return;
pendingAcks.delete(id);
if (ok) ack.resolve(id);
else ack.reject(new Error(error));
};
const deferred = createDeferred();
deferred.state; // => 'pending'
deferred.resolve('delivered'); // => true
deferred.reject(new Error()); // => false (already settled)
await deferred.promise; // => 'delivered'
deferred.state; // => 'fulfilled'
const upstream = createDeferred();
const follower = createDeferred();
follower.resolve(upstream.promise); // => true
follower.resolve('too late'); // => false
follower.state; // => 'pending'
upstream.reject(new Error('lost'));
await follower.promise.catch((error) => error.message); // => 'lost'
follower.state; // => 'rejected'
Promise.withResolvers.state after awaiting promise or a later tick, so it does not have to change synchronously inside resolve.