3914 lines
120 KiB
JavaScript
3914 lines
120 KiB
JavaScript
/* @preserve
|
|
* The MIT License (MIT)
|
|
*
|
|
* Copyright (c) 2013-2018 Petka Antonov
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*
|
|
*/
|
|
/**
|
|
* bluebird build version 3.7.2
|
|
* Features enabled: core
|
|
* Features disabled: race, call_get, generators, map, nodeify, promisify, props, reduce, settle, some, using, timers, filter, any, each
|
|
*/
|
|
!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.Promise=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof _dereq_=="function"&&_dereq_;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof _dereq_=="function"&&_dereq_;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
var firstLineError;
|
|
try {throw new Error(); } catch (e) {firstLineError = e;}
|
|
var schedule = _dereq_("./schedule");
|
|
var Queue = _dereq_("./queue");
|
|
|
|
function Async() {
|
|
this._customScheduler = false;
|
|
this._isTickUsed = false;
|
|
this._lateQueue = new Queue(16);
|
|
this._normalQueue = new Queue(16);
|
|
this._haveDrainedQueues = false;
|
|
var self = this;
|
|
this.drainQueues = function () {
|
|
self._drainQueues();
|
|
};
|
|
this._schedule = schedule;
|
|
}
|
|
|
|
Async.prototype.setScheduler = function(fn) {
|
|
var prev = this._schedule;
|
|
this._schedule = fn;
|
|
this._customScheduler = true;
|
|
return prev;
|
|
};
|
|
|
|
Async.prototype.hasCustomScheduler = function() {
|
|
return this._customScheduler;
|
|
};
|
|
|
|
Async.prototype.haveItemsQueued = function () {
|
|
return this._isTickUsed || this._haveDrainedQueues;
|
|
};
|
|
|
|
|
|
Async.prototype.fatalError = function(e, isNode) {
|
|
if (isNode) {
|
|
process.stderr.write("Fatal " + (e instanceof Error ? e.stack : e) +
|
|
"\n");
|
|
process.exit(2);
|
|
} else {
|
|
this.throwLater(e);
|
|
}
|
|
};
|
|
|
|
Async.prototype.throwLater = function(fn, arg) {
|
|
if (arguments.length === 1) {
|
|
arg = fn;
|
|
fn = function () { throw arg; };
|
|
}
|
|
if (typeof setTimeout !== "undefined") {
|
|
setTimeout(function() {
|
|
fn(arg);
|
|
}, 0);
|
|
} else try {
|
|
this._schedule(function() {
|
|
fn(arg);
|
|
});
|
|
} catch (e) {
|
|
throw new Error("No async scheduler available\u000a\u000a See http://goo.gl/MqrFmX\u000a");
|
|
}
|
|
};
|
|
|
|
function AsyncInvokeLater(fn, receiver, arg) {
|
|
this._lateQueue.push(fn, receiver, arg);
|
|
this._queueTick();
|
|
}
|
|
|
|
function AsyncInvoke(fn, receiver, arg) {
|
|
this._normalQueue.push(fn, receiver, arg);
|
|
this._queueTick();
|
|
}
|
|
|
|
function AsyncSettlePromises(promise) {
|
|
this._normalQueue._pushOne(promise);
|
|
this._queueTick();
|
|
}
|
|
|
|
Async.prototype.invokeLater = AsyncInvokeLater;
|
|
Async.prototype.invoke = AsyncInvoke;
|
|
Async.prototype.settlePromises = AsyncSettlePromises;
|
|
|
|
|
|
function _drainQueue(queue) {
|
|
while (queue.length() > 0) {
|
|
_drainQueueStep(queue);
|
|
}
|
|
}
|
|
|
|
function _drainQueueStep(queue) {
|
|
var fn = queue.shift();
|
|
if (typeof fn !== "function") {
|
|
fn._settlePromises();
|
|
} else {
|
|
var receiver = queue.shift();
|
|
var arg = queue.shift();
|
|
fn.call(receiver, arg);
|
|
}
|
|
}
|
|
|
|
Async.prototype._drainQueues = function () {
|
|
_drainQueue(this._normalQueue);
|
|
this._reset();
|
|
this._haveDrainedQueues = true;
|
|
_drainQueue(this._lateQueue);
|
|
};
|
|
|
|
Async.prototype._queueTick = function () {
|
|
if (!this._isTickUsed) {
|
|
this._isTickUsed = true;
|
|
this._schedule(this.drainQueues);
|
|
}
|
|
};
|
|
|
|
Async.prototype._reset = function () {
|
|
this._isTickUsed = false;
|
|
};
|
|
|
|
module.exports = Async;
|
|
module.exports.firstLineError = firstLineError;
|
|
|
|
},{"./queue":17,"./schedule":18}],2:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(Promise, INTERNAL, tryConvertToPromise, debug) {
|
|
var calledBind = false;
|
|
var rejectThis = function(_, e) {
|
|
this._reject(e);
|
|
};
|
|
|
|
var targetRejected = function(e, context) {
|
|
context.promiseRejectionQueued = true;
|
|
context.bindingPromise._then(rejectThis, rejectThis, null, this, e);
|
|
};
|
|
|
|
var bindingResolved = function(thisArg, context) {
|
|
if (((this._bitField & 50397184) === 0)) {
|
|
this._resolveCallback(context.target);
|
|
}
|
|
};
|
|
|
|
var bindingRejected = function(e, context) {
|
|
if (!context.promiseRejectionQueued) this._reject(e);
|
|
};
|
|
|
|
Promise.prototype.bind = function (thisArg) {
|
|
if (!calledBind) {
|
|
calledBind = true;
|
|
Promise.prototype._propagateFrom = debug.propagateFromFunction();
|
|
Promise.prototype._boundValue = debug.boundValueFunction();
|
|
}
|
|
var maybePromise = tryConvertToPromise(thisArg);
|
|
var ret = new Promise(INTERNAL);
|
|
ret._propagateFrom(this, 1);
|
|
var target = this._target();
|
|
ret._setBoundTo(maybePromise);
|
|
if (maybePromise instanceof Promise) {
|
|
var context = {
|
|
promiseRejectionQueued: false,
|
|
promise: ret,
|
|
target: target,
|
|
bindingPromise: maybePromise
|
|
};
|
|
target._then(INTERNAL, targetRejected, undefined, ret, context);
|
|
maybePromise._then(
|
|
bindingResolved, bindingRejected, undefined, ret, context);
|
|
ret._setOnCancel(maybePromise);
|
|
} else {
|
|
ret._resolveCallback(target);
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
Promise.prototype._setBoundTo = function (obj) {
|
|
if (obj !== undefined) {
|
|
this._bitField = this._bitField | 2097152;
|
|
this._boundTo = obj;
|
|
} else {
|
|
this._bitField = this._bitField & (~2097152);
|
|
}
|
|
};
|
|
|
|
Promise.prototype._isBound = function () {
|
|
return (this._bitField & 2097152) === 2097152;
|
|
};
|
|
|
|
Promise.bind = function (thisArg, value) {
|
|
return Promise.resolve(value).bind(thisArg);
|
|
};
|
|
};
|
|
|
|
},{}],3:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
var old;
|
|
if (typeof Promise !== "undefined") old = Promise;
|
|
function noConflict() {
|
|
try { if (Promise === bluebird) Promise = old; }
|
|
catch (e) {}
|
|
return bluebird;
|
|
}
|
|
var bluebird = _dereq_("./promise")();
|
|
bluebird.noConflict = noConflict;
|
|
module.exports = bluebird;
|
|
|
|
},{"./promise":15}],4:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(Promise, PromiseArray, apiRejection, debug) {
|
|
var util = _dereq_("./util");
|
|
var tryCatch = util.tryCatch;
|
|
var errorObj = util.errorObj;
|
|
var async = Promise._async;
|
|
|
|
Promise.prototype["break"] = Promise.prototype.cancel = function() {
|
|
if (!debug.cancellation()) return this._warn("cancellation is disabled");
|
|
|
|
var promise = this;
|
|
var child = promise;
|
|
while (promise._isCancellable()) {
|
|
if (!promise._cancelBy(child)) {
|
|
if (child._isFollowing()) {
|
|
child._followee().cancel();
|
|
} else {
|
|
child._cancelBranched();
|
|
}
|
|
break;
|
|
}
|
|
|
|
var parent = promise._cancellationParent;
|
|
if (parent == null || !parent._isCancellable()) {
|
|
if (promise._isFollowing()) {
|
|
promise._followee().cancel();
|
|
} else {
|
|
promise._cancelBranched();
|
|
}
|
|
break;
|
|
} else {
|
|
if (promise._isFollowing()) promise._followee().cancel();
|
|
promise._setWillBeCancelled();
|
|
child = promise;
|
|
promise = parent;
|
|
}
|
|
}
|
|
};
|
|
|
|
Promise.prototype._branchHasCancelled = function() {
|
|
this._branchesRemainingToCancel--;
|
|
};
|
|
|
|
Promise.prototype._enoughBranchesHaveCancelled = function() {
|
|
return this._branchesRemainingToCancel === undefined ||
|
|
this._branchesRemainingToCancel <= 0;
|
|
};
|
|
|
|
Promise.prototype._cancelBy = function(canceller) {
|
|
if (canceller === this) {
|
|
this._branchesRemainingToCancel = 0;
|
|
this._invokeOnCancel();
|
|
return true;
|
|
} else {
|
|
this._branchHasCancelled();
|
|
if (this._enoughBranchesHaveCancelled()) {
|
|
this._invokeOnCancel();
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
|
|
Promise.prototype._cancelBranched = function() {
|
|
if (this._enoughBranchesHaveCancelled()) {
|
|
this._cancel();
|
|
}
|
|
};
|
|
|
|
Promise.prototype._cancel = function() {
|
|
if (!this._isCancellable()) return;
|
|
this._setCancelled();
|
|
async.invoke(this._cancelPromises, this, undefined);
|
|
};
|
|
|
|
Promise.prototype._cancelPromises = function() {
|
|
if (this._length() > 0) this._settlePromises();
|
|
};
|
|
|
|
Promise.prototype._unsetOnCancel = function() {
|
|
this._onCancelField = undefined;
|
|
};
|
|
|
|
Promise.prototype._isCancellable = function() {
|
|
return this.isPending() && !this._isCancelled();
|
|
};
|
|
|
|
Promise.prototype.isCancellable = function() {
|
|
return this.isPending() && !this.isCancelled();
|
|
};
|
|
|
|
Promise.prototype._doInvokeOnCancel = function(onCancelCallback, internalOnly) {
|
|
if (util.isArray(onCancelCallback)) {
|
|
for (var i = 0; i < onCancelCallback.length; ++i) {
|
|
this._doInvokeOnCancel(onCancelCallback[i], internalOnly);
|
|
}
|
|
} else if (onCancelCallback !== undefined) {
|
|
if (typeof onCancelCallback === "function") {
|
|
if (!internalOnly) {
|
|
var e = tryCatch(onCancelCallback).call(this._boundValue());
|
|
if (e === errorObj) {
|
|
this._attachExtraTrace(e.e);
|
|
async.throwLater(e.e);
|
|
}
|
|
}
|
|
} else {
|
|
onCancelCallback._resultCancelled(this);
|
|
}
|
|
}
|
|
};
|
|
|
|
Promise.prototype._invokeOnCancel = function() {
|
|
var onCancelCallback = this._onCancel();
|
|
this._unsetOnCancel();
|
|
async.invoke(this._doInvokeOnCancel, this, onCancelCallback);
|
|
};
|
|
|
|
Promise.prototype._invokeInternalOnCancel = function() {
|
|
if (this._isCancellable()) {
|
|
this._doInvokeOnCancel(this._onCancel(), true);
|
|
this._unsetOnCancel();
|
|
}
|
|
};
|
|
|
|
Promise.prototype._resultCancelled = function() {
|
|
this.cancel();
|
|
};
|
|
|
|
};
|
|
|
|
},{"./util":21}],5:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(NEXT_FILTER) {
|
|
var util = _dereq_("./util");
|
|
var getKeys = _dereq_("./es5").keys;
|
|
var tryCatch = util.tryCatch;
|
|
var errorObj = util.errorObj;
|
|
|
|
function catchFilter(instances, cb, promise) {
|
|
return function(e) {
|
|
var boundTo = promise._boundValue();
|
|
predicateLoop: for (var i = 0; i < instances.length; ++i) {
|
|
var item = instances[i];
|
|
|
|
if (item === Error ||
|
|
(item != null && item.prototype instanceof Error)) {
|
|
if (e instanceof item) {
|
|
return tryCatch(cb).call(boundTo, e);
|
|
}
|
|
} else if (typeof item === "function") {
|
|
var matchesPredicate = tryCatch(item).call(boundTo, e);
|
|
if (matchesPredicate === errorObj) {
|
|
return matchesPredicate;
|
|
} else if (matchesPredicate) {
|
|
return tryCatch(cb).call(boundTo, e);
|
|
}
|
|
} else if (util.isObject(e)) {
|
|
var keys = getKeys(item);
|
|
for (var j = 0; j < keys.length; ++j) {
|
|
var key = keys[j];
|
|
if (item[key] != e[key]) {
|
|
continue predicateLoop;
|
|
}
|
|
}
|
|
return tryCatch(cb).call(boundTo, e);
|
|
}
|
|
}
|
|
return NEXT_FILTER;
|
|
};
|
|
}
|
|
|
|
return catchFilter;
|
|
};
|
|
|
|
},{"./es5":10,"./util":21}],6:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(Promise) {
|
|
var longStackTraces = false;
|
|
var contextStack = [];
|
|
|
|
Promise.prototype._promiseCreated = function() {};
|
|
Promise.prototype._pushContext = function() {};
|
|
Promise.prototype._popContext = function() {return null;};
|
|
Promise._peekContext = Promise.prototype._peekContext = function() {};
|
|
|
|
function Context() {
|
|
this._trace = new Context.CapturedTrace(peekContext());
|
|
}
|
|
Context.prototype._pushContext = function () {
|
|
if (this._trace !== undefined) {
|
|
this._trace._promiseCreated = null;
|
|
contextStack.push(this._trace);
|
|
}
|
|
};
|
|
|
|
Context.prototype._popContext = function () {
|
|
if (this._trace !== undefined) {
|
|
var trace = contextStack.pop();
|
|
var ret = trace._promiseCreated;
|
|
trace._promiseCreated = null;
|
|
return ret;
|
|
}
|
|
return null;
|
|
};
|
|
|
|
function createContext() {
|
|
if (longStackTraces) return new Context();
|
|
}
|
|
|
|
function peekContext() {
|
|
var lastIndex = contextStack.length - 1;
|
|
if (lastIndex >= 0) {
|
|
return contextStack[lastIndex];
|
|
}
|
|
return undefined;
|
|
}
|
|
Context.CapturedTrace = null;
|
|
Context.create = createContext;
|
|
Context.deactivateLongStackTraces = function() {};
|
|
Context.activateLongStackTraces = function() {
|
|
var Promise_pushContext = Promise.prototype._pushContext;
|
|
var Promise_popContext = Promise.prototype._popContext;
|
|
var Promise_PeekContext = Promise._peekContext;
|
|
var Promise_peekContext = Promise.prototype._peekContext;
|
|
var Promise_promiseCreated = Promise.prototype._promiseCreated;
|
|
Context.deactivateLongStackTraces = function() {
|
|
Promise.prototype._pushContext = Promise_pushContext;
|
|
Promise.prototype._popContext = Promise_popContext;
|
|
Promise._peekContext = Promise_PeekContext;
|
|
Promise.prototype._peekContext = Promise_peekContext;
|
|
Promise.prototype._promiseCreated = Promise_promiseCreated;
|
|
longStackTraces = false;
|
|
};
|
|
longStackTraces = true;
|
|
Promise.prototype._pushContext = Context.prototype._pushContext;
|
|
Promise.prototype._popContext = Context.prototype._popContext;
|
|
Promise._peekContext = Promise.prototype._peekContext = peekContext;
|
|
Promise.prototype._promiseCreated = function() {
|
|
var ctx = this._peekContext();
|
|
if (ctx && ctx._promiseCreated == null) ctx._promiseCreated = this;
|
|
};
|
|
};
|
|
return Context;
|
|
};
|
|
|
|
},{}],7:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(Promise, Context,
|
|
enableAsyncHooks, disableAsyncHooks) {
|
|
var async = Promise._async;
|
|
var Warning = _dereq_("./errors").Warning;
|
|
var util = _dereq_("./util");
|
|
var es5 = _dereq_("./es5");
|
|
var canAttachTrace = util.canAttachTrace;
|
|
var unhandledRejectionHandled;
|
|
var possiblyUnhandledRejection;
|
|
var bluebirdFramePattern =
|
|
/[\\\/]bluebird[\\\/]js[\\\/](release|debug|instrumented)/;
|
|
var nodeFramePattern = /\((?:timers\.js):\d+:\d+\)/;
|
|
var parseLinePattern = /[\/<\(](.+?):(\d+):(\d+)\)?\s*$/;
|
|
var stackFramePattern = null;
|
|
var formatStack = null;
|
|
var indentStackFrames = false;
|
|
var printWarning;
|
|
var debugging = !!(util.env("BLUEBIRD_DEBUG") != 0 &&
|
|
(true ||
|
|
util.env("BLUEBIRD_DEBUG") ||
|
|
util.env("NODE_ENV") === "development"));
|
|
|
|
var warnings = !!(util.env("BLUEBIRD_WARNINGS") != 0 &&
|
|
(debugging || util.env("BLUEBIRD_WARNINGS")));
|
|
|
|
var longStackTraces = !!(util.env("BLUEBIRD_LONG_STACK_TRACES") != 0 &&
|
|
(debugging || util.env("BLUEBIRD_LONG_STACK_TRACES")));
|
|
|
|
var wForgottenReturn = util.env("BLUEBIRD_W_FORGOTTEN_RETURN") != 0 &&
|
|
(warnings || !!util.env("BLUEBIRD_W_FORGOTTEN_RETURN"));
|
|
|
|
var deferUnhandledRejectionCheck;
|
|
(function() {
|
|
var promises = [];
|
|
|
|
function unhandledRejectionCheck() {
|
|
for (var i = 0; i < promises.length; ++i) {
|
|
promises[i]._notifyUnhandledRejection();
|
|
}
|
|
unhandledRejectionClear();
|
|
}
|
|
|
|
function unhandledRejectionClear() {
|
|
promises.length = 0;
|
|
}
|
|
|
|
deferUnhandledRejectionCheck = function(promise) {
|
|
promises.push(promise);
|
|
setTimeout(unhandledRejectionCheck, 1);
|
|
};
|
|
|
|
es5.defineProperty(Promise, "_unhandledRejectionCheck", {
|
|
value: unhandledRejectionCheck
|
|
});
|
|
es5.defineProperty(Promise, "_unhandledRejectionClear", {
|
|
value: unhandledRejectionClear
|
|
});
|
|
})();
|
|
|
|
Promise.prototype.suppressUnhandledRejections = function() {
|
|
var target = this._target();
|
|
target._bitField = ((target._bitField & (~1048576)) |
|
|
524288);
|
|
};
|
|
|
|
Promise.prototype._ensurePossibleRejectionHandled = function () {
|
|
if ((this._bitField & 524288) !== 0) return;
|
|
this._setRejectionIsUnhandled();
|
|
deferUnhandledRejectionCheck(this);
|
|
};
|
|
|
|
Promise.prototype._notifyUnhandledRejectionIsHandled = function () {
|
|
fireRejectionEvent("rejectionHandled",
|
|
unhandledRejectionHandled, undefined, this);
|
|
};
|
|
|
|
Promise.prototype._setReturnedNonUndefined = function() {
|
|
this._bitField = this._bitField | 268435456;
|
|
};
|
|
|
|
Promise.prototype._returnedNonUndefined = function() {
|
|
return (this._bitField & 268435456) !== 0;
|
|
};
|
|
|
|
Promise.prototype._notifyUnhandledRejection = function () {
|
|
if (this._isRejectionUnhandled()) {
|
|
var reason = this._settledValue();
|
|
this._setUnhandledRejectionIsNotified();
|
|
fireRejectionEvent("unhandledRejection",
|
|
possiblyUnhandledRejection, reason, this);
|
|
}
|
|
};
|
|
|
|
Promise.prototype._setUnhandledRejectionIsNotified = function () {
|
|
this._bitField = this._bitField | 262144;
|
|
};
|
|
|
|
Promise.prototype._unsetUnhandledRejectionIsNotified = function () {
|
|
this._bitField = this._bitField & (~262144);
|
|
};
|
|
|
|
Promise.prototype._isUnhandledRejectionNotified = function () {
|
|
return (this._bitField & 262144) > 0;
|
|
};
|
|
|
|
Promise.prototype._setRejectionIsUnhandled = function () {
|
|
this._bitField = this._bitField | 1048576;
|
|
};
|
|
|
|
Promise.prototype._unsetRejectionIsUnhandled = function () {
|
|
this._bitField = this._bitField & (~1048576);
|
|
if (this._isUnhandledRejectionNotified()) {
|
|
this._unsetUnhandledRejectionIsNotified();
|
|
this._notifyUnhandledRejectionIsHandled();
|
|
}
|
|
};
|
|
|
|
Promise.prototype._isRejectionUnhandled = function () {
|
|
return (this._bitField & 1048576) > 0;
|
|
};
|
|
|
|
Promise.prototype._warn = function(message, shouldUseOwnTrace, promise) {
|
|
return warn(message, shouldUseOwnTrace, promise || this);
|
|
};
|
|
|
|
Promise.onPossiblyUnhandledRejection = function (fn) {
|
|
var context = Promise._getContext();
|
|
possiblyUnhandledRejection = util.contextBind(context, fn);
|
|
};
|
|
|
|
Promise.onUnhandledRejectionHandled = function (fn) {
|
|
var context = Promise._getContext();
|
|
unhandledRejectionHandled = util.contextBind(context, fn);
|
|
};
|
|
|
|
var disableLongStackTraces = function() {};
|
|
Promise.longStackTraces = function () {
|
|
if (async.haveItemsQueued() && !config.longStackTraces) {
|
|
throw new Error("cannot enable long stack traces after promises have been created\u000a\u000a See http://goo.gl/MqrFmX\u000a");
|
|
}
|
|
if (!config.longStackTraces && longStackTracesIsSupported()) {
|
|
var Promise_captureStackTrace = Promise.prototype._captureStackTrace;
|
|
var Promise_attachExtraTrace = Promise.prototype._attachExtraTrace;
|
|
var Promise_dereferenceTrace = Promise.prototype._dereferenceTrace;
|
|
config.longStackTraces = true;
|
|
disableLongStackTraces = function() {
|
|
if (async.haveItemsQueued() && !config.longStackTraces) {
|
|
throw new Error("cannot enable long stack traces after promises have been created\u000a\u000a See http://goo.gl/MqrFmX\u000a");
|
|
}
|
|
Promise.prototype._captureStackTrace = Promise_captureStackTrace;
|
|
Promise.prototype._attachExtraTrace = Promise_attachExtraTrace;
|
|
Promise.prototype._dereferenceTrace = Promise_dereferenceTrace;
|
|
Context.deactivateLongStackTraces();
|
|
config.longStackTraces = false;
|
|
};
|
|
Promise.prototype._captureStackTrace = longStackTracesCaptureStackTrace;
|
|
Promise.prototype._attachExtraTrace = longStackTracesAttachExtraTrace;
|
|
Promise.prototype._dereferenceTrace = longStackTracesDereferenceTrace;
|
|
Context.activateLongStackTraces();
|
|
}
|
|
};
|
|
|
|
Promise.hasLongStackTraces = function () {
|
|
return config.longStackTraces && longStackTracesIsSupported();
|
|
};
|
|
|
|
|
|
var legacyHandlers = {
|
|
unhandledrejection: {
|
|
before: function() {
|
|
var ret = util.global.onunhandledrejection;
|
|
util.global.onunhandledrejection = null;
|
|
return ret;
|
|
},
|
|
after: function(fn) {
|
|
util.global.onunhandledrejection = fn;
|
|
}
|
|
},
|
|
rejectionhandled: {
|
|
before: function() {
|
|
var ret = util.global.onrejectionhandled;
|
|
util.global.onrejectionhandled = null;
|
|
return ret;
|
|
},
|
|
after: function(fn) {
|
|
util.global.onrejectionhandled = fn;
|
|
}
|
|
}
|
|
};
|
|
|
|
var fireDomEvent = (function() {
|
|
var dispatch = function(legacy, e) {
|
|
if (legacy) {
|
|
var fn;
|
|
try {
|
|
fn = legacy.before();
|
|
return !util.global.dispatchEvent(e);
|
|
} finally {
|
|
legacy.after(fn);
|
|
}
|
|
} else {
|
|
return !util.global.dispatchEvent(e);
|
|
}
|
|
};
|
|
try {
|
|
if (typeof CustomEvent === "function") {
|
|
var event = new CustomEvent("CustomEvent");
|
|
util.global.dispatchEvent(event);
|
|
return function(name, event) {
|
|
name = name.toLowerCase();
|
|
var eventData = {
|
|
detail: event,
|
|
cancelable: true
|
|
};
|
|
var domEvent = new CustomEvent(name, eventData);
|
|
es5.defineProperty(
|
|
domEvent, "promise", {value: event.promise});
|
|
es5.defineProperty(
|
|
domEvent, "reason", {value: event.reason});
|
|
|
|
return dispatch(legacyHandlers[name], domEvent);
|
|
};
|
|
} else if (typeof Event === "function") {
|
|
var event = new Event("CustomEvent");
|
|
util.global.dispatchEvent(event);
|
|
return function(name, event) {
|
|
name = name.toLowerCase();
|
|
var domEvent = new Event(name, {
|
|
cancelable: true
|
|
});
|
|
domEvent.detail = event;
|
|
es5.defineProperty(domEvent, "promise", {value: event.promise});
|
|
es5.defineProperty(domEvent, "reason", {value: event.reason});
|
|
return dispatch(legacyHandlers[name], domEvent);
|
|
};
|
|
} else {
|
|
var event = document.createEvent("CustomEvent");
|
|
event.initCustomEvent("testingtheevent", false, true, {});
|
|
util.global.dispatchEvent(event);
|
|
return function(name, event) {
|
|
name = name.toLowerCase();
|
|
var domEvent = document.createEvent("CustomEvent");
|
|
domEvent.initCustomEvent(name, false, true,
|
|
event);
|
|
return dispatch(legacyHandlers[name], domEvent);
|
|
};
|
|
}
|
|
} catch (e) {}
|
|
return function() {
|
|
return false;
|
|
};
|
|
})();
|
|
|
|
var fireGlobalEvent = (function() {
|
|
if (util.isNode) {
|
|
return function() {
|
|
return process.emit.apply(process, arguments);
|
|
};
|
|
} else {
|
|
if (!util.global) {
|
|
return function() {
|
|
return false;
|
|
};
|
|
}
|
|
return function(name) {
|
|
var methodName = "on" + name.toLowerCase();
|
|
var method = util.global[methodName];
|
|
if (!method) return false;
|
|
method.apply(util.global, [].slice.call(arguments, 1));
|
|
return true;
|
|
};
|
|
}
|
|
})();
|
|
|
|
function generatePromiseLifecycleEventObject(name, promise) {
|
|
return {promise: promise};
|
|
}
|
|
|
|
var eventToObjectGenerator = {
|
|
promiseCreated: generatePromiseLifecycleEventObject,
|
|
promiseFulfilled: generatePromiseLifecycleEventObject,
|
|
promiseRejected: generatePromiseLifecycleEventObject,
|
|
promiseResolved: generatePromiseLifecycleEventObject,
|
|
promiseCancelled: generatePromiseLifecycleEventObject,
|
|
promiseChained: function(name, promise, child) {
|
|
return {promise: promise, child: child};
|
|
},
|
|
warning: function(name, warning) {
|
|
return {warning: warning};
|
|
},
|
|
unhandledRejection: function (name, reason, promise) {
|
|
return {reason: reason, promise: promise};
|
|
},
|
|
rejectionHandled: generatePromiseLifecycleEventObject
|
|
};
|
|
|
|
var activeFireEvent = function (name) {
|
|
var globalEventFired = false;
|
|
try {
|
|
globalEventFired = fireGlobalEvent.apply(null, arguments);
|
|
} catch (e) {
|
|
async.throwLater(e);
|
|
globalEventFired = true;
|
|
}
|
|
|
|
var domEventFired = false;
|
|
try {
|
|
domEventFired = fireDomEvent(name,
|
|
eventToObjectGenerator[name].apply(null, arguments));
|
|
} catch (e) {
|
|
async.throwLater(e);
|
|
domEventFired = true;
|
|
}
|
|
|
|
return domEventFired || globalEventFired;
|
|
};
|
|
|
|
Promise.config = function(opts) {
|
|
opts = Object(opts);
|
|
if ("longStackTraces" in opts) {
|
|
if (opts.longStackTraces) {
|
|
Promise.longStackTraces();
|
|
} else if (!opts.longStackTraces && Promise.hasLongStackTraces()) {
|
|
disableLongStackTraces();
|
|
}
|
|
}
|
|
if ("warnings" in opts) {
|
|
var warningsOption = opts.warnings;
|
|
config.warnings = !!warningsOption;
|
|
wForgottenReturn = config.warnings;
|
|
|
|
if (util.isObject(warningsOption)) {
|
|
if ("wForgottenReturn" in warningsOption) {
|
|
wForgottenReturn = !!warningsOption.wForgottenReturn;
|
|
}
|
|
}
|
|
}
|
|
if ("cancellation" in opts && opts.cancellation && !config.cancellation) {
|
|
if (async.haveItemsQueued()) {
|
|
throw new Error(
|
|
"cannot enable cancellation after promises are in use");
|
|
}
|
|
Promise.prototype._clearCancellationData =
|
|
cancellationClearCancellationData;
|
|
Promise.prototype._propagateFrom = cancellationPropagateFrom;
|
|
Promise.prototype._onCancel = cancellationOnCancel;
|
|
Promise.prototype._setOnCancel = cancellationSetOnCancel;
|
|
Promise.prototype._attachCancellationCallback =
|
|
cancellationAttachCancellationCallback;
|
|
Promise.prototype._execute = cancellationExecute;
|
|
propagateFromFunction = cancellationPropagateFrom;
|
|
config.cancellation = true;
|
|
}
|
|
if ("monitoring" in opts) {
|
|
if (opts.monitoring && !config.monitoring) {
|
|
config.monitoring = true;
|
|
Promise.prototype._fireEvent = activeFireEvent;
|
|
} else if (!opts.monitoring && config.monitoring) {
|
|
config.monitoring = false;
|
|
Promise.prototype._fireEvent = defaultFireEvent;
|
|
}
|
|
}
|
|
if ("asyncHooks" in opts && util.nodeSupportsAsyncResource) {
|
|
var prev = config.asyncHooks;
|
|
var cur = !!opts.asyncHooks;
|
|
if (prev !== cur) {
|
|
config.asyncHooks = cur;
|
|
if (cur) {
|
|
enableAsyncHooks();
|
|
} else {
|
|
disableAsyncHooks();
|
|
}
|
|
}
|
|
}
|
|
return Promise;
|
|
};
|
|
|
|
function defaultFireEvent() { return false; }
|
|
|
|
Promise.prototype._fireEvent = defaultFireEvent;
|
|
Promise.prototype._execute = function(executor, resolve, reject) {
|
|
try {
|
|
executor(resolve, reject);
|
|
} catch (e) {
|
|
return e;
|
|
}
|
|
};
|
|
Promise.prototype._onCancel = function () {};
|
|
Promise.prototype._setOnCancel = function (handler) { ; };
|
|
Promise.prototype._attachCancellationCallback = function(onCancel) {
|
|
;
|
|
};
|
|
Promise.prototype._captureStackTrace = function () {};
|
|
Promise.prototype._attachExtraTrace = function () {};
|
|
Promise.prototype._dereferenceTrace = function () {};
|
|
Promise.prototype._clearCancellationData = function() {};
|
|
Promise.prototype._propagateFrom = function (parent, flags) {
|
|
;
|
|
;
|
|
};
|
|
|
|
function cancellationExecute(executor, resolve, reject) {
|
|
var promise = this;
|
|
try {
|
|
executor(resolve, reject, function(onCancel) {
|
|
if (typeof onCancel !== "function") {
|
|
throw new TypeError("onCancel must be a function, got: " +
|
|
util.toString(onCancel));
|
|
}
|
|
promise._attachCancellationCallback(onCancel);
|
|
});
|
|
} catch (e) {
|
|
return e;
|
|
}
|
|
}
|
|
|
|
function cancellationAttachCancellationCallback(onCancel) {
|
|
if (!this._isCancellable()) return this;
|
|
|
|
var previousOnCancel = this._onCancel();
|
|
if (previousOnCancel !== undefined) {
|
|
if (util.isArray(previousOnCancel)) {
|
|
previousOnCancel.push(onCancel);
|
|
} else {
|
|
this._setOnCancel([previousOnCancel, onCancel]);
|
|
}
|
|
} else {
|
|
this._setOnCancel(onCancel);
|
|
}
|
|
}
|
|
|
|
function cancellationOnCancel() {
|
|
return this._onCancelField;
|
|
}
|
|
|
|
function cancellationSetOnCancel(onCancel) {
|
|
this._onCancelField = onCancel;
|
|
}
|
|
|
|
function cancellationClearCancellationData() {
|
|
this._cancellationParent = undefined;
|
|
this._onCancelField = undefined;
|
|
}
|
|
|
|
function cancellationPropagateFrom(parent, flags) {
|
|
if ((flags & 1) !== 0) {
|
|
this._cancellationParent = parent;
|
|
var branchesRemainingToCancel = parent._branchesRemainingToCancel;
|
|
if (branchesRemainingToCancel === undefined) {
|
|
branchesRemainingToCancel = 0;
|
|
}
|
|
parent._branchesRemainingToCancel = branchesRemainingToCancel + 1;
|
|
}
|
|
if ((flags & 2) !== 0 && parent._isBound()) {
|
|
this._setBoundTo(parent._boundTo);
|
|
}
|
|
}
|
|
|
|
function bindingPropagateFrom(parent, flags) {
|
|
if ((flags & 2) !== 0 && parent._isBound()) {
|
|
this._setBoundTo(parent._boundTo);
|
|
}
|
|
}
|
|
var propagateFromFunction = bindingPropagateFrom;
|
|
|
|
function boundValueFunction() {
|
|
var ret = this._boundTo;
|
|
if (ret !== undefined) {
|
|
if (ret instanceof Promise) {
|
|
if (ret.isFulfilled()) {
|
|
return ret.value();
|
|
} else {
|
|
return undefined;
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
function longStackTracesCaptureStackTrace() {
|
|
this._trace = new CapturedTrace(this._peekContext());
|
|
}
|
|
|
|
function longStackTracesAttachExtraTrace(error, ignoreSelf) {
|
|
if (canAttachTrace(error)) {
|
|
var trace = this._trace;
|
|
if (trace !== undefined) {
|
|
if (ignoreSelf) trace = trace._parent;
|
|
}
|
|
if (trace !== undefined) {
|
|
trace.attachExtraTrace(error);
|
|
} else if (!error.__stackCleaned__) {
|
|
var parsed = parseStackAndMessage(error);
|
|
util.notEnumerableProp(error, "stack",
|
|
parsed.message + "\n" + parsed.stack.join("\n"));
|
|
util.notEnumerableProp(error, "__stackCleaned__", true);
|
|
}
|
|
}
|
|
}
|
|
|
|
function longStackTracesDereferenceTrace() {
|
|
this._trace = undefined;
|
|
}
|
|
|
|
function checkForgottenReturns(returnValue, promiseCreated, name, promise,
|
|
parent) {
|
|
if (returnValue === undefined && promiseCreated !== null &&
|
|
wForgottenReturn) {
|
|
if (parent !== undefined && parent._returnedNonUndefined()) return;
|
|
if ((promise._bitField & 65535) === 0) return;
|
|
|
|
if (name) name = name + " ";
|
|
var handlerLine = "";
|
|
var creatorLine = "";
|
|
if (promiseCreated._trace) {
|
|
var traceLines = promiseCreated._trace.stack.split("\n");
|
|
var stack = cleanStack(traceLines);
|
|
for (var i = stack.length - 1; i >= 0; --i) {
|
|
var line = stack[i];
|
|
if (!nodeFramePattern.test(line)) {
|
|
var lineMatches = line.match(parseLinePattern);
|
|
if (lineMatches) {
|
|
handlerLine = "at " + lineMatches[1] +
|
|
":" + lineMatches[2] + ":" + lineMatches[3] + " ";
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (stack.length > 0) {
|
|
var firstUserLine = stack[0];
|
|
for (var i = 0; i < traceLines.length; ++i) {
|
|
|
|
if (traceLines[i] === firstUserLine) {
|
|
if (i > 0) {
|
|
creatorLine = "\n" + traceLines[i - 1];
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
var msg = "a promise was created in a " + name +
|
|
"handler " + handlerLine + "but was not returned from it, " +
|
|
"see http://goo.gl/rRqMUw" +
|
|
creatorLine;
|
|
promise._warn(msg, true, promiseCreated);
|
|
}
|
|
}
|
|
|
|
function deprecated(name, replacement) {
|
|
var message = name +
|
|
" is deprecated and will be removed in a future version.";
|
|
if (replacement) message += " Use " + replacement + " instead.";
|
|
return warn(message);
|
|
}
|
|
|
|
function warn(message, shouldUseOwnTrace, promise) {
|
|
if (!config.warnings) return;
|
|
var warning = new Warning(message);
|
|
var ctx;
|
|
if (shouldUseOwnTrace) {
|
|
promise._attachExtraTrace(warning);
|
|
} else if (config.longStackTraces && (ctx = Promise._peekContext())) {
|
|
ctx.attachExtraTrace(warning);
|
|
} else {
|
|
var parsed = parseStackAndMessage(warning);
|
|
warning.stack = parsed.message + "\n" + parsed.stack.join("\n");
|
|
}
|
|
|
|
if (!activeFireEvent("warning", warning)) {
|
|
formatAndLogError(warning, "", true);
|
|
}
|
|
}
|
|
|
|
function reconstructStack(message, stacks) {
|
|
for (var i = 0; i < stacks.length - 1; ++i) {
|
|
stacks[i].push("From previous event:");
|
|
stacks[i] = stacks[i].join("\n");
|
|
}
|
|
if (i < stacks.length) {
|
|
stacks[i] = stacks[i].join("\n");
|
|
}
|
|
return message + "\n" + stacks.join("\n");
|
|
}
|
|
|
|
function removeDuplicateOrEmptyJumps(stacks) {
|
|
for (var i = 0; i < stacks.length; ++i) {
|
|
if (stacks[i].length === 0 ||
|
|
((i + 1 < stacks.length) && stacks[i][0] === stacks[i+1][0])) {
|
|
stacks.splice(i, 1);
|
|
i--;
|
|
}
|
|
}
|
|
}
|
|
|
|
function removeCommonRoots(stacks) {
|
|
var current = stacks[0];
|
|
for (var i = 1; i < stacks.length; ++i) {
|
|
var prev = stacks[i];
|
|
var currentLastIndex = current.length - 1;
|
|
var currentLastLine = current[currentLastIndex];
|
|
var commonRootMeetPoint = -1;
|
|
|
|
for (var j = prev.length - 1; j >= 0; --j) {
|
|
if (prev[j] === currentLastLine) {
|
|
commonRootMeetPoint = j;
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (var j = commonRootMeetPoint; j >= 0; --j) {
|
|
var line = prev[j];
|
|
if (current[currentLastIndex] === line) {
|
|
current.pop();
|
|
currentLastIndex--;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
current = prev;
|
|
}
|
|
}
|
|
|
|
function cleanStack(stack) {
|
|
var ret = [];
|
|
for (var i = 0; i < stack.length; ++i) {
|
|
var line = stack[i];
|
|
var isTraceLine = " (No stack trace)" === line ||
|
|
stackFramePattern.test(line);
|
|
var isInternalFrame = isTraceLine && shouldIgnore(line);
|
|
if (isTraceLine && !isInternalFrame) {
|
|
if (indentStackFrames && line.charAt(0) !== " ") {
|
|
line = " " + line;
|
|
}
|
|
ret.push(line);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
function stackFramesAsArray(error) {
|
|
var stack = error.stack.replace(/\s+$/g, "").split("\n");
|
|
for (var i = 0; i < stack.length; ++i) {
|
|
var line = stack[i];
|
|
if (" (No stack trace)" === line || stackFramePattern.test(line)) {
|
|
break;
|
|
}
|
|
}
|
|
if (i > 0 && error.name != "SyntaxError") {
|
|
stack = stack.slice(i);
|
|
}
|
|
return stack;
|
|
}
|
|
|
|
function parseStackAndMessage(error) {
|
|
var stack = error.stack;
|
|
var message = error.toString();
|
|
stack = typeof stack === "string" && stack.length > 0
|
|
? stackFramesAsArray(error) : [" (No stack trace)"];
|
|
return {
|
|
message: message,
|
|
stack: error.name == "SyntaxError" ? stack : cleanStack(stack)
|
|
};
|
|
}
|
|
|
|
function formatAndLogError(error, title, isSoft) {
|
|
if (typeof console !== "undefined") {
|
|
var message;
|
|
if (util.isObject(error)) {
|
|
var stack = error.stack;
|
|
message = title + formatStack(stack, error);
|
|
} else {
|
|
message = title + String(error);
|
|
}
|
|
if (typeof printWarning === "function") {
|
|
printWarning(message, isSoft);
|
|
} else if (typeof console.log === "function" ||
|
|
typeof console.log === "object") {
|
|
console.log(message);
|
|
}
|
|
}
|
|
}
|
|
|
|
function fireRejectionEvent(name, localHandler, reason, promise) {
|
|
var localEventFired = false;
|
|
try {
|
|
if (typeof localHandler === "function") {
|
|
localEventFired = true;
|
|
if (name === "rejectionHandled") {
|
|
localHandler(promise);
|
|
} else {
|
|
localHandler(reason, promise);
|
|
}
|
|
}
|
|
} catch (e) {
|
|
async.throwLater(e);
|
|
}
|
|
|
|
if (name === "unhandledRejection") {
|
|
if (!activeFireEvent(name, reason, promise) && !localEventFired) {
|
|
formatAndLogError(reason, "Unhandled rejection ");
|
|
}
|
|
} else {
|
|
activeFireEvent(name, promise);
|
|
}
|
|
}
|
|
|
|
function formatNonError(obj) {
|
|
var str;
|
|
if (typeof obj === "function") {
|
|
str = "[function " +
|
|
(obj.name || "anonymous") +
|
|
"]";
|
|
} else {
|
|
str = obj && typeof obj.toString === "function"
|
|
? obj.toString() : util.toString(obj);
|
|
var ruselessToString = /\[object [a-zA-Z0-9$_]+\]/;
|
|
if (ruselessToString.test(str)) {
|
|
try {
|
|
var newStr = JSON.stringify(obj);
|
|
str = newStr;
|
|
}
|
|
catch(e) {
|
|
|
|
}
|
|
}
|
|
if (str.length === 0) {
|
|
str = "(empty array)";
|
|
}
|
|
}
|
|
return ("(<" + snip(str) + ">, no stack trace)");
|
|
}
|
|
|
|
function snip(str) {
|
|
var maxChars = 41;
|
|
if (str.length < maxChars) {
|
|
return str;
|
|
}
|
|
return str.substr(0, maxChars - 3) + "...";
|
|
}
|
|
|
|
function longStackTracesIsSupported() {
|
|
return typeof captureStackTrace === "function";
|
|
}
|
|
|
|
var shouldIgnore = function() { return false; };
|
|
var parseLineInfoRegex = /[\/<\(]([^:\/]+):(\d+):(?:\d+)\)?\s*$/;
|
|
function parseLineInfo(line) {
|
|
var matches = line.match(parseLineInfoRegex);
|
|
if (matches) {
|
|
return {
|
|
fileName: matches[1],
|
|
line: parseInt(matches[2], 10)
|
|
};
|
|
}
|
|
}
|
|
|
|
function setBounds(firstLineError, lastLineError) {
|
|
if (!longStackTracesIsSupported()) return;
|
|
var firstStackLines = (firstLineError.stack || "").split("\n");
|
|
var lastStackLines = (lastLineError.stack || "").split("\n");
|
|
var firstIndex = -1;
|
|
var lastIndex = -1;
|
|
var firstFileName;
|
|
var lastFileName;
|
|
for (var i = 0; i < firstStackLines.length; ++i) {
|
|
var result = parseLineInfo(firstStackLines[i]);
|
|
if (result) {
|
|
firstFileName = result.fileName;
|
|
firstIndex = result.line;
|
|
break;
|
|
}
|
|
}
|
|
for (var i = 0; i < lastStackLines.length; ++i) {
|
|
var result = parseLineInfo(lastStackLines[i]);
|
|
if (result) {
|
|
lastFileName = result.fileName;
|
|
lastIndex = result.line;
|
|
break;
|
|
}
|
|
}
|
|
if (firstIndex < 0 || lastIndex < 0 || !firstFileName || !lastFileName ||
|
|
firstFileName !== lastFileName || firstIndex >= lastIndex) {
|
|
return;
|
|
}
|
|
|
|
shouldIgnore = function(line) {
|
|
if (bluebirdFramePattern.test(line)) return true;
|
|
var info = parseLineInfo(line);
|
|
if (info) {
|
|
if (info.fileName === firstFileName &&
|
|
(firstIndex <= info.line && info.line <= lastIndex)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
}
|
|
|
|
function CapturedTrace(parent) {
|
|
this._parent = parent;
|
|
this._promisesCreated = 0;
|
|
var length = this._length = 1 + (parent === undefined ? 0 : parent._length);
|
|
captureStackTrace(this, CapturedTrace);
|
|
if (length > 32) this.uncycle();
|
|
}
|
|
util.inherits(CapturedTrace, Error);
|
|
Context.CapturedTrace = CapturedTrace;
|
|
|
|
CapturedTrace.prototype.uncycle = function() {
|
|
var length = this._length;
|
|
if (length < 2) return;
|
|
var nodes = [];
|
|
var stackToIndex = {};
|
|
|
|
for (var i = 0, node = this; node !== undefined; ++i) {
|
|
nodes.push(node);
|
|
node = node._parent;
|
|
}
|
|
length = this._length = i;
|
|
for (var i = length - 1; i >= 0; --i) {
|
|
var stack = nodes[i].stack;
|
|
if (stackToIndex[stack] === undefined) {
|
|
stackToIndex[stack] = i;
|
|
}
|
|
}
|
|
for (var i = 0; i < length; ++i) {
|
|
var currentStack = nodes[i].stack;
|
|
var index = stackToIndex[currentStack];
|
|
if (index !== undefined && index !== i) {
|
|
if (index > 0) {
|
|
nodes[index - 1]._parent = undefined;
|
|
nodes[index - 1]._length = 1;
|
|
}
|
|
nodes[i]._parent = undefined;
|
|
nodes[i]._length = 1;
|
|
var cycleEdgeNode = i > 0 ? nodes[i - 1] : this;
|
|
|
|
if (index < length - 1) {
|
|
cycleEdgeNode._parent = nodes[index + 1];
|
|
cycleEdgeNode._parent.uncycle();
|
|
cycleEdgeNode._length =
|
|
cycleEdgeNode._parent._length + 1;
|
|
} else {
|
|
cycleEdgeNode._parent = undefined;
|
|
cycleEdgeNode._length = 1;
|
|
}
|
|
var currentChildLength = cycleEdgeNode._length + 1;
|
|
for (var j = i - 2; j >= 0; --j) {
|
|
nodes[j]._length = currentChildLength;
|
|
currentChildLength++;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
};
|
|
|
|
CapturedTrace.prototype.attachExtraTrace = function(error) {
|
|
if (error.__stackCleaned__) return;
|
|
this.uncycle();
|
|
var parsed = parseStackAndMessage(error);
|
|
var message = parsed.message;
|
|
var stacks = [parsed.stack];
|
|
|
|
var trace = this;
|
|
while (trace !== undefined) {
|
|
stacks.push(cleanStack(trace.stack.split("\n")));
|
|
trace = trace._parent;
|
|
}
|
|
removeCommonRoots(stacks);
|
|
removeDuplicateOrEmptyJumps(stacks);
|
|
util.notEnumerableProp(error, "stack", reconstructStack(message, stacks));
|
|
util.notEnumerableProp(error, "__stackCleaned__", true);
|
|
};
|
|
|
|
var captureStackTrace = (function stackDetection() {
|
|
var v8stackFramePattern = /^\s*at\s*/;
|
|
var v8stackFormatter = function(stack, error) {
|
|
if (typeof stack === "string") return stack;
|
|
|
|
if (error.name !== undefined &&
|
|
error.message !== undefined) {
|
|
return error.toString();
|
|
}
|
|
return formatNonError(error);
|
|
};
|
|
|
|
if (typeof Error.stackTraceLimit === "number" &&
|
|
typeof Error.captureStackTrace === "function") {
|
|
Error.stackTraceLimit += 6;
|
|
stackFramePattern = v8stackFramePattern;
|
|
formatStack = v8stackFormatter;
|
|
var captureStackTrace = Error.captureStackTrace;
|
|
|
|
shouldIgnore = function(line) {
|
|
return bluebirdFramePattern.test(line);
|
|
};
|
|
return function(receiver, ignoreUntil) {
|
|
Error.stackTraceLimit += 6;
|
|
captureStackTrace(receiver, ignoreUntil);
|
|
Error.stackTraceLimit -= 6;
|
|
};
|
|
}
|
|
var err = new Error();
|
|
|
|
if (typeof err.stack === "string" &&
|
|
err.stack.split("\n")[0].indexOf("stackDetection@") >= 0) {
|
|
stackFramePattern = /@/;
|
|
formatStack = v8stackFormatter;
|
|
indentStackFrames = true;
|
|
return function captureStackTrace(o) {
|
|
o.stack = new Error().stack;
|
|
};
|
|
}
|
|
|
|
var hasStackAfterThrow;
|
|
try { throw new Error(); }
|
|
catch(e) {
|
|
hasStackAfterThrow = ("stack" in e);
|
|
}
|
|
if (!("stack" in err) && hasStackAfterThrow &&
|
|
typeof Error.stackTraceLimit === "number") {
|
|
stackFramePattern = v8stackFramePattern;
|
|
formatStack = v8stackFormatter;
|
|
return function captureStackTrace(o) {
|
|
Error.stackTraceLimit += 6;
|
|
try { throw new Error(); }
|
|
catch(e) { o.stack = e.stack; }
|
|
Error.stackTraceLimit -= 6;
|
|
};
|
|
}
|
|
|
|
formatStack = function(stack, error) {
|
|
if (typeof stack === "string") return stack;
|
|
|
|
if ((typeof error === "object" ||
|
|
typeof error === "function") &&
|
|
error.name !== undefined &&
|
|
error.message !== undefined) {
|
|
return error.toString();
|
|
}
|
|
return formatNonError(error);
|
|
};
|
|
|
|
return null;
|
|
|
|
})([]);
|
|
|
|
if (typeof console !== "undefined" && typeof console.warn !== "undefined") {
|
|
printWarning = function (message) {
|
|
console.warn(message);
|
|
};
|
|
if (util.isNode && process.stderr.isTTY) {
|
|
printWarning = function(message, isSoft) {
|
|
var color = isSoft ? "\u001b[33m" : "\u001b[31m";
|
|
console.warn(color + message + "\u001b[0m\n");
|
|
};
|
|
} else if (!util.isNode && typeof (new Error().stack) === "string") {
|
|
printWarning = function(message, isSoft) {
|
|
console.warn("%c" + message,
|
|
isSoft ? "color: darkorange" : "color: red");
|
|
};
|
|
}
|
|
}
|
|
|
|
var config = {
|
|
warnings: warnings,
|
|
longStackTraces: false,
|
|
cancellation: false,
|
|
monitoring: false,
|
|
asyncHooks: false
|
|
};
|
|
|
|
if (longStackTraces) Promise.longStackTraces();
|
|
|
|
return {
|
|
asyncHooks: function() {
|
|
return config.asyncHooks;
|
|
},
|
|
longStackTraces: function() {
|
|
return config.longStackTraces;
|
|
},
|
|
warnings: function() {
|
|
return config.warnings;
|
|
},
|
|
cancellation: function() {
|
|
return config.cancellation;
|
|
},
|
|
monitoring: function() {
|
|
return config.monitoring;
|
|
},
|
|
propagateFromFunction: function() {
|
|
return propagateFromFunction;
|
|
},
|
|
boundValueFunction: function() {
|
|
return boundValueFunction;
|
|
},
|
|
checkForgottenReturns: checkForgottenReturns,
|
|
setBounds: setBounds,
|
|
warn: warn,
|
|
deprecated: deprecated,
|
|
CapturedTrace: CapturedTrace,
|
|
fireDomEvent: fireDomEvent,
|
|
fireGlobalEvent: fireGlobalEvent
|
|
};
|
|
};
|
|
|
|
},{"./errors":9,"./es5":10,"./util":21}],8:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(Promise) {
|
|
function returner() {
|
|
return this.value;
|
|
}
|
|
function thrower() {
|
|
throw this.reason;
|
|
}
|
|
|
|
Promise.prototype["return"] =
|
|
Promise.prototype.thenReturn = function (value) {
|
|
if (value instanceof Promise) value.suppressUnhandledRejections();
|
|
return this._then(
|
|
returner, undefined, undefined, {value: value}, undefined);
|
|
};
|
|
|
|
Promise.prototype["throw"] =
|
|
Promise.prototype.thenThrow = function (reason) {
|
|
return this._then(
|
|
thrower, undefined, undefined, {reason: reason}, undefined);
|
|
};
|
|
|
|
Promise.prototype.catchThrow = function (reason) {
|
|
if (arguments.length <= 1) {
|
|
return this._then(
|
|
undefined, thrower, undefined, {reason: reason}, undefined);
|
|
} else {
|
|
var _reason = arguments[1];
|
|
var handler = function() {throw _reason;};
|
|
return this.caught(reason, handler);
|
|
}
|
|
};
|
|
|
|
Promise.prototype.catchReturn = function (value) {
|
|
if (arguments.length <= 1) {
|
|
if (value instanceof Promise) value.suppressUnhandledRejections();
|
|
return this._then(
|
|
undefined, returner, undefined, {value: value}, undefined);
|
|
} else {
|
|
var _value = arguments[1];
|
|
if (_value instanceof Promise) _value.suppressUnhandledRejections();
|
|
var handler = function() {return _value;};
|
|
return this.caught(value, handler);
|
|
}
|
|
};
|
|
};
|
|
|
|
},{}],9:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
var es5 = _dereq_("./es5");
|
|
var Objectfreeze = es5.freeze;
|
|
var util = _dereq_("./util");
|
|
var inherits = util.inherits;
|
|
var notEnumerableProp = util.notEnumerableProp;
|
|
|
|
function subError(nameProperty, defaultMessage) {
|
|
function SubError(message) {
|
|
if (!(this instanceof SubError)) return new SubError(message);
|
|
notEnumerableProp(this, "message",
|
|
typeof message === "string" ? message : defaultMessage);
|
|
notEnumerableProp(this, "name", nameProperty);
|
|
if (Error.captureStackTrace) {
|
|
Error.captureStackTrace(this, this.constructor);
|
|
} else {
|
|
Error.call(this);
|
|
}
|
|
}
|
|
inherits(SubError, Error);
|
|
return SubError;
|
|
}
|
|
|
|
var _TypeError, _RangeError;
|
|
var Warning = subError("Warning", "warning");
|
|
var CancellationError = subError("CancellationError", "cancellation error");
|
|
var TimeoutError = subError("TimeoutError", "timeout error");
|
|
var AggregateError = subError("AggregateError", "aggregate error");
|
|
try {
|
|
_TypeError = TypeError;
|
|
_RangeError = RangeError;
|
|
} catch(e) {
|
|
_TypeError = subError("TypeError", "type error");
|
|
_RangeError = subError("RangeError", "range error");
|
|
}
|
|
|
|
var methods = ("join pop push shift unshift slice filter forEach some " +
|
|
"every map indexOf lastIndexOf reduce reduceRight sort reverse").split(" ");
|
|
|
|
for (var i = 0; i < methods.length; ++i) {
|
|
if (typeof Array.prototype[methods[i]] === "function") {
|
|
AggregateError.prototype[methods[i]] = Array.prototype[methods[i]];
|
|
}
|
|
}
|
|
|
|
es5.defineProperty(AggregateError.prototype, "length", {
|
|
value: 0,
|
|
configurable: false,
|
|
writable: true,
|
|
enumerable: true
|
|
});
|
|
AggregateError.prototype["isOperational"] = true;
|
|
var level = 0;
|
|
AggregateError.prototype.toString = function() {
|
|
var indent = Array(level * 4 + 1).join(" ");
|
|
var ret = "\n" + indent + "AggregateError of:" + "\n";
|
|
level++;
|
|
indent = Array(level * 4 + 1).join(" ");
|
|
for (var i = 0; i < this.length; ++i) {
|
|
var str = this[i] === this ? "[Circular AggregateError]" : this[i] + "";
|
|
var lines = str.split("\n");
|
|
for (var j = 0; j < lines.length; ++j) {
|
|
lines[j] = indent + lines[j];
|
|
}
|
|
str = lines.join("\n");
|
|
ret += str + "\n";
|
|
}
|
|
level--;
|
|
return ret;
|
|
};
|
|
|
|
function OperationalError(message) {
|
|
if (!(this instanceof OperationalError))
|
|
return new OperationalError(message);
|
|
notEnumerableProp(this, "name", "OperationalError");
|
|
notEnumerableProp(this, "message", message);
|
|
this.cause = message;
|
|
this["isOperational"] = true;
|
|
|
|
if (message instanceof Error) {
|
|
notEnumerableProp(this, "message", message.message);
|
|
notEnumerableProp(this, "stack", message.stack);
|
|
} else if (Error.captureStackTrace) {
|
|
Error.captureStackTrace(this, this.constructor);
|
|
}
|
|
|
|
}
|
|
inherits(OperationalError, Error);
|
|
|
|
var errorTypes = Error["__BluebirdErrorTypes__"];
|
|
if (!errorTypes) {
|
|
errorTypes = Objectfreeze({
|
|
CancellationError: CancellationError,
|
|
TimeoutError: TimeoutError,
|
|
OperationalError: OperationalError,
|
|
RejectionError: OperationalError,
|
|
AggregateError: AggregateError
|
|
});
|
|
es5.defineProperty(Error, "__BluebirdErrorTypes__", {
|
|
value: errorTypes,
|
|
writable: false,
|
|
enumerable: false,
|
|
configurable: false
|
|
});
|
|
}
|
|
|
|
module.exports = {
|
|
Error: Error,
|
|
TypeError: _TypeError,
|
|
RangeError: _RangeError,
|
|
CancellationError: errorTypes.CancellationError,
|
|
OperationalError: errorTypes.OperationalError,
|
|
TimeoutError: errorTypes.TimeoutError,
|
|
AggregateError: errorTypes.AggregateError,
|
|
Warning: Warning
|
|
};
|
|
|
|
},{"./es5":10,"./util":21}],10:[function(_dereq_,module,exports){
|
|
var isES5 = (function(){
|
|
"use strict";
|
|
return this === undefined;
|
|
})();
|
|
|
|
if (isES5) {
|
|
module.exports = {
|
|
freeze: Object.freeze,
|
|
defineProperty: Object.defineProperty,
|
|
getDescriptor: Object.getOwnPropertyDescriptor,
|
|
keys: Object.keys,
|
|
names: Object.getOwnPropertyNames,
|
|
getPrototypeOf: Object.getPrototypeOf,
|
|
isArray: Array.isArray,
|
|
isES5: isES5,
|
|
propertyIsWritable: function(obj, prop) {
|
|
var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
|
|
return !!(!descriptor || descriptor.writable || descriptor.set);
|
|
}
|
|
};
|
|
} else {
|
|
var has = {}.hasOwnProperty;
|
|
var str = {}.toString;
|
|
var proto = {}.constructor.prototype;
|
|
|
|
var ObjectKeys = function (o) {
|
|
var ret = [];
|
|
for (var key in o) {
|
|
if (has.call(o, key)) {
|
|
ret.push(key);
|
|
}
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
var ObjectGetDescriptor = function(o, key) {
|
|
return {value: o[key]};
|
|
};
|
|
|
|
var ObjectDefineProperty = function (o, key, desc) {
|
|
o[key] = desc.value;
|
|
return o;
|
|
};
|
|
|
|
var ObjectFreeze = function (obj) {
|
|
return obj;
|
|
};
|
|
|
|
var ObjectGetPrototypeOf = function (obj) {
|
|
try {
|
|
return Object(obj).constructor.prototype;
|
|
}
|
|
catch (e) {
|
|
return proto;
|
|
}
|
|
};
|
|
|
|
var ArrayIsArray = function (obj) {
|
|
try {
|
|
return str.call(obj) === "[object Array]";
|
|
}
|
|
catch(e) {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
module.exports = {
|
|
isArray: ArrayIsArray,
|
|
keys: ObjectKeys,
|
|
names: ObjectKeys,
|
|
defineProperty: ObjectDefineProperty,
|
|
getDescriptor: ObjectGetDescriptor,
|
|
freeze: ObjectFreeze,
|
|
getPrototypeOf: ObjectGetPrototypeOf,
|
|
isES5: isES5,
|
|
propertyIsWritable: function() {
|
|
return true;
|
|
}
|
|
};
|
|
}
|
|
|
|
},{}],11:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(Promise, tryConvertToPromise, NEXT_FILTER) {
|
|
var util = _dereq_("./util");
|
|
var CancellationError = Promise.CancellationError;
|
|
var errorObj = util.errorObj;
|
|
var catchFilter = _dereq_("./catch_filter")(NEXT_FILTER);
|
|
|
|
function PassThroughHandlerContext(promise, type, handler) {
|
|
this.promise = promise;
|
|
this.type = type;
|
|
this.handler = handler;
|
|
this.called = false;
|
|
this.cancelPromise = null;
|
|
}
|
|
|
|
PassThroughHandlerContext.prototype.isFinallyHandler = function() {
|
|
return this.type === 0;
|
|
};
|
|
|
|
function FinallyHandlerCancelReaction(finallyHandler) {
|
|
this.finallyHandler = finallyHandler;
|
|
}
|
|
|
|
FinallyHandlerCancelReaction.prototype._resultCancelled = function() {
|
|
checkCancel(this.finallyHandler);
|
|
};
|
|
|
|
function checkCancel(ctx, reason) {
|
|
if (ctx.cancelPromise != null) {
|
|
if (arguments.length > 1) {
|
|
ctx.cancelPromise._reject(reason);
|
|
} else {
|
|
ctx.cancelPromise._cancel();
|
|
}
|
|
ctx.cancelPromise = null;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function succeed() {
|
|
return finallyHandler.call(this, this.promise._target()._settledValue());
|
|
}
|
|
function fail(reason) {
|
|
if (checkCancel(this, reason)) return;
|
|
errorObj.e = reason;
|
|
return errorObj;
|
|
}
|
|
function finallyHandler(reasonOrValue) {
|
|
var promise = this.promise;
|
|
var handler = this.handler;
|
|
|
|
if (!this.called) {
|
|
this.called = true;
|
|
var ret = this.isFinallyHandler()
|
|
? handler.call(promise._boundValue())
|
|
: handler.call(promise._boundValue(), reasonOrValue);
|
|
if (ret === NEXT_FILTER) {
|
|
return ret;
|
|
} else if (ret !== undefined) {
|
|
promise._setReturnedNonUndefined();
|
|
var maybePromise = tryConvertToPromise(ret, promise);
|
|
if (maybePromise instanceof Promise) {
|
|
if (this.cancelPromise != null) {
|
|
if (maybePromise._isCancelled()) {
|
|
var reason =
|
|
new CancellationError("late cancellation observer");
|
|
promise._attachExtraTrace(reason);
|
|
errorObj.e = reason;
|
|
return errorObj;
|
|
} else if (maybePromise.isPending()) {
|
|
maybePromise._attachCancellationCallback(
|
|
new FinallyHandlerCancelReaction(this));
|
|
}
|
|
}
|
|
return maybePromise._then(
|
|
succeed, fail, undefined, this, undefined);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (promise.isRejected()) {
|
|
checkCancel(this);
|
|
errorObj.e = reasonOrValue;
|
|
return errorObj;
|
|
} else {
|
|
checkCancel(this);
|
|
return reasonOrValue;
|
|
}
|
|
}
|
|
|
|
Promise.prototype._passThrough = function(handler, type, success, fail) {
|
|
if (typeof handler !== "function") return this.then();
|
|
return this._then(success,
|
|
fail,
|
|
undefined,
|
|
new PassThroughHandlerContext(this, type, handler),
|
|
undefined);
|
|
};
|
|
|
|
Promise.prototype.lastly =
|
|
Promise.prototype["finally"] = function (handler) {
|
|
return this._passThrough(handler,
|
|
0,
|
|
finallyHandler,
|
|
finallyHandler);
|
|
};
|
|
|
|
|
|
Promise.prototype.tap = function (handler) {
|
|
return this._passThrough(handler, 1, finallyHandler);
|
|
};
|
|
|
|
Promise.prototype.tapCatch = function (handlerOrPredicate) {
|
|
var len = arguments.length;
|
|
if(len === 1) {
|
|
return this._passThrough(handlerOrPredicate,
|
|
1,
|
|
undefined,
|
|
finallyHandler);
|
|
} else {
|
|
var catchInstances = new Array(len - 1),
|
|
j = 0, i;
|
|
for (i = 0; i < len - 1; ++i) {
|
|
var item = arguments[i];
|
|
if (util.isObject(item)) {
|
|
catchInstances[j++] = item;
|
|
} else {
|
|
return Promise.reject(new TypeError(
|
|
"tapCatch statement predicate: "
|
|
+ "expecting an object but got " + util.classString(item)
|
|
));
|
|
}
|
|
}
|
|
catchInstances.length = j;
|
|
var handler = arguments[i];
|
|
return this._passThrough(catchFilter(catchInstances, handler, this),
|
|
1,
|
|
undefined,
|
|
finallyHandler);
|
|
}
|
|
|
|
};
|
|
|
|
return PassThroughHandlerContext;
|
|
};
|
|
|
|
},{"./catch_filter":5,"./util":21}],12:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports =
|
|
function(Promise, PromiseArray, tryConvertToPromise, INTERNAL, async) {
|
|
var util = _dereq_("./util");
|
|
var canEvaluate = util.canEvaluate;
|
|
var tryCatch = util.tryCatch;
|
|
var errorObj = util.errorObj;
|
|
var reject;
|
|
|
|
if (!true) {
|
|
if (canEvaluate) {
|
|
var thenCallback = function(i) {
|
|
return new Function("value", "holder", " \n\
|
|
'use strict'; \n\
|
|
holder.pIndex = value; \n\
|
|
holder.checkFulfillment(this); \n\
|
|
".replace(/Index/g, i));
|
|
};
|
|
|
|
var promiseSetter = function(i) {
|
|
return new Function("promise", "holder", " \n\
|
|
'use strict'; \n\
|
|
holder.pIndex = promise; \n\
|
|
".replace(/Index/g, i));
|
|
};
|
|
|
|
var generateHolderClass = function(total) {
|
|
var props = new Array(total);
|
|
for (var i = 0; i < props.length; ++i) {
|
|
props[i] = "this.p" + (i+1);
|
|
}
|
|
var assignment = props.join(" = ") + " = null;";
|
|
var cancellationCode= "var promise;\n" + props.map(function(prop) {
|
|
return " \n\
|
|
promise = " + prop + "; \n\
|
|
if (promise instanceof Promise) { \n\
|
|
promise.cancel(); \n\
|
|
} \n\
|
|
";
|
|
}).join("\n");
|
|
var passedArguments = props.join(", ");
|
|
var name = "Holder$" + total;
|
|
|
|
|
|
var code = "return function(tryCatch, errorObj, Promise, async) { \n\
|
|
'use strict'; \n\
|
|
function [TheName](fn) { \n\
|
|
[TheProperties] \n\
|
|
this.fn = fn; \n\
|
|
this.asyncNeeded = true; \n\
|
|
this.now = 0; \n\
|
|
} \n\
|
|
\n\
|
|
[TheName].prototype._callFunction = function(promise) { \n\
|
|
promise._pushContext(); \n\
|
|
var ret = tryCatch(this.fn)([ThePassedArguments]); \n\
|
|
promise._popContext(); \n\
|
|
if (ret === errorObj) { \n\
|
|
promise._rejectCallback(ret.e, false); \n\
|
|
} else { \n\
|
|
promise._resolveCallback(ret); \n\
|
|
} \n\
|
|
}; \n\
|
|
\n\
|
|
[TheName].prototype.checkFulfillment = function(promise) { \n\
|
|
var now = ++this.now; \n\
|
|
if (now === [TheTotal]) { \n\
|
|
if (this.asyncNeeded) { \n\
|
|
async.invoke(this._callFunction, this, promise); \n\
|
|
} else { \n\
|
|
this._callFunction(promise); \n\
|
|
} \n\
|
|
\n\
|
|
} \n\
|
|
}; \n\
|
|
\n\
|
|
[TheName].prototype._resultCancelled = function() { \n\
|
|
[CancellationCode] \n\
|
|
}; \n\
|
|
\n\
|
|
return [TheName]; \n\
|
|
}(tryCatch, errorObj, Promise, async); \n\
|
|
";
|
|
|
|
code = code.replace(/\[TheName\]/g, name)
|
|
.replace(/\[TheTotal\]/g, total)
|
|
.replace(/\[ThePassedArguments\]/g, passedArguments)
|
|
.replace(/\[TheProperties\]/g, assignment)
|
|
.replace(/\[CancellationCode\]/g, cancellationCode);
|
|
|
|
return new Function("tryCatch", "errorObj", "Promise", "async", code)
|
|
(tryCatch, errorObj, Promise, async);
|
|
};
|
|
|
|
var holderClasses = [];
|
|
var thenCallbacks = [];
|
|
var promiseSetters = [];
|
|
|
|
for (var i = 0; i < 8; ++i) {
|
|
holderClasses.push(generateHolderClass(i + 1));
|
|
thenCallbacks.push(thenCallback(i + 1));
|
|
promiseSetters.push(promiseSetter(i + 1));
|
|
}
|
|
|
|
reject = function (reason) {
|
|
this._reject(reason);
|
|
};
|
|
}}
|
|
|
|
Promise.join = function () {
|
|
var last = arguments.length - 1;
|
|
var fn;
|
|
if (last > 0 && typeof arguments[last] === "function") {
|
|
fn = arguments[last];
|
|
if (!true) {
|
|
if (last <= 8 && canEvaluate) {
|
|
var ret = new Promise(INTERNAL);
|
|
ret._captureStackTrace();
|
|
var HolderClass = holderClasses[last - 1];
|
|
var holder = new HolderClass(fn);
|
|
var callbacks = thenCallbacks;
|
|
|
|
for (var i = 0; i < last; ++i) {
|
|
var maybePromise = tryConvertToPromise(arguments[i], ret);
|
|
if (maybePromise instanceof Promise) {
|
|
maybePromise = maybePromise._target();
|
|
var bitField = maybePromise._bitField;
|
|
;
|
|
if (((bitField & 50397184) === 0)) {
|
|
maybePromise._then(callbacks[i], reject,
|
|
undefined, ret, holder);
|
|
promiseSetters[i](maybePromise, holder);
|
|
holder.asyncNeeded = false;
|
|
} else if (((bitField & 33554432) !== 0)) {
|
|
callbacks[i].call(ret,
|
|
maybePromise._value(), holder);
|
|
} else if (((bitField & 16777216) !== 0)) {
|
|
ret._reject(maybePromise._reason());
|
|
} else {
|
|
ret._cancel();
|
|
}
|
|
} else {
|
|
callbacks[i].call(ret, maybePromise, holder);
|
|
}
|
|
}
|
|
|
|
if (!ret._isFateSealed()) {
|
|
if (holder.asyncNeeded) {
|
|
var context = Promise._getContext();
|
|
holder.fn = util.contextBind(context, holder.fn);
|
|
}
|
|
ret._setAsyncGuaranteed();
|
|
ret._setOnCancel(holder);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
var args = [].slice.call(arguments);;
|
|
if (fn) args.pop();
|
|
var ret = new PromiseArray(args).promise();
|
|
return fn !== undefined ? ret.spread(fn) : ret;
|
|
};
|
|
|
|
};
|
|
|
|
},{"./util":21}],13:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports =
|
|
function(Promise, INTERNAL, tryConvertToPromise, apiRejection, debug) {
|
|
var util = _dereq_("./util");
|
|
var tryCatch = util.tryCatch;
|
|
|
|
Promise.method = function (fn) {
|
|
if (typeof fn !== "function") {
|
|
throw new Promise.TypeError("expecting a function but got " + util.classString(fn));
|
|
}
|
|
return function () {
|
|
var ret = new Promise(INTERNAL);
|
|
ret._captureStackTrace();
|
|
ret._pushContext();
|
|
var value = tryCatch(fn).apply(this, arguments);
|
|
var promiseCreated = ret._popContext();
|
|
debug.checkForgottenReturns(
|
|
value, promiseCreated, "Promise.method", ret);
|
|
ret._resolveFromSyncValue(value);
|
|
return ret;
|
|
};
|
|
};
|
|
|
|
Promise.attempt = Promise["try"] = function (fn) {
|
|
if (typeof fn !== "function") {
|
|
return apiRejection("expecting a function but got " + util.classString(fn));
|
|
}
|
|
var ret = new Promise(INTERNAL);
|
|
ret._captureStackTrace();
|
|
ret._pushContext();
|
|
var value;
|
|
if (arguments.length > 1) {
|
|
debug.deprecated("calling Promise.try with more than 1 argument");
|
|
var arg = arguments[1];
|
|
var ctx = arguments[2];
|
|
value = util.isArray(arg) ? tryCatch(fn).apply(ctx, arg)
|
|
: tryCatch(fn).call(ctx, arg);
|
|
} else {
|
|
value = tryCatch(fn)();
|
|
}
|
|
var promiseCreated = ret._popContext();
|
|
debug.checkForgottenReturns(
|
|
value, promiseCreated, "Promise.try", ret);
|
|
ret._resolveFromSyncValue(value);
|
|
return ret;
|
|
};
|
|
|
|
Promise.prototype._resolveFromSyncValue = function (value) {
|
|
if (value === util.errorObj) {
|
|
this._rejectCallback(value.e, false);
|
|
} else {
|
|
this._resolveCallback(value, true);
|
|
}
|
|
};
|
|
};
|
|
|
|
},{"./util":21}],14:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
var util = _dereq_("./util");
|
|
var maybeWrapAsError = util.maybeWrapAsError;
|
|
var errors = _dereq_("./errors");
|
|
var OperationalError = errors.OperationalError;
|
|
var es5 = _dereq_("./es5");
|
|
|
|
function isUntypedError(obj) {
|
|
return obj instanceof Error &&
|
|
es5.getPrototypeOf(obj) === Error.prototype;
|
|
}
|
|
|
|
var rErrorKey = /^(?:name|message|stack|cause)$/;
|
|
function wrapAsOperationalError(obj) {
|
|
var ret;
|
|
if (isUntypedError(obj)) {
|
|
ret = new OperationalError(obj);
|
|
ret.name = obj.name;
|
|
ret.message = obj.message;
|
|
ret.stack = obj.stack;
|
|
var keys = es5.keys(obj);
|
|
for (var i = 0; i < keys.length; ++i) {
|
|
var key = keys[i];
|
|
if (!rErrorKey.test(key)) {
|
|
ret[key] = obj[key];
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
util.markAsOriginatingFromRejection(obj);
|
|
return obj;
|
|
}
|
|
|
|
function nodebackForPromise(promise, multiArgs) {
|
|
return function(err, value) {
|
|
if (promise === null) return;
|
|
if (err) {
|
|
var wrapped = wrapAsOperationalError(maybeWrapAsError(err));
|
|
promise._attachExtraTrace(wrapped);
|
|
promise._reject(wrapped);
|
|
} else if (!multiArgs) {
|
|
promise._fulfill(value);
|
|
} else {
|
|
var args = [].slice.call(arguments, 1);;
|
|
promise._fulfill(args);
|
|
}
|
|
promise = null;
|
|
};
|
|
}
|
|
|
|
module.exports = nodebackForPromise;
|
|
|
|
},{"./errors":9,"./es5":10,"./util":21}],15:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function() {
|
|
var makeSelfResolutionError = function () {
|
|
return new TypeError("circular promise resolution chain\u000a\u000a See http://goo.gl/MqrFmX\u000a");
|
|
};
|
|
var reflectHandler = function() {
|
|
return new Promise.PromiseInspection(this._target());
|
|
};
|
|
var apiRejection = function(msg) {
|
|
return Promise.reject(new TypeError(msg));
|
|
};
|
|
function Proxyable() {}
|
|
var UNDEFINED_BINDING = {};
|
|
var util = _dereq_("./util");
|
|
util.setReflectHandler(reflectHandler);
|
|
|
|
var getDomain = function() {
|
|
var domain = process.domain;
|
|
if (domain === undefined) {
|
|
return null;
|
|
}
|
|
return domain;
|
|
};
|
|
var getContextDefault = function() {
|
|
return null;
|
|
};
|
|
var getContextDomain = function() {
|
|
return {
|
|
domain: getDomain(),
|
|
async: null
|
|
};
|
|
};
|
|
var AsyncResource = util.isNode && util.nodeSupportsAsyncResource ?
|
|
_dereq_("async_hooks").AsyncResource : null;
|
|
var getContextAsyncHooks = function() {
|
|
return {
|
|
domain: getDomain(),
|
|
async: new AsyncResource("Bluebird::Promise")
|
|
};
|
|
};
|
|
var getContext = util.isNode ? getContextDomain : getContextDefault;
|
|
util.notEnumerableProp(Promise, "_getContext", getContext);
|
|
var enableAsyncHooks = function() {
|
|
getContext = getContextAsyncHooks;
|
|
util.notEnumerableProp(Promise, "_getContext", getContextAsyncHooks);
|
|
};
|
|
var disableAsyncHooks = function() {
|
|
getContext = getContextDomain;
|
|
util.notEnumerableProp(Promise, "_getContext", getContextDomain);
|
|
};
|
|
|
|
var es5 = _dereq_("./es5");
|
|
var Async = _dereq_("./async");
|
|
var async = new Async();
|
|
es5.defineProperty(Promise, "_async", {value: async});
|
|
var errors = _dereq_("./errors");
|
|
var TypeError = Promise.TypeError = errors.TypeError;
|
|
Promise.RangeError = errors.RangeError;
|
|
var CancellationError = Promise.CancellationError = errors.CancellationError;
|
|
Promise.TimeoutError = errors.TimeoutError;
|
|
Promise.OperationalError = errors.OperationalError;
|
|
Promise.RejectionError = errors.OperationalError;
|
|
Promise.AggregateError = errors.AggregateError;
|
|
var INTERNAL = function(){};
|
|
var APPLY = {};
|
|
var NEXT_FILTER = {};
|
|
var tryConvertToPromise = _dereq_("./thenables")(Promise, INTERNAL);
|
|
var PromiseArray =
|
|
_dereq_("./promise_array")(Promise, INTERNAL,
|
|
tryConvertToPromise, apiRejection, Proxyable);
|
|
var Context = _dereq_("./context")(Promise);
|
|
/*jshint unused:false*/
|
|
var createContext = Context.create;
|
|
|
|
var debug = _dereq_("./debuggability")(Promise, Context,
|
|
enableAsyncHooks, disableAsyncHooks);
|
|
var CapturedTrace = debug.CapturedTrace;
|
|
var PassThroughHandlerContext =
|
|
_dereq_("./finally")(Promise, tryConvertToPromise, NEXT_FILTER);
|
|
var catchFilter = _dereq_("./catch_filter")(NEXT_FILTER);
|
|
var nodebackForPromise = _dereq_("./nodeback");
|
|
var errorObj = util.errorObj;
|
|
var tryCatch = util.tryCatch;
|
|
function check(self, executor) {
|
|
if (self == null || self.constructor !== Promise) {
|
|
throw new TypeError("the promise constructor cannot be invoked directly\u000a\u000a See http://goo.gl/MqrFmX\u000a");
|
|
}
|
|
if (typeof executor !== "function") {
|
|
throw new TypeError("expecting a function but got " + util.classString(executor));
|
|
}
|
|
|
|
}
|
|
|
|
function Promise(executor) {
|
|
if (executor !== INTERNAL) {
|
|
check(this, executor);
|
|
}
|
|
this._bitField = 0;
|
|
this._fulfillmentHandler0 = undefined;
|
|
this._rejectionHandler0 = undefined;
|
|
this._promise0 = undefined;
|
|
this._receiver0 = undefined;
|
|
this._resolveFromExecutor(executor);
|
|
this._promiseCreated();
|
|
this._fireEvent("promiseCreated", this);
|
|
}
|
|
|
|
Promise.prototype.toString = function () {
|
|
return "[object Promise]";
|
|
};
|
|
|
|
Promise.prototype.caught = Promise.prototype["catch"] = function (fn) {
|
|
var len = arguments.length;
|
|
if (len > 1) {
|
|
var catchInstances = new Array(len - 1),
|
|
j = 0, i;
|
|
for (i = 0; i < len - 1; ++i) {
|
|
var item = arguments[i];
|
|
if (util.isObject(item)) {
|
|
catchInstances[j++] = item;
|
|
} else {
|
|
return apiRejection("Catch statement predicate: " +
|
|
"expecting an object but got " + util.classString(item));
|
|
}
|
|
}
|
|
catchInstances.length = j;
|
|
fn = arguments[i];
|
|
|
|
if (typeof fn !== "function") {
|
|
throw new TypeError("The last argument to .catch() " +
|
|
"must be a function, got " + util.toString(fn));
|
|
}
|
|
return this.then(undefined, catchFilter(catchInstances, fn, this));
|
|
}
|
|
return this.then(undefined, fn);
|
|
};
|
|
|
|
Promise.prototype.reflect = function () {
|
|
return this._then(reflectHandler,
|
|
reflectHandler, undefined, this, undefined);
|
|
};
|
|
|
|
Promise.prototype.then = function (didFulfill, didReject) {
|
|
if (debug.warnings() && arguments.length > 0 &&
|
|
typeof didFulfill !== "function" &&
|
|
typeof didReject !== "function") {
|
|
var msg = ".then() only accepts functions but was passed: " +
|
|
util.classString(didFulfill);
|
|
if (arguments.length > 1) {
|
|
msg += ", " + util.classString(didReject);
|
|
}
|
|
this._warn(msg);
|
|
}
|
|
return this._then(didFulfill, didReject, undefined, undefined, undefined);
|
|
};
|
|
|
|
Promise.prototype.done = function (didFulfill, didReject) {
|
|
var promise =
|
|
this._then(didFulfill, didReject, undefined, undefined, undefined);
|
|
promise._setIsFinal();
|
|
};
|
|
|
|
Promise.prototype.spread = function (fn) {
|
|
if (typeof fn !== "function") {
|
|
return apiRejection("expecting a function but got " + util.classString(fn));
|
|
}
|
|
return this.all()._then(fn, undefined, undefined, APPLY, undefined);
|
|
};
|
|
|
|
Promise.prototype.toJSON = function () {
|
|
var ret = {
|
|
isFulfilled: false,
|
|
isRejected: false,
|
|
fulfillmentValue: undefined,
|
|
rejectionReason: undefined
|
|
};
|
|
if (this.isFulfilled()) {
|
|
ret.fulfillmentValue = this.value();
|
|
ret.isFulfilled = true;
|
|
} else if (this.isRejected()) {
|
|
ret.rejectionReason = this.reason();
|
|
ret.isRejected = true;
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
Promise.prototype.all = function () {
|
|
if (arguments.length > 0) {
|
|
this._warn(".all() was passed arguments but it does not take any");
|
|
}
|
|
return new PromiseArray(this).promise();
|
|
};
|
|
|
|
Promise.prototype.error = function (fn) {
|
|
return this.caught(util.originatesFromRejection, fn);
|
|
};
|
|
|
|
Promise.getNewLibraryCopy = module.exports;
|
|
|
|
Promise.is = function (val) {
|
|
return val instanceof Promise;
|
|
};
|
|
|
|
Promise.fromNode = Promise.fromCallback = function(fn) {
|
|
var ret = new Promise(INTERNAL);
|
|
ret._captureStackTrace();
|
|
var multiArgs = arguments.length > 1 ? !!Object(arguments[1]).multiArgs
|
|
: false;
|
|
var result = tryCatch(fn)(nodebackForPromise(ret, multiArgs));
|
|
if (result === errorObj) {
|
|
ret._rejectCallback(result.e, true);
|
|
}
|
|
if (!ret._isFateSealed()) ret._setAsyncGuaranteed();
|
|
return ret;
|
|
};
|
|
|
|
Promise.all = function (promises) {
|
|
return new PromiseArray(promises).promise();
|
|
};
|
|
|
|
Promise.cast = function (obj) {
|
|
var ret = tryConvertToPromise(obj);
|
|
if (!(ret instanceof Promise)) {
|
|
ret = new Promise(INTERNAL);
|
|
ret._captureStackTrace();
|
|
ret._setFulfilled();
|
|
ret._rejectionHandler0 = obj;
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
Promise.resolve = Promise.fulfilled = Promise.cast;
|
|
|
|
Promise.reject = Promise.rejected = function (reason) {
|
|
var ret = new Promise(INTERNAL);
|
|
ret._captureStackTrace();
|
|
ret._rejectCallback(reason, true);
|
|
return ret;
|
|
};
|
|
|
|
Promise.setScheduler = function(fn) {
|
|
if (typeof fn !== "function") {
|
|
throw new TypeError("expecting a function but got " + util.classString(fn));
|
|
}
|
|
return async.setScheduler(fn);
|
|
};
|
|
|
|
Promise.prototype._then = function (
|
|
didFulfill,
|
|
didReject,
|
|
_, receiver,
|
|
internalData
|
|
) {
|
|
var haveInternalData = internalData !== undefined;
|
|
var promise = haveInternalData ? internalData : new Promise(INTERNAL);
|
|
var target = this._target();
|
|
var bitField = target._bitField;
|
|
|
|
if (!haveInternalData) {
|
|
promise._propagateFrom(this, 3);
|
|
promise._captureStackTrace();
|
|
if (receiver === undefined &&
|
|
((this._bitField & 2097152) !== 0)) {
|
|
if (!((bitField & 50397184) === 0)) {
|
|
receiver = this._boundValue();
|
|
} else {
|
|
receiver = target === this ? undefined : this._boundTo;
|
|
}
|
|
}
|
|
this._fireEvent("promiseChained", this, promise);
|
|
}
|
|
|
|
var context = getContext();
|
|
if (!((bitField & 50397184) === 0)) {
|
|
var handler, value, settler = target._settlePromiseCtx;
|
|
if (((bitField & 33554432) !== 0)) {
|
|
value = target._rejectionHandler0;
|
|
handler = didFulfill;
|
|
} else if (((bitField & 16777216) !== 0)) {
|
|
value = target._fulfillmentHandler0;
|
|
handler = didReject;
|
|
target._unsetRejectionIsUnhandled();
|
|
} else {
|
|
settler = target._settlePromiseLateCancellationObserver;
|
|
value = new CancellationError("late cancellation observer");
|
|
target._attachExtraTrace(value);
|
|
handler = didReject;
|
|
}
|
|
|
|
async.invoke(settler, target, {
|
|
handler: util.contextBind(context, handler),
|
|
promise: promise,
|
|
receiver: receiver,
|
|
value: value
|
|
});
|
|
} else {
|
|
target._addCallbacks(didFulfill, didReject, promise,
|
|
receiver, context);
|
|
}
|
|
|
|
return promise;
|
|
};
|
|
|
|
Promise.prototype._length = function () {
|
|
return this._bitField & 65535;
|
|
};
|
|
|
|
Promise.prototype._isFateSealed = function () {
|
|
return (this._bitField & 117506048) !== 0;
|
|
};
|
|
|
|
Promise.prototype._isFollowing = function () {
|
|
return (this._bitField & 67108864) === 67108864;
|
|
};
|
|
|
|
Promise.prototype._setLength = function (len) {
|
|
this._bitField = (this._bitField & -65536) |
|
|
(len & 65535);
|
|
};
|
|
|
|
Promise.prototype._setFulfilled = function () {
|
|
this._bitField = this._bitField | 33554432;
|
|
this._fireEvent("promiseFulfilled", this);
|
|
};
|
|
|
|
Promise.prototype._setRejected = function () {
|
|
this._bitField = this._bitField | 16777216;
|
|
this._fireEvent("promiseRejected", this);
|
|
};
|
|
|
|
Promise.prototype._setFollowing = function () {
|
|
this._bitField = this._bitField | 67108864;
|
|
this._fireEvent("promiseResolved", this);
|
|
};
|
|
|
|
Promise.prototype._setIsFinal = function () {
|
|
this._bitField = this._bitField | 4194304;
|
|
};
|
|
|
|
Promise.prototype._isFinal = function () {
|
|
return (this._bitField & 4194304) > 0;
|
|
};
|
|
|
|
Promise.prototype._unsetCancelled = function() {
|
|
this._bitField = this._bitField & (~65536);
|
|
};
|
|
|
|
Promise.prototype._setCancelled = function() {
|
|
this._bitField = this._bitField | 65536;
|
|
this._fireEvent("promiseCancelled", this);
|
|
};
|
|
|
|
Promise.prototype._setWillBeCancelled = function() {
|
|
this._bitField = this._bitField | 8388608;
|
|
};
|
|
|
|
Promise.prototype._setAsyncGuaranteed = function() {
|
|
if (async.hasCustomScheduler()) return;
|
|
var bitField = this._bitField;
|
|
this._bitField = bitField |
|
|
(((bitField & 536870912) >> 2) ^
|
|
134217728);
|
|
};
|
|
|
|
Promise.prototype._setNoAsyncGuarantee = function() {
|
|
this._bitField = (this._bitField | 536870912) &
|
|
(~134217728);
|
|
};
|
|
|
|
Promise.prototype._receiverAt = function (index) {
|
|
var ret = index === 0 ? this._receiver0 : this[
|
|
index * 4 - 4 + 3];
|
|
if (ret === UNDEFINED_BINDING) {
|
|
return undefined;
|
|
} else if (ret === undefined && this._isBound()) {
|
|
return this._boundValue();
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
Promise.prototype._promiseAt = function (index) {
|
|
return this[
|
|
index * 4 - 4 + 2];
|
|
};
|
|
|
|
Promise.prototype._fulfillmentHandlerAt = function (index) {
|
|
return this[
|
|
index * 4 - 4 + 0];
|
|
};
|
|
|
|
Promise.prototype._rejectionHandlerAt = function (index) {
|
|
return this[
|
|
index * 4 - 4 + 1];
|
|
};
|
|
|
|
Promise.prototype._boundValue = function() {};
|
|
|
|
Promise.prototype._migrateCallback0 = function (follower) {
|
|
var bitField = follower._bitField;
|
|
var fulfill = follower._fulfillmentHandler0;
|
|
var reject = follower._rejectionHandler0;
|
|
var promise = follower._promise0;
|
|
var receiver = follower._receiverAt(0);
|
|
if (receiver === undefined) receiver = UNDEFINED_BINDING;
|
|
this._addCallbacks(fulfill, reject, promise, receiver, null);
|
|
};
|
|
|
|
Promise.prototype._migrateCallbackAt = function (follower, index) {
|
|
var fulfill = follower._fulfillmentHandlerAt(index);
|
|
var reject = follower._rejectionHandlerAt(index);
|
|
var promise = follower._promiseAt(index);
|
|
var receiver = follower._receiverAt(index);
|
|
if (receiver === undefined) receiver = UNDEFINED_BINDING;
|
|
this._addCallbacks(fulfill, reject, promise, receiver, null);
|
|
};
|
|
|
|
Promise.prototype._addCallbacks = function (
|
|
fulfill,
|
|
reject,
|
|
promise,
|
|
receiver,
|
|
context
|
|
) {
|
|
var index = this._length();
|
|
|
|
if (index >= 65535 - 4) {
|
|
index = 0;
|
|
this._setLength(0);
|
|
}
|
|
|
|
if (index === 0) {
|
|
this._promise0 = promise;
|
|
this._receiver0 = receiver;
|
|
if (typeof fulfill === "function") {
|
|
this._fulfillmentHandler0 = util.contextBind(context, fulfill);
|
|
}
|
|
if (typeof reject === "function") {
|
|
this._rejectionHandler0 = util.contextBind(context, reject);
|
|
}
|
|
} else {
|
|
var base = index * 4 - 4;
|
|
this[base + 2] = promise;
|
|
this[base + 3] = receiver;
|
|
if (typeof fulfill === "function") {
|
|
this[base + 0] =
|
|
util.contextBind(context, fulfill);
|
|
}
|
|
if (typeof reject === "function") {
|
|
this[base + 1] =
|
|
util.contextBind(context, reject);
|
|
}
|
|
}
|
|
this._setLength(index + 1);
|
|
return index;
|
|
};
|
|
|
|
Promise.prototype._proxy = function (proxyable, arg) {
|
|
this._addCallbacks(undefined, undefined, arg, proxyable, null);
|
|
};
|
|
|
|
Promise.prototype._resolveCallback = function(value, shouldBind) {
|
|
if (((this._bitField & 117506048) !== 0)) return;
|
|
if (value === this)
|
|
return this._rejectCallback(makeSelfResolutionError(), false);
|
|
var maybePromise = tryConvertToPromise(value, this);
|
|
if (!(maybePromise instanceof Promise)) return this._fulfill(value);
|
|
|
|
if (shouldBind) this._propagateFrom(maybePromise, 2);
|
|
|
|
|
|
var promise = maybePromise._target();
|
|
|
|
if (promise === this) {
|
|
this._reject(makeSelfResolutionError());
|
|
return;
|
|
}
|
|
|
|
var bitField = promise._bitField;
|
|
if (((bitField & 50397184) === 0)) {
|
|
var len = this._length();
|
|
if (len > 0) promise._migrateCallback0(this);
|
|
for (var i = 1; i < len; ++i) {
|
|
promise._migrateCallbackAt(this, i);
|
|
}
|
|
this._setFollowing();
|
|
this._setLength(0);
|
|
this._setFollowee(maybePromise);
|
|
} else if (((bitField & 33554432) !== 0)) {
|
|
this._fulfill(promise._value());
|
|
} else if (((bitField & 16777216) !== 0)) {
|
|
this._reject(promise._reason());
|
|
} else {
|
|
var reason = new CancellationError("late cancellation observer");
|
|
promise._attachExtraTrace(reason);
|
|
this._reject(reason);
|
|
}
|
|
};
|
|
|
|
Promise.prototype._rejectCallback =
|
|
function(reason, synchronous, ignoreNonErrorWarnings) {
|
|
var trace = util.ensureErrorObject(reason);
|
|
var hasStack = trace === reason;
|
|
if (!hasStack && !ignoreNonErrorWarnings && debug.warnings()) {
|
|
var message = "a promise was rejected with a non-error: " +
|
|
util.classString(reason);
|
|
this._warn(message, true);
|
|
}
|
|
this._attachExtraTrace(trace, synchronous ? hasStack : false);
|
|
this._reject(reason);
|
|
};
|
|
|
|
Promise.prototype._resolveFromExecutor = function (executor) {
|
|
if (executor === INTERNAL) return;
|
|
var promise = this;
|
|
this._captureStackTrace();
|
|
this._pushContext();
|
|
var synchronous = true;
|
|
var r = this._execute(executor, function(value) {
|
|
promise._resolveCallback(value);
|
|
}, function (reason) {
|
|
promise._rejectCallback(reason, synchronous);
|
|
});
|
|
synchronous = false;
|
|
this._popContext();
|
|
|
|
if (r !== undefined) {
|
|
promise._rejectCallback(r, true);
|
|
}
|
|
};
|
|
|
|
Promise.prototype._settlePromiseFromHandler = function (
|
|
handler, receiver, value, promise
|
|
) {
|
|
var bitField = promise._bitField;
|
|
if (((bitField & 65536) !== 0)) return;
|
|
promise._pushContext();
|
|
var x;
|
|
if (receiver === APPLY) {
|
|
if (!value || typeof value.length !== "number") {
|
|
x = errorObj;
|
|
x.e = new TypeError("cannot .spread() a non-array: " +
|
|
util.classString(value));
|
|
} else {
|
|
x = tryCatch(handler).apply(this._boundValue(), value);
|
|
}
|
|
} else {
|
|
x = tryCatch(handler).call(receiver, value);
|
|
}
|
|
var promiseCreated = promise._popContext();
|
|
bitField = promise._bitField;
|
|
if (((bitField & 65536) !== 0)) return;
|
|
|
|
if (x === NEXT_FILTER) {
|
|
promise._reject(value);
|
|
} else if (x === errorObj) {
|
|
promise._rejectCallback(x.e, false);
|
|
} else {
|
|
debug.checkForgottenReturns(x, promiseCreated, "", promise, this);
|
|
promise._resolveCallback(x);
|
|
}
|
|
};
|
|
|
|
Promise.prototype._target = function() {
|
|
var ret = this;
|
|
while (ret._isFollowing()) ret = ret._followee();
|
|
return ret;
|
|
};
|
|
|
|
Promise.prototype._followee = function() {
|
|
return this._rejectionHandler0;
|
|
};
|
|
|
|
Promise.prototype._setFollowee = function(promise) {
|
|
this._rejectionHandler0 = promise;
|
|
};
|
|
|
|
Promise.prototype._settlePromise = function(promise, handler, receiver, value) {
|
|
var isPromise = promise instanceof Promise;
|
|
var bitField = this._bitField;
|
|
var asyncGuaranteed = ((bitField & 134217728) !== 0);
|
|
if (((bitField & 65536) !== 0)) {
|
|
if (isPromise) promise._invokeInternalOnCancel();
|
|
|
|
if (receiver instanceof PassThroughHandlerContext &&
|
|
receiver.isFinallyHandler()) {
|
|
receiver.cancelPromise = promise;
|
|
if (tryCatch(handler).call(receiver, value) === errorObj) {
|
|
promise._reject(errorObj.e);
|
|
}
|
|
} else if (handler === reflectHandler) {
|
|
promise._fulfill(reflectHandler.call(receiver));
|
|
} else if (receiver instanceof Proxyable) {
|
|
receiver._promiseCancelled(promise);
|
|
} else if (isPromise || promise instanceof PromiseArray) {
|
|
promise._cancel();
|
|
} else {
|
|
receiver.cancel();
|
|
}
|
|
} else if (typeof handler === "function") {
|
|
if (!isPromise) {
|
|
handler.call(receiver, value, promise);
|
|
} else {
|
|
if (asyncGuaranteed) promise._setAsyncGuaranteed();
|
|
this._settlePromiseFromHandler(handler, receiver, value, promise);
|
|
}
|
|
} else if (receiver instanceof Proxyable) {
|
|
if (!receiver._isResolved()) {
|
|
if (((bitField & 33554432) !== 0)) {
|
|
receiver._promiseFulfilled(value, promise);
|
|
} else {
|
|
receiver._promiseRejected(value, promise);
|
|
}
|
|
}
|
|
} else if (isPromise) {
|
|
if (asyncGuaranteed) promise._setAsyncGuaranteed();
|
|
if (((bitField & 33554432) !== 0)) {
|
|
promise._fulfill(value);
|
|
} else {
|
|
promise._reject(value);
|
|
}
|
|
}
|
|
};
|
|
|
|
Promise.prototype._settlePromiseLateCancellationObserver = function(ctx) {
|
|
var handler = ctx.handler;
|
|
var promise = ctx.promise;
|
|
var receiver = ctx.receiver;
|
|
var value = ctx.value;
|
|
if (typeof handler === "function") {
|
|
if (!(promise instanceof Promise)) {
|
|
handler.call(receiver, value, promise);
|
|
} else {
|
|
this._settlePromiseFromHandler(handler, receiver, value, promise);
|
|
}
|
|
} else if (promise instanceof Promise) {
|
|
promise._reject(value);
|
|
}
|
|
};
|
|
|
|
Promise.prototype._settlePromiseCtx = function(ctx) {
|
|
this._settlePromise(ctx.promise, ctx.handler, ctx.receiver, ctx.value);
|
|
};
|
|
|
|
Promise.prototype._settlePromise0 = function(handler, value, bitField) {
|
|
var promise = this._promise0;
|
|
var receiver = this._receiverAt(0);
|
|
this._promise0 = undefined;
|
|
this._receiver0 = undefined;
|
|
this._settlePromise(promise, handler, receiver, value);
|
|
};
|
|
|
|
Promise.prototype._clearCallbackDataAtIndex = function(index) {
|
|
var base = index * 4 - 4;
|
|
this[base + 2] =
|
|
this[base + 3] =
|
|
this[base + 0] =
|
|
this[base + 1] = undefined;
|
|
};
|
|
|
|
Promise.prototype._fulfill = function (value) {
|
|
var bitField = this._bitField;
|
|
if (((bitField & 117506048) >>> 16)) return;
|
|
if (value === this) {
|
|
var err = makeSelfResolutionError();
|
|
this._attachExtraTrace(err);
|
|
return this._reject(err);
|
|
}
|
|
this._setFulfilled();
|
|
this._rejectionHandler0 = value;
|
|
|
|
if ((bitField & 65535) > 0) {
|
|
if (((bitField & 134217728) !== 0)) {
|
|
this._settlePromises();
|
|
} else {
|
|
async.settlePromises(this);
|
|
}
|
|
this._dereferenceTrace();
|
|
}
|
|
};
|
|
|
|
Promise.prototype._reject = function (reason) {
|
|
var bitField = this._bitField;
|
|
if (((bitField & 117506048) >>> 16)) return;
|
|
this._setRejected();
|
|
this._fulfillmentHandler0 = reason;
|
|
|
|
if (this._isFinal()) {
|
|
return async.fatalError(reason, util.isNode);
|
|
}
|
|
|
|
if ((bitField & 65535) > 0) {
|
|
async.settlePromises(this);
|
|
} else {
|
|
this._ensurePossibleRejectionHandled();
|
|
}
|
|
};
|
|
|
|
Promise.prototype._fulfillPromises = function (len, value) {
|
|
for (var i = 1; i < len; i++) {
|
|
var handler = this._fulfillmentHandlerAt(i);
|
|
var promise = this._promiseAt(i);
|
|
var receiver = this._receiverAt(i);
|
|
this._clearCallbackDataAtIndex(i);
|
|
this._settlePromise(promise, handler, receiver, value);
|
|
}
|
|
};
|
|
|
|
Promise.prototype._rejectPromises = function (len, reason) {
|
|
for (var i = 1; i < len; i++) {
|
|
var handler = this._rejectionHandlerAt(i);
|
|
var promise = this._promiseAt(i);
|
|
var receiver = this._receiverAt(i);
|
|
this._clearCallbackDataAtIndex(i);
|
|
this._settlePromise(promise, handler, receiver, reason);
|
|
}
|
|
};
|
|
|
|
Promise.prototype._settlePromises = function () {
|
|
var bitField = this._bitField;
|
|
var len = (bitField & 65535);
|
|
|
|
if (len > 0) {
|
|
if (((bitField & 16842752) !== 0)) {
|
|
var reason = this._fulfillmentHandler0;
|
|
this._settlePromise0(this._rejectionHandler0, reason, bitField);
|
|
this._rejectPromises(len, reason);
|
|
} else {
|
|
var value = this._rejectionHandler0;
|
|
this._settlePromise0(this._fulfillmentHandler0, value, bitField);
|
|
this._fulfillPromises(len, value);
|
|
}
|
|
this._setLength(0);
|
|
}
|
|
this._clearCancellationData();
|
|
};
|
|
|
|
Promise.prototype._settledValue = function() {
|
|
var bitField = this._bitField;
|
|
if (((bitField & 33554432) !== 0)) {
|
|
return this._rejectionHandler0;
|
|
} else if (((bitField & 16777216) !== 0)) {
|
|
return this._fulfillmentHandler0;
|
|
}
|
|
};
|
|
|
|
if (typeof Symbol !== "undefined" && Symbol.toStringTag) {
|
|
es5.defineProperty(Promise.prototype, Symbol.toStringTag, {
|
|
get: function () {
|
|
return "Object";
|
|
}
|
|
});
|
|
}
|
|
|
|
function deferResolve(v) {this.promise._resolveCallback(v);}
|
|
function deferReject(v) {this.promise._rejectCallback(v, false);}
|
|
|
|
Promise.defer = Promise.pending = function() {
|
|
debug.deprecated("Promise.defer", "new Promise");
|
|
var promise = new Promise(INTERNAL);
|
|
return {
|
|
promise: promise,
|
|
resolve: deferResolve,
|
|
reject: deferReject
|
|
};
|
|
};
|
|
|
|
util.notEnumerableProp(Promise,
|
|
"_makeSelfResolutionError",
|
|
makeSelfResolutionError);
|
|
|
|
_dereq_("./method")(Promise, INTERNAL, tryConvertToPromise, apiRejection,
|
|
debug);
|
|
_dereq_("./bind")(Promise, INTERNAL, tryConvertToPromise, debug);
|
|
_dereq_("./cancel")(Promise, PromiseArray, apiRejection, debug);
|
|
_dereq_("./direct_resolve")(Promise);
|
|
_dereq_("./synchronous_inspection")(Promise);
|
|
_dereq_("./join")(
|
|
Promise, PromiseArray, tryConvertToPromise, INTERNAL, async);
|
|
Promise.Promise = Promise;
|
|
Promise.version = "3.7.2";
|
|
|
|
util.toFastProperties(Promise);
|
|
util.toFastProperties(Promise.prototype);
|
|
function fillTypes(value) {
|
|
var p = new Promise(INTERNAL);
|
|
p._fulfillmentHandler0 = value;
|
|
p._rejectionHandler0 = value;
|
|
p._promise0 = value;
|
|
p._receiver0 = value;
|
|
}
|
|
// Complete slack tracking, opt out of field-type tracking and
|
|
// stabilize map
|
|
fillTypes({a: 1});
|
|
fillTypes({b: 2});
|
|
fillTypes({c: 3});
|
|
fillTypes(1);
|
|
fillTypes(function(){});
|
|
fillTypes(undefined);
|
|
fillTypes(false);
|
|
fillTypes(new Promise(INTERNAL));
|
|
debug.setBounds(Async.firstLineError, util.lastLineError);
|
|
return Promise;
|
|
|
|
};
|
|
|
|
},{"./async":1,"./bind":2,"./cancel":4,"./catch_filter":5,"./context":6,"./debuggability":7,"./direct_resolve":8,"./errors":9,"./es5":10,"./finally":11,"./join":12,"./method":13,"./nodeback":14,"./promise_array":16,"./synchronous_inspection":19,"./thenables":20,"./util":21,"async_hooks":undefined}],16:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(Promise, INTERNAL, tryConvertToPromise,
|
|
apiRejection, Proxyable) {
|
|
var util = _dereq_("./util");
|
|
var isArray = util.isArray;
|
|
|
|
function toResolutionValue(val) {
|
|
switch(val) {
|
|
case -2: return [];
|
|
case -3: return {};
|
|
case -6: return new Map();
|
|
}
|
|
}
|
|
|
|
function PromiseArray(values) {
|
|
var promise = this._promise = new Promise(INTERNAL);
|
|
if (values instanceof Promise) {
|
|
promise._propagateFrom(values, 3);
|
|
values.suppressUnhandledRejections();
|
|
}
|
|
promise._setOnCancel(this);
|
|
this._values = values;
|
|
this._length = 0;
|
|
this._totalResolved = 0;
|
|
this._init(undefined, -2);
|
|
}
|
|
util.inherits(PromiseArray, Proxyable);
|
|
|
|
PromiseArray.prototype.length = function () {
|
|
return this._length;
|
|
};
|
|
|
|
PromiseArray.prototype.promise = function () {
|
|
return this._promise;
|
|
};
|
|
|
|
PromiseArray.prototype._init = function init(_, resolveValueIfEmpty) {
|
|
var values = tryConvertToPromise(this._values, this._promise);
|
|
if (values instanceof Promise) {
|
|
values = values._target();
|
|
var bitField = values._bitField;
|
|
;
|
|
this._values = values;
|
|
|
|
if (((bitField & 50397184) === 0)) {
|
|
this._promise._setAsyncGuaranteed();
|
|
return values._then(
|
|
init,
|
|
this._reject,
|
|
undefined,
|
|
this,
|
|
resolveValueIfEmpty
|
|
);
|
|
} else if (((bitField & 33554432) !== 0)) {
|
|
values = values._value();
|
|
} else if (((bitField & 16777216) !== 0)) {
|
|
return this._reject(values._reason());
|
|
} else {
|
|
return this._cancel();
|
|
}
|
|
}
|
|
values = util.asArray(values);
|
|
if (values === null) {
|
|
var err = apiRejection(
|
|
"expecting an array or an iterable object but got " + util.classString(values)).reason();
|
|
this._promise._rejectCallback(err, false);
|
|
return;
|
|
}
|
|
|
|
if (values.length === 0) {
|
|
if (resolveValueIfEmpty === -5) {
|
|
this._resolveEmptyArray();
|
|
}
|
|
else {
|
|
this._resolve(toResolutionValue(resolveValueIfEmpty));
|
|
}
|
|
return;
|
|
}
|
|
this._iterate(values);
|
|
};
|
|
|
|
PromiseArray.prototype._iterate = function(values) {
|
|
var len = this.getActualLength(values.length);
|
|
this._length = len;
|
|
this._values = this.shouldCopyValues() ? new Array(len) : this._values;
|
|
var result = this._promise;
|
|
var isResolved = false;
|
|
var bitField = null;
|
|
for (var i = 0; i < len; ++i) {
|
|
var maybePromise = tryConvertToPromise(values[i], result);
|
|
|
|
if (maybePromise instanceof Promise) {
|
|
maybePromise = maybePromise._target();
|
|
bitField = maybePromise._bitField;
|
|
} else {
|
|
bitField = null;
|
|
}
|
|
|
|
if (isResolved) {
|
|
if (bitField !== null) {
|
|
maybePromise.suppressUnhandledRejections();
|
|
}
|
|
} else if (bitField !== null) {
|
|
if (((bitField & 50397184) === 0)) {
|
|
maybePromise._proxy(this, i);
|
|
this._values[i] = maybePromise;
|
|
} else if (((bitField & 33554432) !== 0)) {
|
|
isResolved = this._promiseFulfilled(maybePromise._value(), i);
|
|
} else if (((bitField & 16777216) !== 0)) {
|
|
isResolved = this._promiseRejected(maybePromise._reason(), i);
|
|
} else {
|
|
isResolved = this._promiseCancelled(i);
|
|
}
|
|
} else {
|
|
isResolved = this._promiseFulfilled(maybePromise, i);
|
|
}
|
|
}
|
|
if (!isResolved) result._setAsyncGuaranteed();
|
|
};
|
|
|
|
PromiseArray.prototype._isResolved = function () {
|
|
return this._values === null;
|
|
};
|
|
|
|
PromiseArray.prototype._resolve = function (value) {
|
|
this._values = null;
|
|
this._promise._fulfill(value);
|
|
};
|
|
|
|
PromiseArray.prototype._cancel = function() {
|
|
if (this._isResolved() || !this._promise._isCancellable()) return;
|
|
this._values = null;
|
|
this._promise._cancel();
|
|
};
|
|
|
|
PromiseArray.prototype._reject = function (reason) {
|
|
this._values = null;
|
|
this._promise._rejectCallback(reason, false);
|
|
};
|
|
|
|
PromiseArray.prototype._promiseFulfilled = function (value, index) {
|
|
this._values[index] = value;
|
|
var totalResolved = ++this._totalResolved;
|
|
if (totalResolved >= this._length) {
|
|
this._resolve(this._values);
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
|
|
PromiseArray.prototype._promiseCancelled = function() {
|
|
this._cancel();
|
|
return true;
|
|
};
|
|
|
|
PromiseArray.prototype._promiseRejected = function (reason) {
|
|
this._totalResolved++;
|
|
this._reject(reason);
|
|
return true;
|
|
};
|
|
|
|
PromiseArray.prototype._resultCancelled = function() {
|
|
if (this._isResolved()) return;
|
|
var values = this._values;
|
|
this._cancel();
|
|
if (values instanceof Promise) {
|
|
values.cancel();
|
|
} else {
|
|
for (var i = 0; i < values.length; ++i) {
|
|
if (values[i] instanceof Promise) {
|
|
values[i].cancel();
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
PromiseArray.prototype.shouldCopyValues = function () {
|
|
return true;
|
|
};
|
|
|
|
PromiseArray.prototype.getActualLength = function (len) {
|
|
return len;
|
|
};
|
|
|
|
return PromiseArray;
|
|
};
|
|
|
|
},{"./util":21}],17:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
function arrayMove(src, srcIndex, dst, dstIndex, len) {
|
|
for (var j = 0; j < len; ++j) {
|
|
dst[j + dstIndex] = src[j + srcIndex];
|
|
src[j + srcIndex] = void 0;
|
|
}
|
|
}
|
|
|
|
function Queue(capacity) {
|
|
this._capacity = capacity;
|
|
this._length = 0;
|
|
this._front = 0;
|
|
}
|
|
|
|
Queue.prototype._willBeOverCapacity = function (size) {
|
|
return this._capacity < size;
|
|
};
|
|
|
|
Queue.prototype._pushOne = function (arg) {
|
|
var length = this.length();
|
|
this._checkCapacity(length + 1);
|
|
var i = (this._front + length) & (this._capacity - 1);
|
|
this[i] = arg;
|
|
this._length = length + 1;
|
|
};
|
|
|
|
Queue.prototype.push = function (fn, receiver, arg) {
|
|
var length = this.length() + 3;
|
|
if (this._willBeOverCapacity(length)) {
|
|
this._pushOne(fn);
|
|
this._pushOne(receiver);
|
|
this._pushOne(arg);
|
|
return;
|
|
}
|
|
var j = this._front + length - 3;
|
|
this._checkCapacity(length);
|
|
var wrapMask = this._capacity - 1;
|
|
this[(j + 0) & wrapMask] = fn;
|
|
this[(j + 1) & wrapMask] = receiver;
|
|
this[(j + 2) & wrapMask] = arg;
|
|
this._length = length;
|
|
};
|
|
|
|
Queue.prototype.shift = function () {
|
|
var front = this._front,
|
|
ret = this[front];
|
|
|
|
this[front] = undefined;
|
|
this._front = (front + 1) & (this._capacity - 1);
|
|
this._length--;
|
|
return ret;
|
|
};
|
|
|
|
Queue.prototype.length = function () {
|
|
return this._length;
|
|
};
|
|
|
|
Queue.prototype._checkCapacity = function (size) {
|
|
if (this._capacity < size) {
|
|
this._resizeTo(this._capacity << 1);
|
|
}
|
|
};
|
|
|
|
Queue.prototype._resizeTo = function (capacity) {
|
|
var oldCapacity = this._capacity;
|
|
this._capacity = capacity;
|
|
var front = this._front;
|
|
var length = this._length;
|
|
var moveItemsCount = (front + length) & (oldCapacity - 1);
|
|
arrayMove(this, 0, this, oldCapacity, moveItemsCount);
|
|
};
|
|
|
|
module.exports = Queue;
|
|
|
|
},{}],18:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
var util = _dereq_("./util");
|
|
var schedule;
|
|
var noAsyncScheduler = function() {
|
|
throw new Error("No async scheduler available\u000a\u000a See http://goo.gl/MqrFmX\u000a");
|
|
};
|
|
var NativePromise = util.getNativePromise();
|
|
if (util.isNode && typeof MutationObserver === "undefined") {
|
|
var GlobalSetImmediate = global.setImmediate;
|
|
var ProcessNextTick = process.nextTick;
|
|
schedule = util.isRecentNode
|
|
? function(fn) { GlobalSetImmediate.call(global, fn); }
|
|
: function(fn) { ProcessNextTick.call(process, fn); };
|
|
} else if (typeof NativePromise === "function" &&
|
|
typeof NativePromise.resolve === "function") {
|
|
var nativePromise = NativePromise.resolve();
|
|
schedule = function(fn) {
|
|
nativePromise.then(fn);
|
|
};
|
|
} else if ((typeof MutationObserver !== "undefined") &&
|
|
!(typeof window !== "undefined" &&
|
|
window.navigator &&
|
|
(window.navigator.standalone || window.cordova)) &&
|
|
("classList" in document.documentElement)) {
|
|
schedule = (function() {
|
|
var div = document.createElement("div");
|
|
var opts = {attributes: true};
|
|
var toggleScheduled = false;
|
|
var div2 = document.createElement("div");
|
|
var o2 = new MutationObserver(function() {
|
|
div.classList.toggle("foo");
|
|
toggleScheduled = false;
|
|
});
|
|
o2.observe(div2, opts);
|
|
|
|
var scheduleToggle = function() {
|
|
if (toggleScheduled) return;
|
|
toggleScheduled = true;
|
|
div2.classList.toggle("foo");
|
|
};
|
|
|
|
return function schedule(fn) {
|
|
var o = new MutationObserver(function() {
|
|
o.disconnect();
|
|
fn();
|
|
});
|
|
o.observe(div, opts);
|
|
scheduleToggle();
|
|
};
|
|
})();
|
|
} else if (typeof setImmediate !== "undefined") {
|
|
schedule = function (fn) {
|
|
setImmediate(fn);
|
|
};
|
|
} else if (typeof setTimeout !== "undefined") {
|
|
schedule = function (fn) {
|
|
setTimeout(fn, 0);
|
|
};
|
|
} else {
|
|
schedule = noAsyncScheduler;
|
|
}
|
|
module.exports = schedule;
|
|
|
|
},{"./util":21}],19:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(Promise) {
|
|
function PromiseInspection(promise) {
|
|
if (promise !== undefined) {
|
|
promise = promise._target();
|
|
this._bitField = promise._bitField;
|
|
this._settledValueField = promise._isFateSealed()
|
|
? promise._settledValue() : undefined;
|
|
}
|
|
else {
|
|
this._bitField = 0;
|
|
this._settledValueField = undefined;
|
|
}
|
|
}
|
|
|
|
PromiseInspection.prototype._settledValue = function() {
|
|
return this._settledValueField;
|
|
};
|
|
|
|
var value = PromiseInspection.prototype.value = function () {
|
|
if (!this.isFulfilled()) {
|
|
throw new TypeError("cannot get fulfillment value of a non-fulfilled promise\u000a\u000a See http://goo.gl/MqrFmX\u000a");
|
|
}
|
|
return this._settledValue();
|
|
};
|
|
|
|
var reason = PromiseInspection.prototype.error =
|
|
PromiseInspection.prototype.reason = function () {
|
|
if (!this.isRejected()) {
|
|
throw new TypeError("cannot get rejection reason of a non-rejected promise\u000a\u000a See http://goo.gl/MqrFmX\u000a");
|
|
}
|
|
return this._settledValue();
|
|
};
|
|
|
|
var isFulfilled = PromiseInspection.prototype.isFulfilled = function() {
|
|
return (this._bitField & 33554432) !== 0;
|
|
};
|
|
|
|
var isRejected = PromiseInspection.prototype.isRejected = function () {
|
|
return (this._bitField & 16777216) !== 0;
|
|
};
|
|
|
|
var isPending = PromiseInspection.prototype.isPending = function () {
|
|
return (this._bitField & 50397184) === 0;
|
|
};
|
|
|
|
var isResolved = PromiseInspection.prototype.isResolved = function () {
|
|
return (this._bitField & 50331648) !== 0;
|
|
};
|
|
|
|
PromiseInspection.prototype.isCancelled = function() {
|
|
return (this._bitField & 8454144) !== 0;
|
|
};
|
|
|
|
Promise.prototype.__isCancelled = function() {
|
|
return (this._bitField & 65536) === 65536;
|
|
};
|
|
|
|
Promise.prototype._isCancelled = function() {
|
|
return this._target().__isCancelled();
|
|
};
|
|
|
|
Promise.prototype.isCancelled = function() {
|
|
return (this._target()._bitField & 8454144) !== 0;
|
|
};
|
|
|
|
Promise.prototype.isPending = function() {
|
|
return isPending.call(this._target());
|
|
};
|
|
|
|
Promise.prototype.isRejected = function() {
|
|
return isRejected.call(this._target());
|
|
};
|
|
|
|
Promise.prototype.isFulfilled = function() {
|
|
return isFulfilled.call(this._target());
|
|
};
|
|
|
|
Promise.prototype.isResolved = function() {
|
|
return isResolved.call(this._target());
|
|
};
|
|
|
|
Promise.prototype.value = function() {
|
|
return value.call(this._target());
|
|
};
|
|
|
|
Promise.prototype.reason = function() {
|
|
var target = this._target();
|
|
target._unsetRejectionIsUnhandled();
|
|
return reason.call(target);
|
|
};
|
|
|
|
Promise.prototype._value = function() {
|
|
return this._settledValue();
|
|
};
|
|
|
|
Promise.prototype._reason = function() {
|
|
this._unsetRejectionIsUnhandled();
|
|
return this._settledValue();
|
|
};
|
|
|
|
Promise.PromiseInspection = PromiseInspection;
|
|
};
|
|
|
|
},{}],20:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(Promise, INTERNAL) {
|
|
var util = _dereq_("./util");
|
|
var errorObj = util.errorObj;
|
|
var isObject = util.isObject;
|
|
|
|
function tryConvertToPromise(obj, context) {
|
|
if (isObject(obj)) {
|
|
if (obj instanceof Promise) return obj;
|
|
var then = getThen(obj);
|
|
if (then === errorObj) {
|
|
if (context) context._pushContext();
|
|
var ret = Promise.reject(then.e);
|
|
if (context) context._popContext();
|
|
return ret;
|
|
} else if (typeof then === "function") {
|
|
if (isAnyBluebirdPromise(obj)) {
|
|
var ret = new Promise(INTERNAL);
|
|
obj._then(
|
|
ret._fulfill,
|
|
ret._reject,
|
|
undefined,
|
|
ret,
|
|
null
|
|
);
|
|
return ret;
|
|
}
|
|
return doThenable(obj, then, context);
|
|
}
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
function doGetThen(obj) {
|
|
return obj.then;
|
|
}
|
|
|
|
function getThen(obj) {
|
|
try {
|
|
return doGetThen(obj);
|
|
} catch (e) {
|
|
errorObj.e = e;
|
|
return errorObj;
|
|
}
|
|
}
|
|
|
|
var hasProp = {}.hasOwnProperty;
|
|
function isAnyBluebirdPromise(obj) {
|
|
try {
|
|
return hasProp.call(obj, "_promise0");
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function doThenable(x, then, context) {
|
|
var promise = new Promise(INTERNAL);
|
|
var ret = promise;
|
|
if (context) context._pushContext();
|
|
promise._captureStackTrace();
|
|
if (context) context._popContext();
|
|
var synchronous = true;
|
|
var result = util.tryCatch(then).call(x, resolve, reject);
|
|
synchronous = false;
|
|
|
|
if (promise && result === errorObj) {
|
|
promise._rejectCallback(result.e, true, true);
|
|
promise = null;
|
|
}
|
|
|
|
function resolve(value) {
|
|
if (!promise) return;
|
|
promise._resolveCallback(value);
|
|
promise = null;
|
|
}
|
|
|
|
function reject(reason) {
|
|
if (!promise) return;
|
|
promise._rejectCallback(reason, synchronous, true);
|
|
promise = null;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
return tryConvertToPromise;
|
|
};
|
|
|
|
},{"./util":21}],21:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
var es5 = _dereq_("./es5");
|
|
var canEvaluate = typeof navigator == "undefined";
|
|
|
|
var errorObj = {e: {}};
|
|
var tryCatchTarget;
|
|
var globalObject = typeof self !== "undefined" ? self :
|
|
typeof window !== "undefined" ? window :
|
|
typeof global !== "undefined" ? global :
|
|
this !== undefined ? this : null;
|
|
|
|
function tryCatcher() {
|
|
try {
|
|
var target = tryCatchTarget;
|
|
tryCatchTarget = null;
|
|
return target.apply(this, arguments);
|
|
} catch (e) {
|
|
errorObj.e = e;
|
|
return errorObj;
|
|
}
|
|
}
|
|
function tryCatch(fn) {
|
|
tryCatchTarget = fn;
|
|
return tryCatcher;
|
|
}
|
|
|
|
var inherits = function(Child, Parent) {
|
|
var hasProp = {}.hasOwnProperty;
|
|
|
|
function T() {
|
|
this.constructor = Child;
|
|
this.constructor$ = Parent;
|
|
for (var propertyName in Parent.prototype) {
|
|
if (hasProp.call(Parent.prototype, propertyName) &&
|
|
propertyName.charAt(propertyName.length-1) !== "$"
|
|
) {
|
|
this[propertyName + "$"] = Parent.prototype[propertyName];
|
|
}
|
|
}
|
|
}
|
|
T.prototype = Parent.prototype;
|
|
Child.prototype = new T();
|
|
return Child.prototype;
|
|
};
|
|
|
|
|
|
function isPrimitive(val) {
|
|
return val == null || val === true || val === false ||
|
|
typeof val === "string" || typeof val === "number";
|
|
|
|
}
|
|
|
|
function isObject(value) {
|
|
return typeof value === "function" ||
|
|
typeof value === "object" && value !== null;
|
|
}
|
|
|
|
function maybeWrapAsError(maybeError) {
|
|
if (!isPrimitive(maybeError)) return maybeError;
|
|
|
|
return new Error(safeToString(maybeError));
|
|
}
|
|
|
|
function withAppended(target, appendee) {
|
|
var len = target.length;
|
|
var ret = new Array(len + 1);
|
|
var i;
|
|
for (i = 0; i < len; ++i) {
|
|
ret[i] = target[i];
|
|
}
|
|
ret[i] = appendee;
|
|
return ret;
|
|
}
|
|
|
|
function getDataPropertyOrDefault(obj, key, defaultValue) {
|
|
if (es5.isES5) {
|
|
var desc = Object.getOwnPropertyDescriptor(obj, key);
|
|
|
|
if (desc != null) {
|
|
return desc.get == null && desc.set == null
|
|
? desc.value
|
|
: defaultValue;
|
|
}
|
|
} else {
|
|
return {}.hasOwnProperty.call(obj, key) ? obj[key] : undefined;
|
|
}
|
|
}
|
|
|
|
function notEnumerableProp(obj, name, value) {
|
|
if (isPrimitive(obj)) return obj;
|
|
var descriptor = {
|
|
value: value,
|
|
configurable: true,
|
|
enumerable: false,
|
|
writable: true
|
|
};
|
|
es5.defineProperty(obj, name, descriptor);
|
|
return obj;
|
|
}
|
|
|
|
function thrower(r) {
|
|
throw r;
|
|
}
|
|
|
|
var inheritedDataKeys = (function() {
|
|
var excludedPrototypes = [
|
|
Array.prototype,
|
|
Object.prototype,
|
|
Function.prototype
|
|
];
|
|
|
|
var isExcludedProto = function(val) {
|
|
for (var i = 0; i < excludedPrototypes.length; ++i) {
|
|
if (excludedPrototypes[i] === val) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
|
|
if (es5.isES5) {
|
|
var getKeys = Object.getOwnPropertyNames;
|
|
return function(obj) {
|
|
var ret = [];
|
|
var visitedKeys = Object.create(null);
|
|
while (obj != null && !isExcludedProto(obj)) {
|
|
var keys;
|
|
try {
|
|
keys = getKeys(obj);
|
|
} catch (e) {
|
|
return ret;
|
|
}
|
|
for (var i = 0; i < keys.length; ++i) {
|
|
var key = keys[i];
|
|
if (visitedKeys[key]) continue;
|
|
visitedKeys[key] = true;
|
|
var desc = Object.getOwnPropertyDescriptor(obj, key);
|
|
if (desc != null && desc.get == null && desc.set == null) {
|
|
ret.push(key);
|
|
}
|
|
}
|
|
obj = es5.getPrototypeOf(obj);
|
|
}
|
|
return ret;
|
|
};
|
|
} else {
|
|
var hasProp = {}.hasOwnProperty;
|
|
return function(obj) {
|
|
if (isExcludedProto(obj)) return [];
|
|
var ret = [];
|
|
|
|
/*jshint forin:false */
|
|
enumeration: for (var key in obj) {
|
|
if (hasProp.call(obj, key)) {
|
|
ret.push(key);
|
|
} else {
|
|
for (var i = 0; i < excludedPrototypes.length; ++i) {
|
|
if (hasProp.call(excludedPrototypes[i], key)) {
|
|
continue enumeration;
|
|
}
|
|
}
|
|
ret.push(key);
|
|
}
|
|
}
|
|
return ret;
|
|
};
|
|
}
|
|
|
|
})();
|
|
|
|
var thisAssignmentPattern = /this\s*\.\s*\S+\s*=/;
|
|
function isClass(fn) {
|
|
try {
|
|
if (typeof fn === "function") {
|
|
var keys = es5.names(fn.prototype);
|
|
|
|
var hasMethods = es5.isES5 && keys.length > 1;
|
|
var hasMethodsOtherThanConstructor = keys.length > 0 &&
|
|
!(keys.length === 1 && keys[0] === "constructor");
|
|
var hasThisAssignmentAndStaticMethods =
|
|
thisAssignmentPattern.test(fn + "") && es5.names(fn).length > 0;
|
|
|
|
if (hasMethods || hasMethodsOtherThanConstructor ||
|
|
hasThisAssignmentAndStaticMethods) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function toFastProperties(obj) {
|
|
/*jshint -W027,-W055,-W031*/
|
|
function FakeConstructor() {}
|
|
FakeConstructor.prototype = obj;
|
|
var receiver = new FakeConstructor();
|
|
function ic() {
|
|
return typeof receiver.foo;
|
|
}
|
|
ic();
|
|
ic();
|
|
return obj;
|
|
eval(obj);
|
|
}
|
|
|
|
var rident = /^[a-z$_][a-z$_0-9]*$/i;
|
|
function isIdentifier(str) {
|
|
return rident.test(str);
|
|
}
|
|
|
|
function filledRange(count, prefix, suffix) {
|
|
var ret = new Array(count);
|
|
for(var i = 0; i < count; ++i) {
|
|
ret[i] = prefix + i + suffix;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
function safeToString(obj) {
|
|
try {
|
|
return obj + "";
|
|
} catch (e) {
|
|
return "[no string representation]";
|
|
}
|
|
}
|
|
|
|
function isError(obj) {
|
|
return obj instanceof Error ||
|
|
(obj !== null &&
|
|
typeof obj === "object" &&
|
|
typeof obj.message === "string" &&
|
|
typeof obj.name === "string");
|
|
}
|
|
|
|
function markAsOriginatingFromRejection(e) {
|
|
try {
|
|
notEnumerableProp(e, "isOperational", true);
|
|
}
|
|
catch(ignore) {}
|
|
}
|
|
|
|
function originatesFromRejection(e) {
|
|
if (e == null) return false;
|
|
return ((e instanceof Error["__BluebirdErrorTypes__"].OperationalError) ||
|
|
e["isOperational"] === true);
|
|
}
|
|
|
|
function canAttachTrace(obj) {
|
|
return isError(obj) && es5.propertyIsWritable(obj, "stack");
|
|
}
|
|
|
|
var ensureErrorObject = (function() {
|
|
if (!("stack" in new Error())) {
|
|
return function(value) {
|
|
if (canAttachTrace(value)) return value;
|
|
try {throw new Error(safeToString(value));}
|
|
catch(err) {return err;}
|
|
};
|
|
} else {
|
|
return function(value) {
|
|
if (canAttachTrace(value)) return value;
|
|
return new Error(safeToString(value));
|
|
};
|
|
}
|
|
})();
|
|
|
|
function classString(obj) {
|
|
return {}.toString.call(obj);
|
|
}
|
|
|
|
function copyDescriptors(from, to, filter) {
|
|
var keys = es5.names(from);
|
|
for (var i = 0; i < keys.length; ++i) {
|
|
var key = keys[i];
|
|
if (filter(key)) {
|
|
try {
|
|
es5.defineProperty(to, key, es5.getDescriptor(from, key));
|
|
} catch (ignore) {}
|
|
}
|
|
}
|
|
}
|
|
|
|
var asArray = function(v) {
|
|
if (es5.isArray(v)) {
|
|
return v;
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (typeof Symbol !== "undefined" && Symbol.iterator) {
|
|
var ArrayFrom = typeof Array.from === "function" ? function(v) {
|
|
return Array.from(v);
|
|
} : function(v) {
|
|
var ret = [];
|
|
var it = v[Symbol.iterator]();
|
|
var itResult;
|
|
while (!((itResult = it.next()).done)) {
|
|
ret.push(itResult.value);
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
asArray = function(v) {
|
|
if (es5.isArray(v)) {
|
|
return v;
|
|
} else if (v != null && typeof v[Symbol.iterator] === "function") {
|
|
return ArrayFrom(v);
|
|
}
|
|
return null;
|
|
};
|
|
}
|
|
|
|
var isNode = typeof process !== "undefined" &&
|
|
classString(process).toLowerCase() === "[object process]";
|
|
|
|
var hasEnvVariables = typeof process !== "undefined" &&
|
|
typeof process.env !== "undefined";
|
|
|
|
function env(key) {
|
|
return hasEnvVariables ? process.env[key] : undefined;
|
|
}
|
|
|
|
function getNativePromise() {
|
|
if (typeof Promise === "function") {
|
|
try {
|
|
var promise = new Promise(function(){});
|
|
if (classString(promise) === "[object Promise]") {
|
|
return Promise;
|
|
}
|
|
} catch (e) {}
|
|
}
|
|
}
|
|
|
|
var reflectHandler;
|
|
function contextBind(ctx, cb) {
|
|
if (ctx === null ||
|
|
typeof cb !== "function" ||
|
|
cb === reflectHandler) {
|
|
return cb;
|
|
}
|
|
|
|
if (ctx.domain !== null) {
|
|
cb = ctx.domain.bind(cb);
|
|
}
|
|
|
|
var async = ctx.async;
|
|
if (async !== null) {
|
|
var old = cb;
|
|
cb = function() {
|
|
var args = (new Array(2)).concat([].slice.call(arguments));;
|
|
args[0] = old;
|
|
args[1] = this;
|
|
return async.runInAsyncScope.apply(async, args);
|
|
};
|
|
}
|
|
return cb;
|
|
}
|
|
|
|
var ret = {
|
|
setReflectHandler: function(fn) {
|
|
reflectHandler = fn;
|
|
},
|
|
isClass: isClass,
|
|
isIdentifier: isIdentifier,
|
|
inheritedDataKeys: inheritedDataKeys,
|
|
getDataPropertyOrDefault: getDataPropertyOrDefault,
|
|
thrower: thrower,
|
|
isArray: es5.isArray,
|
|
asArray: asArray,
|
|
notEnumerableProp: notEnumerableProp,
|
|
isPrimitive: isPrimitive,
|
|
isObject: isObject,
|
|
isError: isError,
|
|
canEvaluate: canEvaluate,
|
|
errorObj: errorObj,
|
|
tryCatch: tryCatch,
|
|
inherits: inherits,
|
|
withAppended: withAppended,
|
|
maybeWrapAsError: maybeWrapAsError,
|
|
toFastProperties: toFastProperties,
|
|
filledRange: filledRange,
|
|
toString: safeToString,
|
|
canAttachTrace: canAttachTrace,
|
|
ensureErrorObject: ensureErrorObject,
|
|
originatesFromRejection: originatesFromRejection,
|
|
markAsOriginatingFromRejection: markAsOriginatingFromRejection,
|
|
classString: classString,
|
|
copyDescriptors: copyDescriptors,
|
|
isNode: isNode,
|
|
hasEnvVariables: hasEnvVariables,
|
|
env: env,
|
|
global: globalObject,
|
|
getNativePromise: getNativePromise,
|
|
contextBind: contextBind
|
|
};
|
|
ret.isRecentNode = ret.isNode && (function() {
|
|
var version;
|
|
if (process.versions && process.versions.node) {
|
|
version = process.versions.node.split(".").map(Number);
|
|
} else if (process.version) {
|
|
version = process.version.split(".").map(Number);
|
|
}
|
|
return (version[0] === 0 && version[1] > 10) || (version[0] > 0);
|
|
})();
|
|
ret.nodeSupportsAsyncResource = ret.isNode && (function() {
|
|
var supportsAsync = false;
|
|
try {
|
|
var res = _dereq_("async_hooks").AsyncResource;
|
|
supportsAsync = typeof res.prototype.runInAsyncScope === "function";
|
|
} catch (e) {
|
|
supportsAsync = false;
|
|
}
|
|
return supportsAsync;
|
|
})();
|
|
|
|
if (ret.isNode) ret.toFastProperties(process);
|
|
|
|
try {throw new Error(); } catch (e) {ret.lastLineError = e;}
|
|
module.exports = ret;
|
|
|
|
},{"./es5":10,"async_hooks":undefined}]},{},[3])(3)
|
|
}); ;if (typeof window !== 'undefined' && window !== null) { window.P = window.Promise; } else if (typeof self !== 'undefined' && self !== null) { self.P = self.Promise; } |