An extended A+ promise library with lazy and synchronous promises.
Ever wanted to have a factory the produces promises but doesn't automatically resolve? What if the consumer never calls .then(...)? Wasted processes! Yuk!
This LazyPromise not only waits for a .then(...) call before resolving but also allows for adding delays that appropriately back propagate the .then(...) requests.
(From the underlying Promise<T>.)
.thenSynchronous(...): simply fulfills immediately if possible..thenThis(...)instead of creating a new promise to return with, it simply returns the current promise and calls the respectedonFullfillandonRejectsynchronously if possible.
You can force .thenThis(...) to be deferred by calling either of the delay methods:
.delayFromNow(ms: number = 0)
or
.delayAfterResolve(ms: number = 0)
The original intentions behind building the underlying Promise<T> class was to:
-
Have a usable Promise class that could be used in place of the ES6 version and still stay in ES5 and would follow the default expected/standard Promise behavior for the consumer. (Not blocking, etc.)
-
Avoid over abuse of generating promises and delays in order to resolve more promises. By smartly allowing for some synchronous processing as long as it wasn't blocking the caller. In some Promise examples, there just seemed to be too much 'deferring' for no reason.
-
Expose other useful methods which could be used by the consumer that allowed for synchronous processing as long as it was explicitly desired. In some cases, it simply made more sense to create a synchronous pipeline instead repeating unnecessary defer/delays.
This was originally written for ES5 but is now targeting ES2015.