608 lines
24 KiB
JavaScript
608 lines
24 KiB
JavaScript
/*
|
|
* Minimal ES2015+ Promise polyfill
|
|
*
|
|
* Limitations (also see XXX in source):
|
|
*
|
|
* - Caller must manually call Promise.runQueue() to process pending jobs.
|
|
* - No Promise subclassing or non-subclass foreign Promises yet.
|
|
* - Promise.all() and Promise.race() assume a plain array, not iterator.
|
|
* - Doesn't handle errors from core operations, e.g. out-of-memory or
|
|
* internal error when queueing/running jobs. These are implementation
|
|
* defined for the most part.
|
|
*
|
|
* This polyfill was originally used to gain a better understanding of the
|
|
* ES2015 specification algorithms, before implementing Promises natively.
|
|
*
|
|
* The polyfill uses a Symbol to mark Promise instances, but falls back to
|
|
* an ordinary (non-enumerable) property if no Symbol support is available.
|
|
* Presence of the polyfill itself can be checked using "Promise.isPolyfill".
|
|
*
|
|
* Unhandled Promise rejections use a custom API signature. For now, a
|
|
* single Promise.unhandledRejection() hook receives both 'rawReject' and
|
|
* 'rawHandle' events directly from HostPromiseRejectionTracker, and higher
|
|
* level (Node.js / WHATWG like) 'reject' and 'handle' events which filter
|
|
* out cases where a rejected Promise is initially unhandled but gets handled
|
|
* within the same "tick".
|
|
*
|
|
* See also: https://github.com/stefanpenner/es6-promise#readme
|
|
*/
|
|
|
|
(function () {
|
|
if (typeof Promise !== 'undefined') { return; }
|
|
|
|
// As far as the specification goes, almost all Promise settling is via
|
|
// concrete resolve/reject functions with mutual protection from being
|
|
// called multiple times. Sometimes the actual resolve/reject functions
|
|
// are not exposed to calling code, and can safely be omitted which is
|
|
// useful because resolve/reject functions are memory heavy. These
|
|
// optimizations are enabled by default; set to false to disable.
|
|
var allowOptimization = true;
|
|
|
|
// Job queue to simulate ES2015 job queues, linked list, 'next' reference.
|
|
// While ES2015 doesn't guarantee the relative order of jobs in different
|
|
// job queues, within a certain queue strict FIFO is required. See ES5.1
|
|
// https://www.ecma-international.org/ecma-262/6.0/#sec-jobs-and-job-queues:
|
|
// "The PendingJob records from a single Job Queue are always initiated in
|
|
// FIFO order. This specification does not define the order in which
|
|
// multiple Job Queues are serviced."
|
|
var queueHead = null, queueTail = null;
|
|
function enqueueJob(job) {
|
|
// Avoid inheriting conflicting properties if caller already didn't
|
|
// ensure it.
|
|
Object.setPrototypeOf(job, null);
|
|
compact(job);
|
|
if (queueHead) {
|
|
queueTail.next = job;
|
|
compact(queueTail);
|
|
queueTail = job;
|
|
} else {
|
|
queueHead = job;
|
|
queueTail = job;
|
|
}
|
|
}
|
|
function dequeueJob() {
|
|
var ret = queueHead;
|
|
if (ret) {
|
|
queueHead = ret.next;
|
|
if (!queueHead) {
|
|
queueTail = null;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
function queueEmpty() {
|
|
return !queueHead;
|
|
}
|
|
|
|
// Helper to define/modify properties more compactly.
|
|
function def(obj, key, val, attrs) {
|
|
if (attrs === void 0) { attrs = 'wc'; }
|
|
Object.defineProperty(obj, key, {
|
|
value: val,
|
|
writable: attrs.indexOf('w') >= 0,
|
|
enumerable: attrs.indexOf('e') >= 0,
|
|
configurable: attrs.indexOf('c') >= 0
|
|
});
|
|
}
|
|
|
|
// Helper for Duktape specific object compaction.
|
|
var compact = (typeof Duktape === 'object' && Duktape.compact) ||
|
|
function (v) { return v; };
|
|
|
|
// Shared no-op function.
|
|
var nop = function nop() {};
|
|
|
|
// Promise detection (plain or subclassed Promise), in spec has
|
|
// [[PromiseState]] internal slot which isn't affected by Proxy
|
|
// behaviors etc.
|
|
var haveSymbols = (typeof Symbol === 'function');
|
|
var promiseMarker = haveSymbols ? Symbol('promise') : '__PromiseInstance__';
|
|
function isPromise(p) {
|
|
return p !== null && typeof p === 'object' && promiseMarker in p;
|
|
}
|
|
function requirePromise(p) {
|
|
if (!isPromise(p)) { throw new TypeError('Promise required'); }
|
|
}
|
|
|
|
// Raw HostPromiseRejectionTracker call. This operation should "never"
|
|
// fail but that's in practice unachievable due to possible out-of-memory
|
|
// on any operation (including invocation of the callback). Higher level
|
|
// hook events are emitted from Promise.runQueue().
|
|
function safeCallUnhandledRejection(event) {
|
|
try {
|
|
cons.unhandledRejection(event);
|
|
} catch (e) {
|
|
//console.log('Promise.unhandledRejection failed:', e);
|
|
}
|
|
}
|
|
function rejectionTracker(p, operation) {
|
|
try {
|
|
if (operation === 'reject') {
|
|
// Unhandled at resolution.
|
|
safeCallUnhandledRejection({ promise: p, event: 'rawReject', reason: p.value });
|
|
def(p, 'unhandled', 1);
|
|
cons.potentiallyUnhandled.push(p);
|
|
} else if (operation === 'handle') {
|
|
safeCallUnhandledRejection({ promise: p, event: 'rawHandle', reason: p.value });
|
|
if (p.unhandled === 2) {
|
|
// Unhandled, already notified, need handled notification.
|
|
def(p, 'unhandled', 3);
|
|
cons.potentiallyUnhandled.push(p);
|
|
} else {
|
|
// Handled but not yet notified -> no action needed.
|
|
// XXX: If this.unhandled was 1, we'd like to remove
|
|
// the Promise from cons.potentiallyUnhandled list.
|
|
// We skip that here because it would mean an expensive
|
|
// list remove. If cons.potentiallyUnhandled was a
|
|
// Set, it would be natural to remove from Set here.
|
|
delete p.unhandled;
|
|
}
|
|
}
|
|
} catch (e) {
|
|
//console.log('HostPromiseRejectionTracker failed:', e);
|
|
}
|
|
}
|
|
|
|
// Raw fulfill/reject operations, assume resolution processing done.
|
|
// The specification algorithms RejectPromise() and FulfillPromise()
|
|
// assert that the Promise is pending so the initial check in these
|
|
// implementations (p.state !== void 0) is not needed: the resolve/reject
|
|
// function pairs always ensure a Promise is not ultimately settled twice.
|
|
// With some of the "as if" optimizations we rely on these raw operations
|
|
// to protect against multiple attempts to settle the Promise so the checks
|
|
// are actually needed.
|
|
function doFulfill(p, val) {
|
|
if (p.state !== void 0) { return; } // additional check needed with optimizations
|
|
p.state = true; p.value = val;
|
|
var reactions = p.fulfillReactions;
|
|
delete p.fulfillReactions; delete p.rejectReactions; compact(p);
|
|
reactions.forEach(function (ent) {
|
|
// Conceptually: create a job from the registered reaction.
|
|
// In practice: reuse the reaction object because it is unique,
|
|
// never leaks to calling code, and is never reused.
|
|
ent.value = val;
|
|
enqueueJob(ent);
|
|
});
|
|
}
|
|
function doReject(p, val) {
|
|
if (p.state !== void 0) { return; } // additional check needed with optimizations
|
|
p.state = false; p.value = val;
|
|
var reactions = p.rejectReactions;
|
|
delete p.fulfillReactions; delete p.rejectReactions; compact(p);
|
|
reactions.forEach(function (ent) {
|
|
// As for doFulfill(), reuse the registered reaction object.
|
|
ent.value = val;
|
|
if (!ent.handler) {
|
|
// Without a .handler, we're dealing with an optimized
|
|
// entry where only .target exists and the resolve/reject
|
|
// behavior is simulated when the entry runs. However,
|
|
// we need to know whether to simulate resolve or reject
|
|
// at that time, so flag rejection explicitly (resolve
|
|
// requires no flag).
|
|
ent.rejected = true;
|
|
}
|
|
enqueueJob(ent);
|
|
});
|
|
if (!p.isHandled) {
|
|
rejectionTracker(p, 'reject');
|
|
}
|
|
}
|
|
|
|
// Create a new resolve/reject pair for a Promise. Multiple pairs are
|
|
// needed in thenable handling, with all but the most recent pair being
|
|
// neutralized ('alreadyResolved'). Because Promises are resolved only
|
|
// via this resolution process, it shouldn't be possible for the Promise
|
|
// to be settled but check it anyway: it may be useful for e.g. the C API
|
|
// to forcibly resolve/fulfill/reject a Promise regardless of extant
|
|
// resolve/reject functions.
|
|
function createResolutionFunctions(p) {
|
|
// In ES2015 the resolve/reject functions have a shared 'state' object
|
|
// with a [[AlreadyResolved]] slot. Here we use an in-scope variable.
|
|
var alreadyResolved = false;
|
|
var reject = function (err) {
|
|
if (new.target) { throw new TypeError('reject is not constructable'); }
|
|
if (alreadyResolved) { return; }
|
|
alreadyResolved = true; // neutralize resolve/reject
|
|
if (p.state !== void 0) { return; }
|
|
doReject(p, err);
|
|
};
|
|
reject.prototype = null; // drop .prototype object
|
|
var resolve = function (val) {
|
|
if (new.target) { throw new TypeError('resolve is not constructable'); }
|
|
if (alreadyResolved) { return; }
|
|
alreadyResolved = true; // neutralize resolve/reject
|
|
if (p.state !== void 0) { return; }
|
|
if (val === p) {
|
|
return doReject(p, new TypeError('self resolution'));
|
|
}
|
|
try {
|
|
var then = (val !== null && typeof val === 'object' &&
|
|
val.then);
|
|
if (typeof then === 'function') {
|
|
var t = createResolutionFunctions(p);
|
|
var optimized = allowOptimization;
|
|
if (optimized) {
|
|
// XXX: this optimization may not be useful because the
|
|
// job entry runs usually very quickly, and as part of
|
|
// running the job, the resolve/reject function must be
|
|
// created for the then() call.
|
|
return enqueueJob({
|
|
thenable: val,
|
|
then: then,
|
|
target: p
|
|
});
|
|
} else {
|
|
return enqueueJob({
|
|
thenable: val,
|
|
then: then,
|
|
resolve: t.resolve,
|
|
reject: t.reject
|
|
});
|
|
}
|
|
// old resolve/reject is neutralized, only new pair is live
|
|
}
|
|
return doFulfill(p, val);
|
|
} catch (e) {
|
|
return doReject(p, e);
|
|
}
|
|
};
|
|
resolve.prototype = null; // drop .prototype object
|
|
return { resolve: resolve, reject: reject };
|
|
}
|
|
|
|
// Job queue simulation.
|
|
function runQueueEntry() {
|
|
// XXX: In optimized cases, creating both resolution functions is
|
|
// not always necessary. There's also no need for alreadySettled
|
|
// protections for the optimized cases either.
|
|
var job = dequeueJob();
|
|
var tmp;
|
|
if (!job) { return false; }
|
|
if (job.then) {
|
|
// PromiseResolveThenableJob
|
|
if (job.target) {
|
|
tmp = createResolutionFunctions(job.target);
|
|
}
|
|
try {
|
|
if (tmp) {
|
|
void job.then.call(job.thenable, tmp.resolve, tmp.reject);
|
|
} else {
|
|
void job.then.call(job.thenable, job.resolve, job.reject);
|
|
}
|
|
} catch (e) {
|
|
if (tmp) {
|
|
tmp.reject.call(void 0, e);
|
|
} else {
|
|
job.reject.call(void 0, e);
|
|
}
|
|
}
|
|
} else {
|
|
// PromiseReactionJob
|
|
try {
|
|
if (job.handler === void 0) {
|
|
// Optimized case where two Promises are tied together
|
|
// without the need for an actual 'handler'.
|
|
tmp = createResolutionFunctions(job.target); // must exist in this case
|
|
tmp = job.rejected ? tmp.reject : tmp.resolve;
|
|
tmp.call(void 0, job.value);
|
|
return true;
|
|
} else if (job.handler === 'Identity') {
|
|
res = job.value;
|
|
} else if (job.handler === 'Thrower') {
|
|
throw job.value;
|
|
} else {
|
|
res = job.handler.call(void 0, job.value);
|
|
}
|
|
if (job.target) {
|
|
createResolutionFunctions(job.target).resolve.call(void 0, res);
|
|
} else {
|
|
job.resolve.call(void 0, res);
|
|
}
|
|
} catch (e) {
|
|
if (job.target) {
|
|
createResolutionFunctions(job.target).reject.call(void 0, e);
|
|
} else {
|
|
job.reject.call(void 0, e);
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// %Promise% constructor.
|
|
var cons = function Promise(executor) {
|
|
if (!new.target) {
|
|
throw new TypeError('Promise must be called as a constructor');
|
|
}
|
|
if (typeof executor !== 'function') {
|
|
throw new TypeError('executor must be callable');
|
|
}
|
|
var _this = this;
|
|
def(this, promiseMarker, true, '');
|
|
def(this, 'state', void 0); // undefined (pending), true/false
|
|
def(this, 'value', void 0);
|
|
def(this, 'fulfillReactions', []);
|
|
def(this, 'rejectReactions', []);
|
|
def(this, 'isHandled', false); // XXX: roll into 'state' to minimize fields
|
|
compact(this);
|
|
var t = createResolutionFunctions(this);
|
|
try {
|
|
void executor(t.resolve, t.reject);
|
|
} catch (e) {
|
|
t.reject(e);
|
|
}
|
|
};
|
|
var proto = cons.prototype;
|
|
def(cons, 'prototype', proto, '');
|
|
def(cons, 'potentiallyUnhandled', [], '');
|
|
|
|
// %Promise%.resolve().
|
|
// XXX: direct handling
|
|
function resolve(val) {
|
|
if (isPromise(val) && val.constructor === this) { return val; }
|
|
return new Promise(function (resolve, reject) { resolve(val); });
|
|
}
|
|
|
|
// %Promise%.reject()
|
|
// XXX: direct handling
|
|
function reject(val) {
|
|
return new Promise(function (resolve, reject) { reject(val); });
|
|
}
|
|
|
|
// %Promise%.all().
|
|
function all(list) {
|
|
if (!Array.isArray(list)) {
|
|
throw new TypeError('non-array all() argument not supported');
|
|
}
|
|
var resolveFn, rejectFn;
|
|
var p = new Promise(function (resolve, reject) {
|
|
resolveFn = resolve; rejectFn = reject;
|
|
});
|
|
var values = [];
|
|
var index = 0;
|
|
var remaining = 1; // remaining intentionally 1, not 0
|
|
list.forEach(function (x) { // XXX: no iterator support
|
|
var t = Promise.resolve(x);
|
|
var f = function promiseAllElement(val) {
|
|
var F = promiseAllElement;
|
|
if (F.alreadyCalled) { return; }
|
|
F.alreadyCalled = true;
|
|
values[F.index] = val;
|
|
if (--remaining === 0) {
|
|
resolveFn.call(void 0, values);
|
|
}
|
|
};
|
|
// In ES2015 the functions would reference a shared state object
|
|
// explicitly. Here the conceptual state is in scope.
|
|
f.index = index++;
|
|
remaining++;
|
|
t.then(f, rejectFn);
|
|
});
|
|
if (--remaining === 0) {
|
|
resolveFn.call(void 0, values);
|
|
}
|
|
return p;
|
|
}
|
|
|
|
// %Promise%.race().
|
|
function race(list) {
|
|
if (!Array.isArray(list)) {
|
|
throw new TypeError('non-array race() argument not supported');
|
|
}
|
|
var resolveFn, rejectFn;
|
|
var p = new Promise(function (resolve, reject) {
|
|
resolveFn = resolve; rejectFn = reject;
|
|
});
|
|
list.forEach(function (x) { // XXX: no iterator support
|
|
var t = Promise.resolve(x);
|
|
var func = t.then;
|
|
var optimized = (func === then) && allowOptimization;
|
|
if (optimized) {
|
|
// If the .then() of the Promise.resolve() is the original
|
|
// built-in implementation, we don't need to queue the actual
|
|
// resolve and reject functions explicitly because (1) the
|
|
// functions don't leak and can't be called by anyone else,
|
|
// and (2) the onFulfilled/onRejected functions would just
|
|
// directly forward the result from 't' to 'p'.
|
|
optimizedThen(t, p);
|
|
} else {
|
|
// Generic case, the result Promise of .then() is ignored.
|
|
void func.call(t, resolveFn, rejectFn);
|
|
}
|
|
});
|
|
return p;
|
|
}
|
|
|
|
// %PromisePrototype%.then(), also used for .catch().
|
|
function then(onFulfilled, onRejected) {
|
|
// No subclassing support here now, no NewPromiseCapability() handling.
|
|
requirePromise(this);
|
|
var resolveFn, rejectFn;
|
|
var p = new Promise(function (resolve, reject) {
|
|
resolveFn = resolve; rejectFn = reject;
|
|
});
|
|
var optimized = allowOptimization;
|
|
if (typeof onFulfilled !== 'function') { onFulfilled = 'Identity'; }
|
|
if (typeof onRejected !== 'function') { onRejected = 'Thrower'; }
|
|
|
|
if (this.state === void 0) { // pending
|
|
if (optimized) {
|
|
this.fulfillReactions.push({
|
|
handler: onFulfilled,
|
|
target: p
|
|
});
|
|
this.rejectReactions.push({
|
|
handler: onRejected,
|
|
target: p
|
|
});
|
|
} else {
|
|
this.fulfillReactions.push({
|
|
handler: onFulfilled,
|
|
resolve: resolveFn,
|
|
reject: rejectFn
|
|
});
|
|
this.rejectReactions.push({
|
|
handler: onRejected,
|
|
resolve: resolveFn,
|
|
reject: rejectFn
|
|
});
|
|
}
|
|
} else if (this.state) { // fulfilled
|
|
if (optimized) {
|
|
enqueueJob({
|
|
handler: onFulfilled,
|
|
target: p,
|
|
value: this.value
|
|
});
|
|
} else {
|
|
enqueueJob({
|
|
handler: onFulfilled,
|
|
resolve: resolveFn,
|
|
reject: rejectFn,
|
|
value: this.value
|
|
});
|
|
}
|
|
} else { // rejected
|
|
if (!this.isHandled) {
|
|
rejectionTracker(this, 'handle');
|
|
}
|
|
if (optimized) {
|
|
enqueueJob({
|
|
handler: onRejected,
|
|
target: p,
|
|
value: this.value
|
|
});
|
|
} else {
|
|
enqueueJob({
|
|
handler: onRejected,
|
|
resolve: resolveFn,
|
|
reject: rejectFn,
|
|
value: this.value
|
|
});
|
|
}
|
|
}
|
|
this.isHandled = true;
|
|
return p;
|
|
}
|
|
|
|
// Optimized .then() where a specific source Promise just forwards its
|
|
// result to a target Promise unless its already settled.
|
|
function optimizedThen(source, target) {
|
|
if (source.state === void 0) { // pending
|
|
source.fulfillReactions.push({
|
|
target: target
|
|
});
|
|
source.rejectReactions.push({
|
|
target: target
|
|
});
|
|
} else if (source.state) { // fulfilled
|
|
enqueueJob({
|
|
target: target,
|
|
value: source.value
|
|
});
|
|
} else { // rejected
|
|
if (!source.isHandled) {
|
|
rejectionTracker(source, 'handle');
|
|
}
|
|
enqueueJob({
|
|
target: target,
|
|
value: source.value,
|
|
rejected: true
|
|
});
|
|
}
|
|
source.isHandled = true;
|
|
}
|
|
|
|
// %PromisePrototype%.catch.
|
|
var _catch = function (onRejected) {
|
|
return this.then.call(this, void 0, onRejected);
|
|
};
|
|
def(_catch, 'name', 'catch', 'c');
|
|
|
|
// %Promise%.try(), https://github.com/tc39/proposal-promise-try,
|
|
// simple polyfill-style implementation.
|
|
var _try = function (func) {
|
|
// XXX: check 'this' for callability, or Promise / subclass.
|
|
return new this(function (resolve, reject) { resolve(func()); });
|
|
};
|
|
def(_try, 'name', 'try', 'c');
|
|
|
|
// Emit higher level Node.js/WHATWG like 'reject' and 'handle' events,
|
|
// filtering out some cases where a rejected Promise is initially unhandled
|
|
// but is handled within the same "tick" (for a relatively murky definition
|
|
// of a "tick").
|
|
// https://html.spec.whatwg.org/multipage/webappapis.html#unhandled-promise-rejections
|
|
// https://www.ecma-international.org/ecma-262/8.0/#sec-host-promise-rejection-tracker
|
|
function checkUnhandledRejections() {
|
|
var idx;
|
|
|
|
// The unhandledRejection() callbacks may have queued more Promises,
|
|
// settled existing Promises on the list, etc. Keep going until
|
|
// the list is empty. Null out entries to allow early GC when the
|
|
// Promises are no longer reachable. Callbacks may also queue more
|
|
// ordinary Promise jobs; they are also handled to completion within
|
|
// the tick.
|
|
|
|
// XXX: It might be more natural to handle the notification callbacks
|
|
// via the job queue. This might be a bit simpler, but would change
|
|
// the Promise job vs. unhandledRejection callback ordering a bit.
|
|
// For example, Node.js emits 'handle' events before the related
|
|
// catch callbacks are called, while the polyfill in its current
|
|
// state does not.
|
|
|
|
for (idx = 0; idx < cons.potentiallyUnhandled.length; idx++) {
|
|
var p = cons.potentiallyUnhandled[idx];
|
|
cons.potentiallyUnhandled[idx] = null;
|
|
|
|
// For consistency with hook calls from HostPromiseRejectionTracker
|
|
// errors from user callback are silently eaten. If a process exit
|
|
// is desirable, user callback may call a custom native binding to
|
|
// do that ("process.exit(1)" or similar).
|
|
//
|
|
// Use a custom object argument convention for flexibility.
|
|
|
|
if (p.unhandled === 1) {
|
|
safeCallUnhandledRejection({ promise: p, event: 'reject', reason: p.value });
|
|
def(p, 'unhandled', 2);
|
|
} else if (p.unhandled === 3) {
|
|
safeCallUnhandledRejection({ promise: p, event: 'handle', reason: p.value });
|
|
delete p.unhandled;
|
|
}
|
|
}
|
|
|
|
cons.potentiallyUnhandled.length = 0;
|
|
|
|
return idx > 0; // true if we processed entries
|
|
}
|
|
|
|
// Define visible objects and properties.
|
|
(function () {
|
|
def(this, 'Promise', cons);
|
|
def(cons, 'resolve', resolve);
|
|
def(cons, 'reject', reject);
|
|
def(cons, 'all', all);
|
|
def(cons, 'race', race);
|
|
def(cons, 'try', _try);
|
|
def(cons, 'isPolyfill', true); // needed by e.g. testcases
|
|
def(proto, 'then', then);
|
|
def(proto, 'catch', _catch);
|
|
if (haveSymbols) {
|
|
def(proto, Symbol.toStringTag, 'Promise', 'c');
|
|
}
|
|
|
|
// Custom API to drive the "job queue". We only want to exit when
|
|
// there are no more Promise jobs or unhandledRejection() callbacks,
|
|
// i.e. no more work to do. Note that an unhandledRejection()
|
|
// callback may queue more Promise job entries and vice versa.
|
|
def(cons, 'runQueue', function _runQueueUntilEmpty() {
|
|
do {
|
|
while (runQueueEntry()) {}
|
|
checkUnhandledRejections();
|
|
} while(!(queueEmpty() && cons.potentiallyUnhandled.length === 0));
|
|
});
|
|
def(cons, 'unhandledRejection', nop);
|
|
|
|
compact(this); compact(cons); compact(proto);
|
|
}());
|
|
}());
|