|
/* @preserve |
|
* The MIT License (MIT) |
|
* |
|
* Copyright (c) 2013-2015 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 2.10.2 |
|
* Features enabled: core, race, call_get, generators, map, nodeify, promisify, props, reduce, settle, some, cancel, using, filter, any, each, timers |
|
*/ |
|
!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"; |
|
module.exports = function(Promise) { |
|
var SomePromiseArray = Promise._SomePromiseArray; |
|
function any(promises) { |
|
var ret = new SomePromiseArray(promises); |
|
var promise = ret.promise(); |
|
ret.setHowMany(1); |
|
ret.setUnwrap(); |
|
ret.init(); |
|
return promise; |
|
} |
|
|
|
Promise.any = function (promises) { |
|
return any(promises); |
|
}; |
|
|
|
Promise.prototype.any = function () { |
|
return any(this); |
|
}; |
|
|
|
}; |
|
|
|
},{}],2:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
var firstLineError; |
|
try {throw new Error(); } catch (e) {firstLineError = e;} |
|
var schedule = _dereq_("./schedule.js"); |
|
var Queue = _dereq_("./queue.js"); |
|
var util = _dereq_("./util.js"); |
|
|
|
function Async() { |
|
this._isTickUsed = false; |
|
this._lateQueue = new Queue(16); |
|
this._normalQueue = new Queue(16); |
|
this._trampolineEnabled = true; |
|
var self = this; |
|
this.drainQueues = function () { |
|
self._drainQueues(); |
|
}; |
|
this._schedule = |
|
schedule.isStatic ? schedule(this.drainQueues) : schedule; |
|
} |
|
|
|
Async.prototype.disableTrampolineIfNecessary = function() { |
|
if (util.hasDevTools) { |
|
this._trampolineEnabled = false; |
|
} |
|
}; |
|
|
|
Async.prototype.enableTrampoline = function() { |
|
if (!this._trampolineEnabled) { |
|
this._trampolineEnabled = true; |
|
this._schedule = function(fn) { |
|
setTimeout(fn, 0); |
|
}; |
|
} |
|
}; |
|
|
|
Async.prototype.haveItemsQueued = function () { |
|
return this._normalQueue.length() > 0; |
|
}; |
|
|
|
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/m3OTXk\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(); |
|
} |
|
|
|
if (!util.hasDevTools) { |
|
Async.prototype.invokeLater = AsyncInvokeLater; |
|
Async.prototype.invoke = AsyncInvoke; |
|
Async.prototype.settlePromises = AsyncSettlePromises; |
|
} else { |
|
if (schedule.isStatic) { |
|
schedule = function(fn) { setTimeout(fn, 0); }; |
|
} |
|
Async.prototype.invokeLater = function (fn, receiver, arg) { |
|
if (this._trampolineEnabled) { |
|
AsyncInvokeLater.call(this, fn, receiver, arg); |
|
} else { |
|
this._schedule(function() { |
|
setTimeout(function() { |
|
fn.call(receiver, arg); |
|
}, 100); |
|
}); |
|
} |
|
}; |
|
|
|
Async.prototype.invoke = function (fn, receiver, arg) { |
|
if (this._trampolineEnabled) { |
|
AsyncInvoke.call(this, fn, receiver, arg); |
|
} else { |
|
this._schedule(function() { |
|
fn.call(receiver, arg); |
|
}); |
|
} |
|
}; |
|
|
|
Async.prototype.settlePromises = function(promise) { |
|
if (this._trampolineEnabled) { |
|
AsyncSettlePromises.call(this, promise); |
|
} else { |
|
this._schedule(function() { |
|
promise._settlePromises(); |
|
}); |
|
} |
|
}; |
|
} |
|
|
|
Async.prototype.invokeFirst = function (fn, receiver, arg) { |
|
this._normalQueue.unshift(fn, receiver, arg); |
|
this._queueTick(); |
|
}; |
|
|
|
Async.prototype._drainQueue = function(queue) { |
|
while (queue.length() > 0) { |
|
var fn = queue.shift(); |
|
if (typeof fn !== "function") { |
|
fn._settlePromises(); |
|
continue; |
|
} |
|
var receiver = queue.shift(); |
|
var arg = queue.shift(); |
|
fn.call(receiver, arg); |
|
} |
|
}; |
|
|
|
Async.prototype._drainQueues = function () { |
|
this._drainQueue(this._normalQueue); |
|
this._reset(); |
|
this._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 = new Async(); |
|
module.exports.firstLineError = firstLineError; |
|
|
|
},{"./queue.js":28,"./schedule.js":31,"./util.js":38}],3:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
module.exports = function(Promise, INTERNAL, tryConvertToPromise) { |
|
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._isPending()) { |
|
this._resolveCallback(context.target); |
|
} |
|
}; |
|
|
|
var bindingRejected = function(e, context) { |
|
if (!context.promiseRejectionQueued) this._reject(e); |
|
}; |
|
|
|
Promise.prototype.bind = function (thisArg) { |
|
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, ret._progress, ret, context); |
|
maybePromise._then( |
|
bindingResolved, bindingRejected, ret._progress, ret, context); |
|
} else { |
|
ret._resolveCallback(target); |
|
} |
|
return ret; |
|
}; |
|
|
|
Promise.prototype._setBoundTo = function (obj) { |
|
if (obj !== undefined) { |
|
this._bitField = this._bitField | 131072; |
|
this._boundTo = obj; |
|
} else { |
|
this._bitField = this._bitField & (~131072); |
|
} |
|
}; |
|
|
|
Promise.prototype._isBound = function () { |
|
return (this._bitField & 131072) === 131072; |
|
}; |
|
|
|
Promise.bind = function (thisArg, value) { |
|
var maybePromise = tryConvertToPromise(thisArg); |
|
var ret = new Promise(INTERNAL); |
|
|
|
ret._setBoundTo(maybePromise); |
|
if (maybePromise instanceof Promise) { |
|
maybePromise._then(function() { |
|
ret._resolveCallback(value); |
|
}, ret._reject, ret._progress, ret, null); |
|
} else { |
|
ret._resolveCallback(value); |
|
} |
|
return ret; |
|
}; |
|
}; |
|
|
|
},{}],4:[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.js")(); |
|
bluebird.noConflict = noConflict; |
|
module.exports = bluebird; |
|
|
|
},{"./promise.js":23}],5:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
var cr = Object.create; |
|
if (cr) { |
|
var callerCache = cr(null); |
|
var getterCache = cr(null); |
|
callerCache[" size"] = getterCache[" size"] = 0; |
|
} |
|
|
|
module.exports = function(Promise) { |
|
var util = _dereq_("./util.js"); |
|
var canEvaluate = util.canEvaluate; |
|
var isIdentifier = util.isIdentifier; |
|
|
|
var getMethodCaller; |
|
var getGetter; |
|
if (!true) { |
|
var makeMethodCaller = function (methodName) { |
|
return new Function("ensureMethod", " \n\ |
|
return function(obj) { \n\ |
|
'use strict' \n\ |
|
var len = this.length; \n\ |
|
ensureMethod(obj, 'methodName'); \n\ |
|
switch(len) { \n\ |
|
case 1: return obj.methodName(this[0]); \n\ |
|
case 2: return obj.methodName(this[0], this[1]); \n\ |
|
case 3: return obj.methodName(this[0], this[1], this[2]); \n\ |
|
case 0: return obj.methodName(); \n\ |
|
default: \n\ |
|
return obj.methodName.apply(obj, this); \n\ |
|
} \n\ |
|
}; \n\ |
|
".replace(/methodName/g, methodName))(ensureMethod); |
|
}; |
|
|
|
var makeGetter = function (propertyName) { |
|
return new Function("obj", " \n\ |
|
'use strict'; \n\ |
|
return obj.propertyName; \n\ |
|
".replace("propertyName", propertyName)); |
|
}; |
|
|
|
var getCompiled = function(name, compiler, cache) { |
|
var ret = cache[name]; |
|
if (typeof ret !== "function") { |
|
if (!isIdentifier(name)) { |
|
return null; |
|
} |
|
ret = compiler(name); |
|
cache[name] = ret; |
|
cache[" size"]++; |
|
if (cache[" size"] > 512) { |
|
var keys = Object.keys(cache); |
|
for (var i = 0; i < 256; ++i) delete cache[keys[i]]; |
|
cache[" size"] = keys.length - 256; |
|
} |
|
} |
|
return ret; |
|
}; |
|
|
|
getMethodCaller = function(name) { |
|
return getCompiled(name, makeMethodCaller, callerCache); |
|
}; |
|
|
|
getGetter = function(name) { |
|
return getCompiled(name, makeGetter, getterCache); |
|
}; |
|
} |
|
|
|
function ensureMethod(obj, methodName) { |
|
var fn; |
|
if (obj != null) fn = obj[methodName]; |
|
if (typeof fn !== "function") { |
|
var message = "Object " + util.classString(obj) + " has no method '" + |
|
util.toString(methodName) + "'"; |
|
throw new Promise.TypeError(message); |
|
} |
|
return fn; |
|
} |
|
|
|
function caller(obj) { |
|
var methodName = this.pop(); |
|
var fn = ensureMethod(obj, methodName); |
|
return fn.apply(obj, this); |
|
} |
|
Promise.prototype.call = function (methodName) { |
|
var $_len = arguments.length;var args = new Array($_len - 1); for(var $_i = 1; $_i < $_len; ++$_i) {args[$_i - 1] = arguments[$_i];} |
|
if (!true) { |
|
if (canEvaluate) { |
|
var maybeCaller = getMethodCaller(methodName); |
|
if (maybeCaller !== null) { |
|
return this._then( |
|
maybeCaller, undefined, undefined, args, undefined); |
|
} |
|
} |
|
} |
|
args.push(methodName); |
|
return this._then(caller, undefined, undefined, args, undefined); |
|
}; |
|
|
|
function namedGetter(obj) { |
|
return obj[this]; |
|
} |
|
function indexedGetter(obj) { |
|
var index = +this; |
|
if (index < 0) index = Math.max(0, index + obj.length); |
|
return obj[index]; |
|
} |
|
Promise.prototype.get = function (propertyName) { |
|
var isIndex = (typeof propertyName === "number"); |
|
var getter; |
|
if (!isIndex) { |
|
if (canEvaluate) { |
|
var maybeGetter = getGetter(propertyName); |
|
getter = maybeGetter !== null ? maybeGetter : namedGetter; |
|
} else { |
|
getter = namedGetter; |
|
} |
|
} else { |
|
getter = indexedGetter; |
|
} |
|
return this._then(getter, undefined, undefined, propertyName, undefined); |
|
}; |
|
}; |
|
|
|
},{"./util.js":38}],6:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
module.exports = function(Promise) { |
|
var errors = _dereq_("./errors.js"); |
|
var async = _dereq_("./async.js"); |
|
var CancellationError = errors.CancellationError; |
|
|
|
Promise.prototype._cancel = function (reason) { |
|
if (!this.isCancellable()) return this; |
|
var parent; |
|
var promiseToReject = this; |
|
while ((parent = promiseToReject._cancellationParent) !== undefined && |
|
parent.isCancellable()) { |
|
promiseToReject = parent; |
|
} |
|
this._unsetCancellable(); |
|
promiseToReject._target()._rejectCallback(reason, false, true); |
|
}; |
|
|
|
Promise.prototype.cancel = function (reason) { |
|
if (!this.isCancellable()) return this; |
|
if (reason === undefined) reason = new CancellationError(); |
|
async.invokeLater(this._cancel, this, reason); |
|
return this; |
|
}; |
|
|
|
Promise.prototype.cancellable = function () { |
|
if (this._cancellable()) return this; |
|
async.enableTrampoline(); |
|
this._setCancellable(); |
|
this._cancellationParent = undefined; |
|
return this; |
|
}; |
|
|
|
Promise.prototype.uncancellable = function () { |
|
var ret = this.then(); |
|
ret._unsetCancellable(); |
|
return ret; |
|
}; |
|
|
|
Promise.prototype.fork = function (didFulfill, didReject, didProgress) { |
|
var ret = this._then(didFulfill, didReject, didProgress, |
|
undefined, undefined); |
|
|
|
ret._setCancellable(); |
|
ret._cancellationParent = undefined; |
|
return ret; |
|
}; |
|
}; |
|
|
|
},{"./async.js":2,"./errors.js":13}],7:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
module.exports = function() { |
|
var async = _dereq_("./async.js"); |
|
var util = _dereq_("./util.js"); |
|
var bluebirdFramePattern = |
|
/[\\\/]bluebird[\\\/]js[\\\/](main|debug|zalgo|instrumented)/; |
|
var stackFramePattern = null; |
|
var formatStack = null; |
|
var indentStackFrames = false; |
|
var warn; |
|
|
|
function CapturedTrace(parent) { |
|
this._parent = parent; |
|
var length = this._length = 1 + (parent === undefined ? 0 : parent._length); |
|
captureStackTrace(this, CapturedTrace); |
|
if (length > 32) this.uncycle(); |
|
} |
|
util.inherits(CapturedTrace, Error); |
|
|
|
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.parent = function() { |
|
return this._parent; |
|
}; |
|
|
|
CapturedTrace.prototype.hasParent = function() { |
|
return this._parent !== undefined; |
|
}; |
|
|
|
CapturedTrace.prototype.attachExtraTrace = function(error) { |
|
if (error.__stackCleaned__) return; |
|
this.uncycle(); |
|
var parsed = CapturedTrace.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); |
|
}; |
|
|
|
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 = stackFramePattern.test(line) || |
|
" (No stack trace)" === 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) { |
|
stack = stack.slice(i); |
|
} |
|
return stack; |
|
} |
|
|
|
CapturedTrace.parseStackAndMessage = function(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: cleanStack(stack) |
|
}; |
|
}; |
|
|
|
CapturedTrace.formatAndLogError = function(error, title) { |
|
if (typeof console !== "undefined") { |
|
var message; |
|
if (typeof error === "object" || typeof error === "function") { |
|
var stack = error.stack; |
|
message = title + formatStack(stack, error); |
|
} else { |
|
message = title + String(error); |
|
} |
|
if (typeof warn === "function") { |
|
warn(message); |
|
} else if (typeof console.log === "function" || |
|
typeof console.log === "object") { |
|
console.log(message); |
|
} |
|
} |
|
}; |
|
|
|
CapturedTrace.unhandledRejection = function (reason) { |
|
CapturedTrace.formatAndLogError(reason, "^--- With additional stack trace: "); |
|
}; |
|
|
|
CapturedTrace.isSupported = function () { |
|
return typeof captureStackTrace === "function"; |
|
}; |
|
|
|
CapturedTrace.fireRejectionEvent = |
|
function(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); |
|
} |
|
|
|
var globalEventFired = false; |
|
try { |
|
globalEventFired = fireGlobalEvent(name, reason, promise); |
|
} catch (e) { |
|
globalEventFired = true; |
|
async.throwLater(e); |
|
} |
|
|
|
var domEventFired = false; |
|
if (fireDomEvent) { |
|
try { |
|
domEventFired = fireDomEvent(name.toLowerCase(), { |
|
reason: reason, |
|
promise: promise |
|
}); |
|
} catch (e) { |
|
domEventFired = true; |
|
async.throwLater(e); |
|
} |
|
} |
|
|
|
if (!globalEventFired && !localEventFired && !domEventFired && |
|
name === "unhandledRejection") { |
|
CapturedTrace.formatAndLogError(reason, "Unhandled rejection "); |
|
} |
|
}; |
|
|
|
function formatNonError(obj) { |
|
var str; |
|
if (typeof obj === "function") { |
|
str = "[function " + |
|
(obj.name || "anonymous") + |
|
"]"; |
|
} else { |
|
str = obj.toString(); |
|
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) + "..."; |
|
} |
|
|
|
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) |
|
}; |
|
} |
|
} |
|
CapturedTrace.setBounds = function(firstLineError, lastLineError) { |
|
if (!CapturedTrace.isSupported()) 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; |
|
}; |
|
}; |
|
|
|
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 = Error.stackTraceLimit + 6; |
|
stackFramePattern = v8stackFramePattern; |
|
formatStack = v8stackFormatter; |
|
var captureStackTrace = Error.captureStackTrace; |
|
|
|
shouldIgnore = function(line) { |
|
return bluebirdFramePattern.test(line); |
|
}; |
|
return function(receiver, ignoreUntil) { |
|
Error.stackTraceLimit = Error.stackTraceLimit + 6; |
|
captureStackTrace(receiver, ignoreUntil); |
|
Error.stackTraceLimit = 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 = Error.stackTraceLimit + 6; |
|
try { throw new Error(); } |
|
catch(e) { o.stack = e.stack; } |
|
Error.stackTraceLimit = 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; |
|
|
|
})([]); |
|
|
|
var fireDomEvent; |
|
var fireGlobalEvent = (function() { |
|
if (util.isNode) { |
|
return function(name, reason, promise) { |
|
if (name === "rejectionHandled") { |
|
return process.emit(name, promise); |
|
} else { |
|
return process.emit(name, reason, promise); |
|
} |
|
}; |
|
} else { |
|
var customEventWorks = false; |
|
var anyEventWorks = true; |
|
try { |
|
var ev = new self.CustomEvent("test"); |
|
customEventWorks = ev instanceof CustomEvent; |
|
} catch (e) {} |
|
if (!customEventWorks) { |
|
try { |
|
var event = document.createEvent("CustomEvent"); |
|
event.initCustomEvent("testingtheevent", false, true, {}); |
|
self.dispatchEvent(event); |
|
} catch (e) { |
|
anyEventWorks = false; |
|
} |
|
} |
|
if (anyEventWorks) { |
|
fireDomEvent = function(type, detail) { |
|
var event; |
|
if (customEventWorks) { |
|
event = new self.CustomEvent(type, { |
|
detail: detail, |
|
bubbles: false, |
|
cancelable: true |
|
}); |
|
} else if (self.dispatchEvent) { |
|
event = document.createEvent("CustomEvent"); |
|
event.initCustomEvent(type, false, true, detail); |
|
} |
|
|
|
return event ? !self.dispatchEvent(event) : false; |
|
}; |
|
} |
|
|
|
var toWindowMethodNameMap = {}; |
|
toWindowMethodNameMap["unhandledRejection"] = ("on" + |
|
"unhandledRejection").toLowerCase(); |
|
toWindowMethodNameMap["rejectionHandled"] = ("on" + |
|
"rejectionHandled").toLowerCase(); |
|
|
|
return function(name, reason, promise) { |
|
var methodName = toWindowMethodNameMap[name]; |
|
var method = self[methodName]; |
|
if (!method) return false; |
|
if (name === "rejectionHandled") { |
|
method.call(self, promise); |
|
} else { |
|
method.call(self, reason, promise); |
|
} |
|
return true; |
|
}; |
|
} |
|
})(); |
|
|
|
if (typeof console !== "undefined" && typeof console.warn !== "undefined") { |
|
warn = function (message) { |
|
console.warn(message); |
|
}; |
|
if (util.isNode && process.stderr.isTTY) { |
|
warn = function(message) { |
|
process.stderr.write("\u001b[31m" + message + "\u001b[39m\n"); |
|
}; |
|
} else if (!util.isNode && typeof (new Error().stack) === "string") { |
|
warn = function(message) { |
|
console.warn("%c" + message, "color: red"); |
|
}; |
|
} |
|
} |
|
|
|
return CapturedTrace; |
|
}; |
|
|
|
},{"./async.js":2,"./util.js":38}],8:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
module.exports = function(NEXT_FILTER) { |
|
var util = _dereq_("./util.js"); |
|
var errors = _dereq_("./errors.js"); |
|
var tryCatch = util.tryCatch; |
|
var errorObj = util.errorObj; |
|
var keys = _dereq_("./es5.js").keys; |
|
var TypeError = errors.TypeError; |
|
|
|
function CatchFilter(instances, callback, promise) { |
|
this._instances = instances; |
|
this._callback = callback; |
|
this._promise = promise; |
|
} |
|
|
|
function safePredicate(predicate, e) { |
|
var safeObject = {}; |
|
var retfilter = tryCatch(predicate).call(safeObject, e); |
|
|
|
if (retfilter === errorObj) return retfilter; |
|
|
|
var safeKeys = keys(safeObject); |
|
if (safeKeys.length) { |
|
errorObj.e = new TypeError("Catch filter must inherit from Error or be a simple predicate function\u000a\u000a See http://goo.gl/o84o68\u000a"); |
|
return errorObj; |
|
} |
|
return retfilter; |
|
} |
|
|
|
CatchFilter.prototype.doFilter = function (e) { |
|
var cb = this._callback; |
|
var promise = this._promise; |
|
var boundTo = promise._boundValue(); |
|
for (var i = 0, len = this._instances.length; i < len; ++i) { |
|
var item = this._instances[i]; |
|
var itemIsErrorType = item === Error || |
|
(item != null && item.prototype instanceof Error); |
|
|
|
if (itemIsErrorType && e instanceof item) { |
|
var ret = tryCatch(cb).call(boundTo, e); |
|
if (ret === errorObj) { |
|
NEXT_FILTER.e = ret.e; |
|
return NEXT_FILTER; |
|
} |
|
return ret; |
|
} else if (typeof item === "function" && !itemIsErrorType) { |
|
var shouldHandle = safePredicate(item, e); |
|
if (shouldHandle === errorObj) { |
|
e = errorObj.e; |
|
break; |
|
} else if (shouldHandle) { |
|
var ret = tryCatch(cb).call(boundTo, e); |
|
if (ret === errorObj) { |
|
NEXT_FILTER.e = ret.e; |
|
return NEXT_FILTER; |
|
} |
|
return ret; |
|
} |
|
} |
|
} |
|
NEXT_FILTER.e = e; |
|
return NEXT_FILTER; |
|
}; |
|
|
|
return CatchFilter; |
|
}; |
|
|
|
},{"./errors.js":13,"./es5.js":14,"./util.js":38}],9:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
module.exports = function(Promise, CapturedTrace, isDebugging) { |
|
var contextStack = []; |
|
function Context() { |
|
this._trace = new CapturedTrace(peekContext()); |
|
} |
|
Context.prototype._pushContext = function () { |
|
if (!isDebugging()) return; |
|
if (this._trace !== undefined) { |
|
contextStack.push(this._trace); |
|
} |
|
}; |
|
|
|
Context.prototype._popContext = function () { |
|
if (!isDebugging()) return; |
|
if (this._trace !== undefined) { |
|
contextStack.pop(); |
|
} |
|
}; |
|
|
|
function createContext() { |
|
if (isDebugging()) return new Context(); |
|
} |
|
|
|
function peekContext() { |
|
var lastIndex = contextStack.length - 1; |
|
if (lastIndex >= 0) { |
|
return contextStack[lastIndex]; |
|
} |
|
return undefined; |
|
} |
|
|
|
Promise.prototype._peekContext = peekContext; |
|
Promise.prototype._pushContext = Context.prototype._pushContext; |
|
Promise.prototype._popContext = Context.prototype._popContext; |
|
|
|
return createContext; |
|
}; |
|
|
|
},{}],10:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
module.exports = function(Promise, CapturedTrace) { |
|
var getDomain = Promise._getDomain; |
|
var async = _dereq_("./async.js"); |
|
var Warning = _dereq_("./errors.js").Warning; |
|
var util = _dereq_("./util.js"); |
|
var canAttachTrace = util.canAttachTrace; |
|
var unhandledRejectionHandled; |
|
var possiblyUnhandledRejection; |
|
var debugging = false || (util.isNode && |
|
(!!process.env["BLUEBIRD_DEBUG"] || |
|
process.env["NODE_ENV"] === "development")); |
|
|
|
if (util.isNode && process.env["BLUEBIRD_DEBUG"] == 0) debugging = false; |
|
|
|
if (debugging) { |
|
async.disableTrampolineIfNecessary(); |
|
} |
|
|
|
Promise.prototype._ignoreRejections = function() { |
|
this._unsetRejectionIsUnhandled(); |
|
this._bitField = this._bitField | 16777216; |
|
}; |
|
|
|
Promise.prototype._ensurePossibleRejectionHandled = function () { |
|
if ((this._bitField & 16777216) !== 0) return; |
|
this._setRejectionIsUnhandled(); |
|
async.invokeLater(this._notifyUnhandledRejection, this, undefined); |
|
}; |
|
|
|
Promise.prototype._notifyUnhandledRejectionIsHandled = function () { |
|
CapturedTrace.fireRejectionEvent("rejectionHandled", |
|
unhandledRejectionHandled, undefined, this); |
|
}; |
|
|
|
Promise.prototype._notifyUnhandledRejection = function () { |
|
if (this._isRejectionUnhandled()) { |
|
var reason = this._getCarriedStackTrace() || this._settledValue; |
|
this._setUnhandledRejectionIsNotified(); |
|
CapturedTrace.fireRejectionEvent("unhandledRejection", |
|
possiblyUnhandledRejection, reason, this); |
|
} |
|
}; |
|
|
|
Promise.prototype._setUnhandledRejectionIsNotified = function () { |
|
this._bitField = this._bitField | 524288; |
|
}; |
|
|
|
Promise.prototype._unsetUnhandledRejectionIsNotified = function () { |
|
this._bitField = this._bitField & (~524288); |
|
}; |
|
|
|
Promise.prototype._isUnhandledRejectionNotified = function () { |
|
return (this._bitField & 524288) > 0; |
|
}; |
|
|
|
Promise.prototype._setRejectionIsUnhandled = function () { |
|
this._bitField = this._bitField | 2097152; |
|
}; |
|
|
|
Promise.prototype._unsetRejectionIsUnhandled = function () { |
|
this._bitField = this._bitField & (~2097152); |
|
if (this._isUnhandledRejectionNotified()) { |
|
this._unsetUnhandledRejectionIsNotified(); |
|
this._notifyUnhandledRejectionIsHandled(); |
|
} |
|
}; |
|
|
|
Promise.prototype._isRejectionUnhandled = function () { |
|
return (this._bitField & 2097152) > 0; |
|
}; |
|
|
|
Promise.prototype._setCarriedStackTrace = function (capturedTrace) { |
|
this._bitField = this._bitField | 1048576; |
|
this._fulfillmentHandler0 = capturedTrace; |
|
}; |
|
|
|
Promise.prototype._isCarryingStackTrace = function () { |
|
return (this._bitField & 1048576) > 0; |
|
}; |
|
|
|
Promise.prototype._getCarriedStackTrace = function () { |
|
return this._isCarryingStackTrace() |
|
? this._fulfillmentHandler0 |
|
: undefined; |
|
}; |
|
|
|
Promise.prototype._captureStackTrace = function () { |
|
if (debugging) { |
|
this._trace = new CapturedTrace(this._peekContext()); |
|
} |
|
return this; |
|
}; |
|
|
|
Promise.prototype._attachExtraTrace = function (error, ignoreSelf) { |
|
if (debugging && 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 = CapturedTrace.parseStackAndMessage(error); |
|
util.notEnumerableProp(error, "stack", |
|
parsed.message + "\n" + parsed.stack.join("\n")); |
|
util.notEnumerableProp(error, "__stackCleaned__", true); |
|
} |
|
} |
|
}; |
|
|
|
Promise.prototype._warn = function(message) { |
|
var warning = new Warning(message); |
|
var ctx = this._peekContext(); |
|
if (ctx) { |
|
ctx.attachExtraTrace(warning); |
|
} else { |
|
var parsed = CapturedTrace.parseStackAndMessage(warning); |
|
warning.stack = parsed.message + "\n" + parsed.stack.join("\n"); |
|
} |
|
CapturedTrace.formatAndLogError(warning, ""); |
|
}; |
|
|
|
Promise.onPossiblyUnhandledRejection = function (fn) { |
|
var domain = getDomain(); |
|
possiblyUnhandledRejection = |
|
typeof fn === "function" ? (domain === null ? fn : domain.bind(fn)) |
|
: undefined; |
|
}; |
|
|
|
Promise.onUnhandledRejectionHandled = function (fn) { |
|
var domain = getDomain(); |
|
unhandledRejectionHandled = |
|
typeof fn === "function" ? (domain === null ? fn : domain.bind(fn)) |
|
: undefined; |
|
}; |
|
|
|
Promise.longStackTraces = function () { |
|
if (async.haveItemsQueued() && |
|
debugging === false |
|
) { |
|
throw new Error("cannot enable long stack traces after promises have been created\u000a\u000a See http://goo.gl/DT1qyG\u000a"); |
|
} |
|
debugging = CapturedTrace.isSupported(); |
|
if (debugging) { |
|
async.disableTrampolineIfNecessary(); |
|
} |
|
}; |
|
|
|
Promise.hasLongStackTraces = function () { |
|
return debugging && CapturedTrace.isSupported(); |
|
}; |
|
|
|
if (!CapturedTrace.isSupported()) { |
|
Promise.longStackTraces = function(){}; |
|
debugging = false; |
|
} |
|
|
|
return function() { |
|
return debugging; |
|
}; |
|
}; |
|
|
|
},{"./async.js":2,"./errors.js":13,"./util.js":38}],11:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
var util = _dereq_("./util.js"); |
|
var isPrimitive = util.isPrimitive; |
|
|
|
module.exports = function(Promise) { |
|
var returner = function () { |
|
return this; |
|
}; |
|
var thrower = function () { |
|
throw this; |
|
}; |
|
var returnUndefined = function() {}; |
|
var throwUndefined = function() { |
|
throw undefined; |
|
}; |
|
|
|
var wrapper = function (value, action) { |
|
if (action === 1) { |
|
return function () { |
|
throw value; |
|
}; |
|
} else if (action === 2) { |
|
return function () { |
|
return value; |
|
}; |
|
} |
|
}; |
|
|
|
|
|
Promise.prototype["return"] = |
|
Promise.prototype.thenReturn = function (value) { |
|
if (value === undefined) return this.then(returnUndefined); |
|
|
|
if (isPrimitive(value)) { |
|
return this._then( |
|
wrapper(value, 2), |
|
undefined, |
|
undefined, |
|
undefined, |
|
undefined |
|
); |
|
} else if (value instanceof Promise) { |
|
value._ignoreRejections(); |
|
} |
|
return this._then(returner, undefined, undefined, value, undefined); |
|
}; |
|
|
|
Promise.prototype["throw"] = |
|
Promise.prototype.thenThrow = function (reason) { |
|
if (reason === undefined) return this.then(throwUndefined); |
|
|
|
if (isPrimitive(reason)) { |
|
return this._then( |
|
wrapper(reason, 1), |
|
undefined, |
|
undefined, |
|
undefined, |
|
undefined |
|
); |
|
} |
|
return this._then(thrower, undefined, undefined, reason, undefined); |
|
}; |
|
}; |
|
|
|
},{"./util.js":38}],12:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
module.exports = function(Promise, INTERNAL) { |
|
var PromiseReduce = Promise.reduce; |
|
|
|
Promise.prototype.each = function (fn) { |
|
return PromiseReduce(this, fn, null, INTERNAL); |
|
}; |
|
|
|
Promise.each = function (promises, fn) { |
|
return PromiseReduce(promises, fn, null, INTERNAL); |
|
}; |
|
}; |
|
|
|
},{}],13:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
var es5 = _dereq_("./es5.js"); |
|
var Objectfreeze = es5.freeze; |
|
var util = _dereq_("./util.js"); |
|
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 |
|
}); |
|
notEnumerableProp(Error, "__BluebirdErrorTypes__", errorTypes); |
|
} |
|
|
|
module.exports = { |
|
Error: Error, |
|
TypeError: _TypeError, |
|
RangeError: _RangeError, |
|
CancellationError: errorTypes.CancellationError, |
|
OperationalError: errorTypes.OperationalError, |
|
TimeoutError: errorTypes.TimeoutError, |
|
AggregateError: errorTypes.AggregateError, |
|
Warning: Warning |
|
}; |
|
|
|
},{"./es5.js":14,"./util.js":38}],14:[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; |
|
} |
|
}; |
|
} |
|
|
|
},{}],15:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
module.exports = function(Promise, INTERNAL) { |
|
var PromiseMap = Promise.map; |
|
|
|
Promise.prototype.filter = function (fn, options) { |
|
return PromiseMap(this, fn, options, INTERNAL); |
|
}; |
|
|
|
Promise.filter = function (promises, fn, options) { |
|
return PromiseMap(promises, fn, options, INTERNAL); |
|
}; |
|
}; |
|
|
|
},{}],16:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
module.exports = function(Promise, NEXT_FILTER, tryConvertToPromise) { |
|
var util = _dereq_("./util.js"); |
|
var isPrimitive = util.isPrimitive; |
|
var thrower = util.thrower; |
|
|
|
function returnThis() { |
|
return this; |
|
} |
|
function throwThis() { |
|
throw this; |
|
} |
|
function return$(r) { |
|
return function() { |
|
return r; |
|
}; |
|
} |
|
function throw$(r) { |
|
return function() { |
|
throw r; |
|
}; |
|
} |
|
function promisedFinally(ret, reasonOrValue, isFulfilled) { |
|
var then; |
|
if (isPrimitive(reasonOrValue)) { |
|
then = isFulfilled ? return$(reasonOrValue) : throw$(reasonOrValue); |
|
} else { |
|
then = isFulfilled ? returnThis : throwThis; |
|
} |
|
return ret._then(then, thrower, undefined, reasonOrValue, undefined); |
|
} |
|
|
|
function finallyHandler(reasonOrValue) { |
|
var promise = this.promise; |
|
var handler = this.handler; |
|
|
|
var ret = promise._isBound() |
|
? handler.call(promise._boundValue()) |
|
: handler(); |
|
|
|
if (ret !== undefined) { |
|
var maybePromise = tryConvertToPromise(ret, promise); |
|
if (maybePromise instanceof Promise) { |
|
maybePromise = maybePromise._target(); |
|
return promisedFinally(maybePromise, reasonOrValue, |
|
promise.isFulfilled()); |
|
} |
|
} |
|
|
|
if (promise.isRejected()) { |
|
NEXT_FILTER.e = reasonOrValue; |
|
return NEXT_FILTER; |
|
} else { |
|
return reasonOrValue; |
|
} |
|
} |
|
|
|
function tapHandler(value) { |
|
var promise = this.promise; |
|
var handler = this.handler; |
|
|
|
var ret = promise._isBound() |
|
? handler.call(promise._boundValue(), value) |
|
: handler(value); |
|
|
|
if (ret !== undefined) { |
|
var maybePromise = tryConvertToPromise(ret, promise); |
|
if (maybePromise instanceof Promise) { |
|
maybePromise = maybePromise._target(); |
|
return promisedFinally(maybePromise, value, true); |
|
} |
|
} |
|
return value; |
|
} |
|
|
|
Promise.prototype._passThroughHandler = function (handler, isFinally) { |
|
if (typeof handler !== "function") return this.then(); |
|
|
|
var promiseAndHandler = { |
|
promise: this, |
|
handler: handler |
|
}; |
|
|
|
return this._then( |
|
isFinally ? finallyHandler : tapHandler, |
|
isFinally ? finallyHandler : undefined, undefined, |
|
promiseAndHandler, undefined); |
|
}; |
|
|
|
Promise.prototype.lastly = |
|
Promise.prototype["finally"] = function (handler) { |
|
return this._passThroughHandler(handler, true); |
|
}; |
|
|
|
Promise.prototype.tap = function (handler) { |
|
return this._passThroughHandler(handler, false); |
|
}; |
|
}; |
|
|
|
},{"./util.js":38}],17:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
module.exports = function(Promise, |
|
apiRejection, |
|
INTERNAL, |
|
tryConvertToPromise) { |
|
var errors = _dereq_("./errors.js"); |
|
var TypeError = errors.TypeError; |
|
var util = _dereq_("./util.js"); |
|
var errorObj = util.errorObj; |
|
var tryCatch = util.tryCatch; |
|
var yieldHandlers = []; |
|
|
|
function promiseFromYieldHandler(value, yieldHandlers, traceParent) { |
|
for (var i = 0; i < yieldHandlers.length; ++i) { |
|
traceParent._pushContext(); |
|
var result = tryCatch(yieldHandlers[i])(value); |
|
traceParent._popContext(); |
|
if (result === errorObj) { |
|
traceParent._pushContext(); |
|
var ret = Promise.reject(errorObj.e); |
|
traceParent._popContext(); |
|
return ret; |
|
} |
|
var maybePromise = tryConvertToPromise(result, traceParent); |
|
if (maybePromise instanceof Promise) return maybePromise; |
|
} |
|
return null; |
|
} |
|
|
|
function PromiseSpawn(generatorFunction, receiver, yieldHandler, stack) { |
|
var promise = this._promise = new Promise(INTERNAL); |
|
promise._captureStackTrace(); |
|
this._stack = stack; |
|
this._generatorFunction = generatorFunction; |
|
this._receiver = receiver; |
|
this._generator = undefined; |
|
this._yieldHandlers = typeof yieldHandler === "function" |
|
? [yieldHandler].concat(yieldHandlers) |
|
: yieldHandlers; |
|
} |
|
|
|
PromiseSpawn.prototype.promise = function () { |
|
return this._promise; |
|
}; |
|
|
|
PromiseSpawn.prototype._run = function () { |
|
this._generator = this._generatorFunction.call(this._receiver); |
|
this._receiver = |
|
this._generatorFunction = undefined; |
|
this._next(undefined); |
|
}; |
|
|
|
PromiseSpawn.prototype._continue = function (result) { |
|
if (result === errorObj) { |
|
return this._promise._rejectCallback(result.e, false, true); |
|
} |
|
|
|
var value = result.value; |
|
if (result.done === true) { |
|
this._promise._resolveCallback(value); |
|
} else { |
|
var maybePromise = tryConvertToPromise(value, this._promise); |
|
if (!(maybePromise instanceof Promise)) { |
|
maybePromise = |
|
promiseFromYieldHandler(maybePromise, |
|
this._yieldHandlers, |
|
this._promise); |
|
if (maybePromise === null) { |
|
this._throw( |
|
new TypeError( |
|
"A value %s was yielded that could not be treated as a promise\u000a\u000a See http://goo.gl/4Y4pDk\u000a\u000a".replace("%s", value) + |
|
"From coroutine:\u000a" + |
|
this._stack.split("\n").slice(1, -7).join("\n") |
|
) |
|
); |
|
return; |
|
} |
|
} |
|
maybePromise._then( |
|
this._next, |
|
this._throw, |
|
undefined, |
|
this, |
|
null |
|
); |
|
} |
|
}; |
|
|
|
PromiseSpawn.prototype._throw = function (reason) { |
|
this._promise._attachExtraTrace(reason); |
|
this._promise._pushContext(); |
|
var result = tryCatch(this._generator["throw"]) |
|
.call(this._generator, reason); |
|
this._promise._popContext(); |
|
this._continue(result); |
|
}; |
|
|
|
PromiseSpawn.prototype._next = function (value) { |
|
this._promise._pushContext(); |
|
var result = tryCatch(this._generator.next).call(this._generator, value); |
|
this._promise._popContext(); |
|
this._continue(result); |
|
}; |
|
|
|
Promise.coroutine = function (generatorFunction, options) { |
|
if (typeof generatorFunction !== "function") { |
|
throw new TypeError("generatorFunction must be a function\u000a\u000a See http://goo.gl/6Vqhm0\u000a"); |
|
} |
|
var yieldHandler = Object(options).yieldHandler; |
|
var PromiseSpawn$ = PromiseSpawn; |
|
var stack = new Error().stack; |
|
return function () { |
|
var generator = generatorFunction.apply(this, arguments); |
|
var spawn = new PromiseSpawn$(undefined, undefined, yieldHandler, |
|
stack); |
|
spawn._generator = generator; |
|
spawn._next(undefined); |
|
return spawn.promise(); |
|
}; |
|
}; |
|
|
|
Promise.coroutine.addYieldHandler = function(fn) { |
|
if (typeof fn !== "function") throw new TypeError("fn must be a function\u000a\u000a See http://goo.gl/916lJJ\u000a"); |
|
yieldHandlers.push(fn); |
|
}; |
|
|
|
Promise.spawn = function (generatorFunction) { |
|
if (typeof generatorFunction !== "function") { |
|
return apiRejection("generatorFunction must be a function\u000a\u000a See http://goo.gl/6Vqhm0\u000a"); |
|
} |
|
var spawn = new PromiseSpawn(generatorFunction, this); |
|
var ret = spawn.promise(); |
|
spawn._run(Promise.spawn); |
|
return ret; |
|
}; |
|
}; |
|
|
|
},{"./errors.js":13,"./util.js":38}],18:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
module.exports = |
|
function(Promise, PromiseArray, tryConvertToPromise, INTERNAL) { |
|
var util = _dereq_("./util.js"); |
|
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 caller = function(count) { |
|
var values = []; |
|
for (var i = 1; i <= count; ++i) values.push("holder.p" + i); |
|
return new Function("holder", " \n\ |
|
'use strict'; \n\ |
|
var callback = holder.fn; \n\ |
|
return callback(values); \n\ |
|
".replace(/values/g, values.join(", "))); |
|
}; |
|
var thenCallbacks = []; |
|
var callers = [undefined]; |
|
for (var i = 1; i <= 5; ++i) { |
|
thenCallbacks.push(thenCallback(i)); |
|
callers.push(caller(i)); |
|
} |
|
|
|
var Holder = function(total, fn) { |
|
this.p1 = this.p2 = this.p3 = this.p4 = this.p5 = null; |
|
this.fn = fn; |
|
this.total = total; |
|
this.now = 0; |
|
}; |
|
|
|
Holder.prototype.callers = callers; |
|
Holder.prototype.checkFulfillment = function(promise) { |
|
var now = this.now; |
|
now++; |
|
var total = this.total; |
|
if (now >= total) { |
|
var handler = this.callers[total]; |
|
promise._pushContext(); |
|
var ret = tryCatch(handler)(this); |
|
promise._popContext(); |
|
if (ret === errorObj) { |
|
promise._rejectCallback(ret.e, false, true); |
|
} else { |
|
promise._resolveCallback(ret); |
|
} |
|
} else { |
|
this.now = now; |
|
} |
|
}; |
|
|
|
var 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 < 6 && canEvaluate) { |
|
var ret = new Promise(INTERNAL); |
|
ret._captureStackTrace(); |
|
var holder = new Holder(last, fn); |
|
var callbacks = thenCallbacks; |
|
for (var i = 0; i < last; ++i) { |
|
var maybePromise = tryConvertToPromise(arguments[i], ret); |
|
if (maybePromise instanceof Promise) { |
|
maybePromise = maybePromise._target(); |
|
if (maybePromise._isPending()) { |
|
maybePromise._then(callbacks[i], reject, |
|
undefined, ret, holder); |
|
} else if (maybePromise._isFulfilled()) { |
|
callbacks[i].call(ret, |
|
maybePromise._value(), holder); |
|
} else { |
|
ret._reject(maybePromise._reason()); |
|
} |
|
} else { |
|
callbacks[i].call(ret, maybePromise, holder); |
|
} |
|
} |
|
return ret; |
|
} |
|
} |
|
} |
|
var $_len = arguments.length;var args = new Array($_len); for(var $_i = 0; $_i < $_len; ++$_i) {args[$_i] = arguments[$_i];} |
|
if (fn) args.pop(); |
|
var ret = new PromiseArray(args).promise(); |
|
return fn !== undefined ? ret.spread(fn) : ret; |
|
}; |
|
|
|
}; |
|
|
|
},{"./util.js":38}],19:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
module.exports = function(Promise, |
|
PromiseArray, |
|
apiRejection, |
|
tryConvertToPromise, |
|
INTERNAL) { |
|
var getDomain = Promise._getDomain; |
|
var async = _dereq_("./async.js"); |
|
var util = _dereq_("./util.js"); |
|
var tryCatch = util.tryCatch; |
|
var errorObj = util.errorObj; |
|
var PENDING = {}; |
|
var EMPTY_ARRAY = []; |
|
|
|
function MappingPromiseArray(promises, fn, limit, _filter) { |
|
this.constructor$(promises); |
|
this._promise._captureStackTrace(); |
|
var domain = getDomain(); |
|
this._callback = domain === null ? fn : domain.bind(fn); |
|
this._preservedValues = _filter === INTERNAL |
|
? new Array(this.length()) |
|
: null; |
|
this._limit = limit; |
|
this._inFlight = 0; |
|
this._queue = limit >= 1 ? [] : EMPTY_ARRAY; |
|
async.invoke(init, this, undefined); |
|
} |
|
util.inherits(MappingPromiseArray, PromiseArray); |
|
function init() {this._init$(undefined, -2);} |
|
|
|
MappingPromiseArray.prototype._init = function () {}; |
|
|
|
MappingPromiseArray.prototype._promiseFulfilled = function (value, index) { |
|
var values = this._values; |
|
var length = this.length(); |
|
var preservedValues = this._preservedValues; |
|
var limit = this._limit; |
|
if (values[index] === PENDING) { |
|
values[index] = value; |
|
if (limit >= 1) { |
|
this._inFlight--; |
|
this._drainQueue(); |
|
if (this._isResolved()) return; |
|
} |
|
} else { |
|
if (limit >= 1 && this._inFlight >= limit) { |
|
values[index] = value; |
|
this._queue.push(index); |
|
return; |
|
} |
|
if (preservedValues !== null) preservedValues[index] = value; |
|
|
|
var callback = this._callback; |
|
var receiver = this._promise._boundValue(); |
|
this._promise._pushContext(); |
|
var ret = tryCatch(callback).call(receiver, value, index, length); |
|
this._promise._popContext(); |
|
if (ret === errorObj) return this._reject(ret.e); |
|
|
|
var maybePromise = tryConvertToPromise(ret, this._promise); |
|
if (maybePromise instanceof Promise) { |
|
maybePromise = maybePromise._target(); |
|
if (maybePromise._isPending()) { |
|
if (limit >= 1) this._inFlight++; |
|
values[index] = PENDING; |
|
return maybePromise._proxyPromiseArray(this, index); |
|
} else if (maybePromise._isFulfilled()) { |
|
ret = maybePromise._value(); |
|
} else { |
|
return this._reject(maybePromise._reason()); |
|
} |
|
} |
|
values[index] = ret; |
|
} |
|
var totalResolved = ++this._totalResolved; |
|
if (totalResolved >= length) { |
|
if (preservedValues !== null) { |
|
this._filter(values, preservedValues); |
|
} else { |
|
this._resolve(values); |
|
} |
|
|
|
} |
|
}; |
|
|
|
MappingPromiseArray.prototype._drainQueue = function () { |
|
var queue = this._queue; |
|
var limit = this._limit; |
|
var values = this._values; |
|
while (queue.length > 0 && this._inFlight < limit) { |
|
if (this._isResolved()) return; |
|
var index = queue.pop(); |
|
this._promiseFulfilled(values[index], index); |
|
} |
|
}; |
|
|
|
MappingPromiseArray.prototype._filter = function (booleans, values) { |
|
var len = values.length; |
|
var ret = new Array(len); |
|
var j = 0; |
|
for (var i = 0; i < len; ++i) { |
|
if (booleans[i]) ret[j++] = values[i]; |
|
} |
|
ret.length = j; |
|
this._resolve(ret); |
|
}; |
|
|
|
MappingPromiseArray.prototype.preservedValues = function () { |
|
return this._preservedValues; |
|
}; |
|
|
|
function map(promises, fn, options, _filter) { |
|
var limit = typeof options === "object" && options !== null |
|
? options.concurrency |
|
: 0; |
|
limit = typeof limit === "number" && |
|
isFinite(limit) && limit >= 1 ? limit : 0; |
|
return new MappingPromiseArray(promises, fn, limit, _filter); |
|
} |
|
|
|
Promise.prototype.map = function (fn, options) { |
|
if (typeof fn !== "function") return apiRejection("fn must be a function\u000a\u000a See http://goo.gl/916lJJ\u000a"); |
|
|
|
return map(this, fn, options, null).promise(); |
|
}; |
|
|
|
Promise.map = function (promises, fn, options, _filter) { |
|
if (typeof fn !== "function") return apiRejection("fn must be a function\u000a\u000a See http://goo.gl/916lJJ\u000a"); |
|
return map(promises, fn, options, _filter).promise(); |
|
}; |
|
|
|
|
|
}; |
|
|
|
},{"./async.js":2,"./util.js":38}],20:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
module.exports = |
|
function(Promise, INTERNAL, tryConvertToPromise, apiRejection) { |
|
var util = _dereq_("./util.js"); |
|
var tryCatch = util.tryCatch; |
|
|
|
Promise.method = function (fn) { |
|
if (typeof fn !== "function") { |
|
throw new Promise.TypeError("fn must be a function\u000a\u000a See http://goo.gl/916lJJ\u000a"); |
|
} |
|
return function () { |
|
var ret = new Promise(INTERNAL); |
|
ret._captureStackTrace(); |
|
ret._pushContext(); |
|
var value = tryCatch(fn).apply(this, arguments); |
|
ret._popContext(); |
|
ret._resolveFromSyncValue(value); |
|
return ret; |
|
}; |
|
}; |
|
|
|
Promise.attempt = Promise["try"] = function (fn, args, ctx) { |
|
if (typeof fn !== "function") { |
|
return apiRejection("fn must be a function\u000a\u000a See http://goo.gl/916lJJ\u000a"); |
|
} |
|
var ret = new Promise(INTERNAL); |
|
ret._captureStackTrace(); |
|
ret._pushContext(); |
|
var value = util.isArray(args) |
|
? tryCatch(fn).apply(ctx, args) |
|
: tryCatch(fn).call(ctx, args); |
|
ret._popContext(); |
|
ret._resolveFromSyncValue(value); |
|
return ret; |
|
}; |
|
|
|
Promise.prototype._resolveFromSyncValue = function (value) { |
|
if (value === util.errorObj) { |
|
this._rejectCallback(value.e, false, true); |
|
} else { |
|
this._resolveCallback(value, true); |
|
} |
|
}; |
|
}; |
|
|
|
},{"./util.js":38}],21:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
module.exports = function(Promise) { |
|
var util = _dereq_("./util.js"); |
|
var async = _dereq_("./async.js"); |
|
var tryCatch = util.tryCatch; |
|
var errorObj = util.errorObj; |
|
|
|
function spreadAdapter(val, nodeback) { |
|
var promise = this; |
|
if (!util.isArray(val)) return successAdapter.call(promise, val, nodeback); |
|
var ret = |
|
tryCatch(nodeback).apply(promise._boundValue(), [null].concat(val)); |
|
if (ret === errorObj) { |
|
async.throwLater(ret.e); |
|
} |
|
} |
|
|
|
function successAdapter(val, nodeback) { |
|
var promise = this; |
|
var receiver = promise._boundValue(); |
|
var ret = val === undefined |
|
? tryCatch(nodeback).call(receiver, null) |
|
: tryCatch(nodeback).call(receiver, null, val); |
|
if (ret === errorObj) { |
|
async.throwLater(ret.e); |
|
} |
|
} |
|
function errorAdapter(reason, nodeback) { |
|
var promise = this; |
|
if (!reason) { |
|
var target = promise._target(); |
|
var newReason = target._getCarriedStackTrace(); |
|
newReason.cause = reason; |
|
reason = newReason; |
|
} |
|
var ret = tryCatch(nodeback).call(promise._boundValue(), reason); |
|
if (ret === errorObj) { |
|
async.throwLater(ret.e); |
|
} |
|
} |
|
|
|
Promise.prototype.asCallback = |
|
Promise.prototype.nodeify = function (nodeback, options) { |
|
if (typeof nodeback == "function") { |
|
var adapter = successAdapter; |
|
if (options !== undefined && Object(options).spread) { |
|
adapter = spreadAdapter; |
|
} |
|
this._then( |
|
adapter, |
|
errorAdapter, |
|
undefined, |
|
this, |
|
nodeback |
|
); |
|
} |
|
return this; |
|
}; |
|
}; |
|
|
|
},{"./async.js":2,"./util.js":38}],22:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
module.exports = function(Promise, PromiseArray) { |
|
var util = _dereq_("./util.js"); |
|
var async = _dereq_("./async.js"); |
|
var tryCatch = util.tryCatch; |
|
var errorObj = util.errorObj; |
|
|
|
Promise.prototype.progressed = function (handler) { |
|
return this._then(undefined, undefined, handler, undefined, undefined); |
|
}; |
|
|
|
Promise.prototype._progress = function (progressValue) { |
|
if (this._isFollowingOrFulfilledOrRejected()) return; |
|
this._target()._progressUnchecked(progressValue); |
|
|
|
}; |
|
|
|
Promise.prototype._progressHandlerAt = function (index) { |
|
return index === 0 |
|
? this._progressHandler0 |
|
: this[(index << 2) + index - 5 + 2]; |
|
}; |
|
|
|
Promise.prototype._doProgressWith = function (progression) { |
|
var progressValue = progression.value; |
|
var handler = progression.handler; |
|
var promise = progression.promise; |
|
var receiver = progression.receiver; |
|
|
|
var ret = tryCatch(handler).call(receiver, progressValue); |
|
if (ret === errorObj) { |
|
if (ret.e != null && |
|
ret.e.name !== "StopProgressPropagation") { |
|
var trace = util.canAttachTrace(ret.e) |
|
? ret.e : new Error(util.toString(ret.e)); |
|
promise._attachExtraTrace(trace); |
|
promise._progress(ret.e); |
|
} |
|
} else if (ret instanceof Promise) { |
|
ret._then(promise._progress, null, null, promise, undefined); |
|
} else { |
|
promise._progress(ret); |
|
} |
|
}; |
|
|
|
|
|
Promise.prototype._progressUnchecked = function (progressValue) { |
|
var len = this._length(); |
|
var progress = this._progress; |
|
for (var i = 0; i < len; i++) { |
|
var handler = this._progressHandlerAt(i); |
|
var promise = this._promiseAt(i); |
|
if (!(promise instanceof Promise)) { |
|
var receiver = this._receiverAt(i); |
|
if (typeof handler === "function") { |
|
handler.call(receiver, progressValue, promise); |
|
} else if (receiver instanceof PromiseArray && |
|
!receiver._isResolved()) { |
|
receiver._promiseProgressed(progressValue, promise); |
|
} |
|
continue; |
|
} |
|
|
|
if (typeof handler === "function") { |
|
async.invoke(this._doProgressWith, this, { |
|
handler: handler, |
|
promise: promise, |
|
receiver: this._receiverAt(i), |
|
value: progressValue |
|
}); |
|
} else { |
|
async.invoke(progress, promise, progressValue); |
|
} |
|
} |
|
}; |
|
}; |
|
|
|
},{"./async.js":2,"./util.js":38}],23:[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/LhFpo0\u000a"); |
|
}; |
|
var reflect = function() { |
|
return new Promise.PromiseInspection(this._target()); |
|
}; |
|
var apiRejection = function(msg) { |
|
return Promise.reject(new TypeError(msg)); |
|
}; |
|
|
|
var util = _dereq_("./util.js"); |
|
|
|
var getDomain; |
|
if (util.isNode) { |
|
getDomain = function() { |
|
var ret = process.domain; |
|
if (ret === undefined) ret = null; |
|
return ret; |
|
}; |
|
} else { |
|
getDomain = function() { |
|
return null; |
|
}; |
|
} |
|
util.notEnumerableProp(Promise, "_getDomain", getDomain); |
|
|
|
var UNDEFINED_BINDING = {}; |
|
var async = _dereq_("./async.js"); |
|
var errors = _dereq_("./errors.js"); |
|
var TypeError = Promise.TypeError = errors.TypeError; |
|
Promise.RangeError = errors.RangeError; |
|
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 = {e: null}; |
|
var tryConvertToPromise = _dereq_("./thenables.js")(Promise, INTERNAL); |
|
var PromiseArray = |
|
_dereq_("./promise_array.js")(Promise, INTERNAL, |
|
tryConvertToPromise, apiRejection); |
|
var CapturedTrace = _dereq_("./captured_trace.js")(); |
|
var isDebugging = _dereq_("./debuggability.js")(Promise, CapturedTrace); |
|
/*jshint unused:false*/ |
|
var createContext = |
|
_dereq_("./context.js")(Promise, CapturedTrace, isDebugging); |
|
var CatchFilter = _dereq_("./catch_filter.js")(NEXT_FILTER); |
|
var PromiseResolver = _dereq_("./promise_resolver.js"); |
|
var nodebackForPromise = PromiseResolver._nodebackForPromise; |
|
var errorObj = util.errorObj; |
|
var tryCatch = util.tryCatch; |
|
function Promise(resolver) { |
|
if (typeof resolver !== "function") { |
|
throw new TypeError("the promise constructor requires a resolver function\u000a\u000a See http://goo.gl/EC22Yn\u000a"); |
|
} |
|
if (this.constructor !== Promise) { |
|
throw new TypeError("the promise constructor cannot be invoked directly\u000a\u000a See http://goo.gl/KsIlge\u000a"); |
|
} |
|
this._bitField = 0; |
|
this._fulfillmentHandler0 = undefined; |
|
this._rejectionHandler0 = undefined; |
|
this._progressHandler0 = undefined; |
|
this._promise0 = undefined; |
|
this._receiver0 = undefined; |
|
this._settledValue = undefined; |
|
if (resolver !== INTERNAL) this._resolveFromResolver(resolver); |
|
} |
|
|
|
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 (typeof item === "function") { |
|
catchInstances[j++] = item; |
|
} else { |
|
return Promise.reject( |
|
new TypeError("Catch filter must inherit from Error or be a simple predicate function\u000a\u000a See http://goo.gl/o84o68\u000a")); |
|
} |
|
} |
|
catchInstances.length = j; |
|
fn = arguments[i]; |
|
var catchFilter = new CatchFilter(catchInstances, fn, this); |
|
return this._then(undefined, catchFilter.doFilter, undefined, |
|
catchFilter, undefined); |
|
} |
|
return this._then(undefined, fn, undefined, undefined, undefined); |
|
}; |
|
|
|
Promise.prototype.reflect = function () { |
|
return this._then(reflect, reflect, undefined, this, undefined); |
|
}; |
|
|
|
Promise.prototype.then = function (didFulfill, didReject, didProgress) { |
|
if (isDebugging() && 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, didProgress, |
|
undefined, undefined); |
|
}; |
|
|
|
Promise.prototype.done = function (didFulfill, didReject, didProgress) { |
|
var promise = this._then(didFulfill, didReject, didProgress, |
|
undefined, undefined); |
|
promise._setIsFinal(); |
|
}; |
|
|
|
Promise.prototype.spread = function (didFulfill, didReject) { |
|
return this.all()._then(didFulfill, didReject, undefined, APPLY, undefined); |
|
}; |
|
|
|
Promise.prototype.isCancellable = function () { |
|
return !this.isResolved() && |
|
this._cancellable(); |
|
}; |
|
|
|
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 () { |
|
return new PromiseArray(this).promise(); |
|
}; |
|
|
|
Promise.prototype.error = function (fn) { |
|
return this.caught(util.originatesFromRejection, fn); |
|
}; |
|
|
|
Promise.is = function (val) { |
|
return val instanceof Promise; |
|
}; |
|
|
|
Promise.fromNode = function(fn) { |
|
var ret = new Promise(INTERNAL); |
|
var result = tryCatch(fn)(nodebackForPromise(ret)); |
|
if (result === errorObj) { |
|
ret._rejectCallback(result.e, true, true); |
|
} |
|
return ret; |
|
}; |
|
|
|
Promise.all = function (promises) { |
|
return new PromiseArray(promises).promise(); |
|
}; |
|
|
|
Promise.defer = Promise.pending = function () { |
|
var promise = new Promise(INTERNAL); |
|
return new PromiseResolver(promise); |
|
}; |
|
|
|
Promise.cast = function (obj) { |
|
var ret = tryConvertToPromise(obj); |
|
if (!(ret instanceof Promise)) { |
|
var val = ret; |
|
ret = new Promise(INTERNAL); |
|
ret._fulfillUnchecked(val); |
|
} |
|
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("fn must be a function\u000a\u000a See http://goo.gl/916lJJ\u000a"); |
|
var prev = async._schedule; |
|
async._schedule = fn; |
|
return prev; |
|
}; |
|
|
|
Promise.prototype._then = function ( |
|
didFulfill, |
|
didReject, |
|
didProgress, |
|
receiver, |
|
internalData |
|
) { |
|
var haveInternalData = internalData !== undefined; |
|
var ret = haveInternalData ? internalData : new Promise(INTERNAL); |
|
|
|
if (!haveInternalData) { |
|
ret._propagateFrom(this, 4 | 1); |
|
ret._captureStackTrace(); |
|
} |
|
|
|
var target = this._target(); |
|
if (target !== this) { |
|
if (receiver === undefined) receiver = this._boundTo; |
|
if (!haveInternalData) ret._setIsMigrated(); |
|
} |
|
|
|
var callbackIndex = target._addCallbacks(didFulfill, |
|
didReject, |
|
didProgress, |
|
ret, |
|
receiver, |
|
getDomain()); |
|
|
|
if (target._isResolved() && !target._isSettlePromisesQueued()) { |
|
async.invoke( |
|
target._settlePromiseAtPostResolution, target, callbackIndex); |
|
} |
|
|
|
return ret; |
|
}; |
|
|
|
Promise.prototype._settlePromiseAtPostResolution = function (index) { |
|
if (this._isRejectionUnhandled()) this._unsetRejectionIsUnhandled(); |
|
this._settlePromiseAt(index); |
|
}; |
|
|
|
Promise.prototype._length = function () { |
|
return this._bitField & 131071; |
|
}; |
|
|
|
Promise.prototype._isFollowingOrFulfilledOrRejected = function () { |
|
return (this._bitField & 939524096) > 0; |
|
}; |
|
|
|
Promise.prototype._isFollowing = function () { |
|
return (this._bitField & 536870912) === 536870912; |
|
}; |
|
|
|
Promise.prototype._setLength = function (len) { |
|
this._bitField = (this._bitField & -131072) | |
|
(len & 131071); |
|
}; |
|
|
|
Promise.prototype._setFulfilled = function () { |
|
this._bitField = this._bitField | 268435456; |
|
}; |
|
|
|
Promise.prototype._setRejected = function () { |
|
this._bitField = this._bitField | 134217728; |
|
}; |
|
|
|
Promise.prototype._setFollowing = function () { |
|
this._bitField = this._bitField | 536870912; |
|
}; |
|
|
|
Promise.prototype._setIsFinal = function () { |
|
this._bitField = this._bitField | 33554432; |
|
}; |
|
|
|
Promise.prototype._isFinal = function () { |
|
return (this._bitField & 33554432) > 0; |
|
}; |
|
|
|
Promise.prototype._cancellable = function () { |
|
return (this._bitField & 67108864) > 0; |
|
}; |
|
|
|
Promise.prototype._setCancellable = function () { |
|
this._bitField = this._bitField | 67108864; |
|
}; |
|
|
|
Promise.prototype._unsetCancellable = function () { |
|
this._bitField = this._bitField & (~67108864); |
|
}; |
|
|
|
Promise.prototype._setIsMigrated = function () { |
|
this._bitField = this._bitField | 4194304; |
|
}; |
|
|
|
Promise.prototype._unsetIsMigrated = function () { |
|
this._bitField = this._bitField & (~4194304); |
|
}; |
|
|
|
Promise.prototype._isMigrated = function () { |
|
return (this._bitField & 4194304) > 0; |
|
}; |
|
|
|
Promise.prototype._receiverAt = function (index) { |
|
var ret = index === 0 |
|
? this._receiver0 |
|
: this[ |
|
index * 5 - 5 + 4]; |
|
if (ret === UNDEFINED_BINDING) { |
|
return undefined; |
|
} else if (ret === undefined && this._isBound()) { |
|
return this._boundValue(); |
|
} |
|
return ret; |
|
}; |
|
|
|
Promise.prototype._promiseAt = function (index) { |
|
return index === 0 |
|
? this._promise0 |
|
: this[index * 5 - 5 + 3]; |
|
}; |
|
|
|
Promise.prototype._fulfillmentHandlerAt = function (index) { |
|
return index === 0 |
|
? this._fulfillmentHandler0 |
|
: this[index * 5 - 5 + 0]; |
|
}; |
|
|
|
Promise.prototype._rejectionHandlerAt = function (index) { |
|
return index === 0 |
|
? this._rejectionHandler0 |
|
: this[index * 5 - 5 + 1]; |
|
}; |
|
|
|
Promise.prototype._boundValue = function() { |
|
var ret = this._boundTo; |
|
if (ret !== undefined) { |
|
if (ret instanceof Promise) { |
|
if (ret.isFulfilled()) { |
|
return ret.value(); |
|
} else { |
|
return undefined; |
|
} |
|
} |
|
} |
|
return ret; |
|
}; |
|
|
|
Promise.prototype._migrateCallbacks = function (follower, index) { |
|
var fulfill = follower._fulfillmentHandlerAt(index); |
|
var reject = follower._rejectionHandlerAt(index); |
|
var progress = follower._progressHandlerAt(index); |
|
var promise = follower._promiseAt(index); |
|
var receiver = follower._receiverAt(index); |
|
if (promise instanceof Promise) promise._setIsMigrated(); |
|
if (receiver === undefined) receiver = UNDEFINED_BINDING; |
|
this._addCallbacks(fulfill, reject, progress, promise, receiver, null); |
|
}; |
|
|
|
Promise.prototype._addCallbacks = function ( |
|
fulfill, |
|
reject, |
|
progress, |
|
promise, |
|
receiver, |
|
domain |
|
) { |
|
var index = this._length(); |
|
|
|
if (index >= 131071 - 5) { |
|
index = 0; |
|
this._setLength(0); |
|
} |
|
|
|
if (index === 0) { |
|
this._promise0 = promise; |
|
if (receiver !== undefined) this._receiver0 = receiver; |
|
if (typeof fulfill === "function" && !this._isCarryingStackTrace()) { |
|
this._fulfillmentHandler0 = |
|
domain === null ? fulfill : domain.bind(fulfill); |
|
} |
|
if (typeof reject === "function") { |
|
this._rejectionHandler0 = |
|
domain === null ? reject : domain.bind(reject); |
|
} |
|
if (typeof progress === "function") { |
|
this._progressHandler0 = |
|
domain === null ? progress : domain.bind(progress); |
|
} |
|
} else { |
|
var base = index * 5 - 5; |
|
this[base + 3] = promise; |
|
this[base + 4] = receiver; |
|
if (typeof fulfill === "function") { |
|
this[base + 0] = |
|
domain === null ? fulfill : domain.bind(fulfill); |
|
} |
|
if (typeof reject === "function") { |
|
this[base + 1] = |
|
domain === null ? reject : domain.bind(reject); |
|
} |
|
if (typeof progress === "function") { |
|
this[base + 2] = |
|
domain === null ? progress : domain.bind(progress); |
|
} |
|
} |
|
this._setLength(index + 1); |
|
return index; |
|
}; |
|
|
|
Promise.prototype._setProxyHandlers = function (receiver, promiseSlotValue) { |
|
var index = this._length(); |
|
|
|
if (index >= 131071 - 5) { |
|
index = 0; |
|
this._setLength(0); |
|
} |
|
if (index === 0) { |
|
this._promise0 = promiseSlotValue; |
|
this._receiver0 = receiver; |
|
} else { |
|
var base = index * 5 - 5; |
|
this[base + 3] = promiseSlotValue; |
|
this[base + 4] = receiver; |
|
} |
|
this._setLength(index + 1); |
|
}; |
|
|
|
Promise.prototype._proxyPromiseArray = function (promiseArray, index) { |
|
this._setProxyHandlers(promiseArray, index); |
|
}; |
|
|
|
Promise.prototype._resolveCallback = function(value, shouldBind) { |
|
if (this._isFollowingOrFulfilledOrRejected()) return; |
|
if (value === this) |
|
return this._rejectCallback(makeSelfResolutionError(), false, true); |
|
var maybePromise = tryConvertToPromise(value, this); |
|
if (!(maybePromise instanceof Promise)) return this._fulfill(value); |
|
|
|
var propagationFlags = 1 | (shouldBind ? 4 : 0); |
|
this._propagateFrom(maybePromise, propagationFlags); |
|
var promise = maybePromise._target(); |
|
if (promise._isPending()) { |
|
var len = this._length(); |
|
for (var i = 0; i < len; ++i) { |
|
promise._migrateCallbacks(this, i); |
|
} |
|
this._setFollowing(); |
|
this._setLength(0); |
|
this._setFollowee(promise); |
|
} else if (promise._isFulfilled()) { |
|
this._fulfillUnchecked(promise._value()); |
|
} else { |
|
this._rejectUnchecked(promise._reason(), |
|
promise._getCarriedStackTrace()); |
|
} |
|
}; |
|
|
|
Promise.prototype._rejectCallback = |
|
function(reason, synchronous, shouldNotMarkOriginatingFromRejection) { |
|
if (!shouldNotMarkOriginatingFromRejection) { |
|
util.markAsOriginatingFromRejection(reason); |
|
} |
|
var trace = util.ensureErrorObject(reason); |
|
var hasStack = trace === reason; |
|
this._attachExtraTrace(trace, synchronous ? hasStack : false); |
|
this._reject(reason, hasStack ? undefined : trace); |
|
}; |
|
|
|
Promise.prototype._resolveFromResolver = function (resolver) { |
|
var promise = this; |
|
this._captureStackTrace(); |
|
this._pushContext(); |
|
var synchronous = true; |
|
var r = tryCatch(resolver)(function(value) { |
|
if (promise === null) return; |
|
promise._resolveCallback(value); |
|
promise = null; |
|
}, function (reason) { |
|
if (promise === null) return; |
|
promise._rejectCallback(reason, synchronous); |
|
promise = null; |
|
}); |
|
synchronous = false; |
|
this._popContext(); |
|
|
|
if (r !== undefined && r === errorObj && promise !== null) { |
|
promise._rejectCallback(r.e, true, true); |
|
promise = null; |
|
} |
|
}; |
|
|
|
Promise.prototype._settlePromiseFromHandler = function ( |
|
handler, receiver, value, promise |
|
) { |
|
if (promise._isRejected()) return; |
|
promise._pushContext(); |
|
var x; |
|
if (receiver === APPLY && !this._isRejected()) { |
|
x = tryCatch(handler).apply(this._boundValue(), value); |
|
} else { |
|
x = tryCatch(handler).call(receiver, value); |
|
} |
|
promise._popContext(); |
|
|
|
if (x === errorObj || x === promise || x === NEXT_FILTER) { |
|
var err = x === promise ? makeSelfResolutionError() : x.e; |
|
promise._rejectCallback(err, false, true); |
|
} else { |
|
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._cleanValues = function () { |
|
if (this._cancellable()) { |
|
this._cancellationParent = undefined; |
|
} |
|
}; |
|
|
|
Promise.prototype._propagateFrom = function (parent, flags) { |
|
if ((flags & 1) > 0 && parent._cancellable()) { |
|
this._setCancellable(); |
|
this._cancellationParent = parent; |
|
} |
|
if ((flags & 4) > 0 && parent._isBound()) { |
|
this._setBoundTo(parent._boundTo); |
|
} |
|
}; |
|
|
|
Promise.prototype._fulfill = function (value) { |
|
if (this._isFollowingOrFulfilledOrRejected()) return; |
|
this._fulfillUnchecked(value); |
|
}; |
|
|
|
Promise.prototype._reject = function (reason, carriedStackTrace) { |
|
if (this._isFollowingOrFulfilledOrRejected()) return; |
|
this._rejectUnchecked(reason, carriedStackTrace); |
|
}; |
|
|
|
Promise.prototype._settlePromiseAt = function (index) { |
|
var promise = this._promiseAt(index); |
|
var isPromise = promise instanceof Promise; |
|
|
|
if (isPromise && promise._isMigrated()) { |
|
promise._unsetIsMigrated(); |
|
return async.invoke(this._settlePromiseAt, this, index); |
|
} |
|
var handler = this._isFulfilled() |
|
? this._fulfillmentHandlerAt(index) |
|
: this._rejectionHandlerAt(index); |
|
|
|
var carriedStackTrace = |
|
this._isCarryingStackTrace() ? this._getCarriedStackTrace() : undefined; |
|
var value = this._settledValue; |
|
var receiver = this._receiverAt(index); |
|
this._clearCallbackDataAtIndex(index); |
|
|
|
if (typeof handler === "function") { |
|
if (!isPromise) { |
|
handler.call(receiver, value, promise); |
|
} else { |
|
this._settlePromiseFromHandler(handler, receiver, value, promise); |
|
} |
|
} else if (receiver instanceof PromiseArray) { |
|
if (!receiver._isResolved()) { |
|
if (this._isFulfilled()) { |
|
receiver._promiseFulfilled(value, promise); |
|
} |
|
else { |
|
receiver._promiseRejected(value, promise); |
|
} |
|
} |
|
} else if (isPromise) { |
|
if (this._isFulfilled()) { |
|
promise._fulfill(value); |
|
} else { |
|
promise._reject(value, carriedStackTrace); |
|
} |
|
} |
|
|
|
if (index >= 4 && (index & 31) === 4) |
|
async.invokeLater(this._setLength, this, 0); |
|
}; |
|
|
|
Promise.prototype._clearCallbackDataAtIndex = function(index) { |
|
if (index === 0) { |
|
if (!this._isCarryingStackTrace()) { |
|
this._fulfillmentHandler0 = undefined; |
|
} |
|
this._rejectionHandler0 = |
|
this._progressHandler0 = |
|
this._receiver0 = |
|
this._promise0 = undefined; |
|
} else { |
|
var base = index * 5 - 5; |
|
this[base + 3] = |
|
this[base + 4] = |
|
this[base + 0] = |
|
this[base + 1] = |
|
this[base + 2] = undefined; |
|
} |
|
}; |
|
|
|
Promise.prototype._isSettlePromisesQueued = function () { |
|
return (this._bitField & |
|
-1073741824) === -1073741824; |
|
}; |
|
|
|
Promise.prototype._setSettlePromisesQueued = function () { |
|
this._bitField = this._bitField | -1073741824; |
|
}; |
|
|
|
Promise.prototype._unsetSettlePromisesQueued = function () { |
|
this._bitField = this._bitField & (~-1073741824); |
|
}; |
|
|
|
Promise.prototype._queueSettlePromises = function() { |
|
async.settlePromises(this); |
|
this._setSettlePromisesQueued(); |
|
}; |
|
|
|
Promise.prototype._fulfillUnchecked = function (value) { |
|
if (value === this) { |
|
var err = makeSelfResolutionError(); |
|
this._attachExtraTrace(err); |
|
return this._rejectUnchecked(err, undefined); |
|
} |
|
this._setFulfilled(); |
|
this._settledValue = value; |
|
this._cleanValues(); |
|
|
|
if (this._length() > 0) { |
|
this._queueSettlePromises(); |
|
} |
|
}; |
|
|
|
Promise.prototype._rejectUncheckedCheckError = function (reason) { |
|
var trace = util.ensureErrorObject(reason); |
|
this._rejectUnchecked(reason, trace === reason ? undefined : trace); |
|
}; |
|
|
|
Promise.prototype._rejectUnchecked = function (reason, trace) { |
|
if (reason === this) { |
|
var err = makeSelfResolutionError(); |
|
this._attachExtraTrace(err); |
|
return this._rejectUnchecked(err); |
|
} |
|
this._setRejected(); |
|
this._settledValue = reason; |
|
this._cleanValues(); |
|
|
|
if (this._isFinal()) { |
|
async.throwLater(function(e) { |
|
if ("stack" in e) { |
|
async.invokeFirst( |
|
CapturedTrace.unhandledRejection, undefined, e); |
|
} |
|
throw e; |
|
}, trace === undefined ? reason : trace); |
|
return; |
|
} |
|
|
|
if (trace !== undefined && trace !== reason) { |
|
this._setCarriedStackTrace(trace); |
|
} |
|
|
|
if (this._length() > 0) { |
|
this._queueSettlePromises(); |
|
} else { |
|
this._ensurePossibleRejectionHandled(); |
|
} |
|
}; |
|
|
|
Promise.prototype._settlePromises = function () { |
|
this._unsetSettlePromisesQueued(); |
|
var len = this._length(); |
|
for (var i = 0; i < len; i++) { |
|
this._settlePromiseAt(i); |
|
} |
|
}; |
|
|
|
util.notEnumerableProp(Promise, |
|
"_makeSelfResolutionError", |
|
makeSelfResolutionError); |
|
|
|
_dereq_("./progress.js")(Promise, PromiseArray); |
|
_dereq_("./method.js")(Promise, INTERNAL, tryConvertToPromise, apiRejection); |
|
_dereq_("./bind.js")(Promise, INTERNAL, tryConvertToPromise); |
|
_dereq_("./finally.js")(Promise, NEXT_FILTER, tryConvertToPromise); |
|
_dereq_("./direct_resolve.js")(Promise); |
|
_dereq_("./synchronous_inspection.js")(Promise); |
|
_dereq_("./join.js")(Promise, PromiseArray, tryConvertToPromise, INTERNAL); |
|
Promise.Promise = Promise; |
|
_dereq_('./map.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL); |
|
_dereq_('./cancel.js')(Promise); |
|
_dereq_('./using.js')(Promise, apiRejection, tryConvertToPromise, createContext); |
|
_dereq_('./generators.js')(Promise, apiRejection, INTERNAL, tryConvertToPromise); |
|
_dereq_('./nodeify.js')(Promise); |
|
_dereq_('./call_get.js')(Promise); |
|
_dereq_('./props.js')(Promise, PromiseArray, tryConvertToPromise, apiRejection); |
|
_dereq_('./race.js')(Promise, INTERNAL, tryConvertToPromise, apiRejection); |
|
_dereq_('./reduce.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL); |
|
_dereq_('./settle.js')(Promise, PromiseArray); |
|
_dereq_('./some.js')(Promise, PromiseArray, apiRejection); |
|
_dereq_('./promisify.js')(Promise, INTERNAL); |
|
_dereq_('./any.js')(Promise); |
|
_dereq_('./each.js')(Promise, INTERNAL); |
|
_dereq_('./timers.js')(Promise, INTERNAL); |
|
_dereq_('./filter.js')(Promise, INTERNAL); |
|
|
|
util.toFastProperties(Promise); |
|
util.toFastProperties(Promise.prototype); |
|
function fillTypes(value) { |
|
var p = new Promise(INTERNAL); |
|
p._fulfillmentHandler0 = value; |
|
p._rejectionHandler0 = value; |
|
p._progressHandler0 = value; |
|
p._promise0 = value; |
|
p._receiver0 = value; |
|
p._settledValue = 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)); |
|
CapturedTrace.setBounds(async.firstLineError, util.lastLineError); |
|
return Promise; |
|
|
|
}; |
|
|
|
},{"./any.js":1,"./async.js":2,"./bind.js":3,"./call_get.js":5,"./cancel.js":6,"./captured_trace.js":7,"./catch_filter.js":8,"./context.js":9,"./debuggability.js":10,"./direct_resolve.js":11,"./each.js":12,"./errors.js":13,"./filter.js":15,"./finally.js":16,"./generators.js":17,"./join.js":18,"./map.js":19,"./method.js":20,"./nodeify.js":21,"./progress.js":22,"./promise_array.js":24,"./promise_resolver.js":25,"./promisify.js":26,"./props.js":27,"./race.js":29,"./reduce.js":30,"./settle.js":32,"./some.js":33,"./synchronous_inspection.js":34,"./thenables.js":35,"./timers.js":36,"./using.js":37,"./util.js":38}],24:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
module.exports = function(Promise, INTERNAL, tryConvertToPromise, |
|
apiRejection) { |
|
var util = _dereq_("./util.js"); |
|
var isArray = util.isArray; |
|
|
|
function toResolutionValue(val) { |
|
switch(val) { |
|
case -2: return []; |
|
case -3: return {}; |
|
} |
|
} |
|
|
|
function PromiseArray(values) { |
|
var promise = this._promise = new Promise(INTERNAL); |
|
var parent; |
|
if (values instanceof Promise) { |
|
parent = values; |
|
promise._propagateFrom(parent, 1 | 4); |
|
} |
|
this._values = values; |
|
this._length = 0; |
|
this._totalResolved = 0; |
|
this._init(undefined, -2); |
|
} |
|
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(); |
|
this._values = values; |
|
if (values._isFulfilled()) { |
|
values = values._value(); |
|
if (!isArray(values)) { |
|
var err = new Promise.TypeError("expecting an array, a promise or a thenable\u000a\u000a See http://goo.gl/s8MMhc\u000a"); |
|
this.__hardReject__(err); |
|
return; |
|
} |
|
} else if (values._isPending()) { |
|
values._then( |
|
init, |
|
this._reject, |
|
undefined, |
|
this, |
|
resolveValueIfEmpty |
|
); |
|
return; |
|
} else { |
|
this._reject(values._reason()); |
|
return; |
|
} |
|
} else if (!isArray(values)) { |
|
this._promise._reject(apiRejection("expecting an array, a promise or a thenable\u000a\u000a See http://goo.gl/s8MMhc\u000a")._reason()); |
|
return; |
|
} |
|
|
|
if (values.length === 0) { |
|
if (resolveValueIfEmpty === -5) { |
|
this._resolveEmptyArray(); |
|
} |
|
else { |
|
this._resolve(toResolutionValue(resolveValueIfEmpty)); |
|
} |
|
return; |
|
} |
|
var len = this.getActualLength(values.length); |
|
this._length = len; |
|
this._values = this.shouldCopyValues() ? new Array(len) : this._values; |
|
var promise = this._promise; |
|
for (var i = 0; i < len; ++i) { |
|
var isResolved = this._isResolved(); |
|
var maybePromise = tryConvertToPromise(values[i], promise); |
|
if (maybePromise instanceof Promise) { |
|
maybePromise = maybePromise._target(); |
|
if (isResolved) { |
|
maybePromise._ignoreRejections(); |
|
} else if (maybePromise._isPending()) { |
|
maybePromise._proxyPromiseArray(this, i); |
|
} else if (maybePromise._isFulfilled()) { |
|
this._promiseFulfilled(maybePromise._value(), i); |
|
} else { |
|
this._promiseRejected(maybePromise._reason(), i); |
|
} |
|
} else if (!isResolved) { |
|
this._promiseFulfilled(maybePromise, i); |
|
} |
|
} |
|
}; |
|
|
|
PromiseArray.prototype._isResolved = function () { |
|
return this._values === null; |
|
}; |
|
|
|
PromiseArray.prototype._resolve = function (value) { |
|
this._values = null; |
|
this._promise._fulfill(value); |
|
}; |
|
|
|
PromiseArray.prototype.__hardReject__ = |
|
PromiseArray.prototype._reject = function (reason) { |
|
this._values = null; |
|
this._promise._rejectCallback(reason, false, true); |
|
}; |
|
|
|
PromiseArray.prototype._promiseProgressed = function (progressValue, index) { |
|
this._promise._progress({ |
|
index: index, |
|
value: progressValue |
|
}); |
|
}; |
|
|
|
|
|
PromiseArray.prototype._promiseFulfilled = function (value, index) { |
|
this._values[index] = value; |
|
var totalResolved = ++this._totalResolved; |
|
if (totalResolved >= this._length) { |
|
this._resolve(this._values); |
|
} |
|
}; |
|
|
|
PromiseArray.prototype._promiseRejected = function (reason, index) { |
|
this._totalResolved++; |
|
this._reject(reason); |
|
}; |
|
|
|
PromiseArray.prototype.shouldCopyValues = function () { |
|
return true; |
|
}; |
|
|
|
PromiseArray.prototype.getActualLength = function (len) { |
|
return len; |
|
}; |
|
|
|
return PromiseArray; |
|
}; |
|
|
|
},{"./util.js":38}],25:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
var util = _dereq_("./util.js"); |
|
var maybeWrapAsError = util.maybeWrapAsError; |
|
var errors = _dereq_("./errors.js"); |
|
var TimeoutError = errors.TimeoutError; |
|
var OperationalError = errors.OperationalError; |
|
var haveGetters = util.haveGetters; |
|
var es5 = _dereq_("./es5.js"); |
|
|
|
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) { |
|
return function(err, value) { |
|
if (promise === null) return; |
|
|
|
if (err) { |
|
var wrapped = wrapAsOperationalError(maybeWrapAsError(err)); |
|
promise._attachExtraTrace(wrapped); |
|
promise._reject(wrapped); |
|
} else if (arguments.length > 2) { |
|
var $_len = arguments.length;var args = new Array($_len - 1); for(var $_i = 1; $_i < $_len; ++$_i) {args[$_i - 1] = arguments[$_i];} |
|
promise._fulfill(args); |
|
} else { |
|
promise._fulfill(value); |
|
} |
|
|
|
promise = null; |
|
}; |
|
} |
|
|
|
|
|
var PromiseResolver; |
|
if (!haveGetters) { |
|
PromiseResolver = function (promise) { |
|
this.promise = promise; |
|
this.asCallback = nodebackForPromise(promise); |
|
this.callback = this.asCallback; |
|
}; |
|
} |
|
else { |
|
PromiseResolver = function (promise) { |
|
this.promise = promise; |
|
}; |
|
} |
|
if (haveGetters) { |
|
var prop = { |
|
get: function() { |
|
return nodebackForPromise(this.promise); |
|
} |
|
}; |
|
es5.defineProperty(PromiseResolver.prototype, "asCallback", prop); |
|
es5.defineProperty(PromiseResolver.prototype, "callback", prop); |
|
} |
|
|
|
PromiseResolver._nodebackForPromise = nodebackForPromise; |
|
|
|
PromiseResolver.prototype.toString = function () { |
|
return "[object PromiseResolver]"; |
|
}; |
|
|
|
PromiseResolver.prototype.resolve = |
|
PromiseResolver.prototype.fulfill = function (value) { |
|
if (!(this instanceof PromiseResolver)) { |
|
throw new TypeError("Illegal invocation, resolver resolve/reject must be called within a resolver context. Consider using the promise constructor instead.\u000a\u000a See http://goo.gl/sdkXL9\u000a"); |
|
} |
|
this.promise._resolveCallback(value); |
|
}; |
|
|
|
PromiseResolver.prototype.reject = function (reason) { |
|
if (!(this instanceof PromiseResolver)) { |
|
throw new TypeError("Illegal invocation, resolver resolve/reject must be called within a resolver context. Consider using the promise constructor instead.\u000a\u000a See http://goo.gl/sdkXL9\u000a"); |
|
} |
|
this.promise._rejectCallback(reason); |
|
}; |
|
|
|
PromiseResolver.prototype.progress = function (value) { |
|
if (!(this instanceof PromiseResolver)) { |
|
throw new TypeError("Illegal invocation, resolver resolve/reject must be called within a resolver context. Consider using the promise constructor instead.\u000a\u000a See http://goo.gl/sdkXL9\u000a"); |
|
} |
|
this.promise._progress(value); |
|
}; |
|
|
|
PromiseResolver.prototype.cancel = function (err) { |
|
this.promise.cancel(err); |
|
}; |
|
|
|
PromiseResolver.prototype.timeout = function () { |
|
this.reject(new TimeoutError("timeout")); |
|
}; |
|
|
|
PromiseResolver.prototype.isResolved = function () { |
|
return this.promise.isResolved(); |
|
}; |
|
|
|
PromiseResolver.prototype.toJSON = function () { |
|
return this.promise.toJSON(); |
|
}; |
|
|
|
module.exports = PromiseResolver; |
|
|
|
},{"./errors.js":13,"./es5.js":14,"./util.js":38}],26:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
module.exports = function(Promise, INTERNAL) { |
|
var THIS = {}; |
|
var util = _dereq_("./util.js"); |
|
var nodebackForPromise = _dereq_("./promise_resolver.js") |
|
._nodebackForPromise; |
|
var withAppended = util.withAppended; |
|
var maybeWrapAsError = util.maybeWrapAsError; |
|
var canEvaluate = util.canEvaluate; |
|
var TypeError = _dereq_("./errors").TypeError; |
|
var defaultSuffix = "Async"; |
|
var defaultPromisified = {__isPromisified__: true}; |
|
var noCopyProps = [ |
|
"arity", "length", |
|
"name", |
|
"arguments", |
|
"caller", |
|
"callee", |
|
"prototype", |
|
"__isPromisified__" |
|
]; |
|
var noCopyPropsPattern = new RegExp("^(?:" + noCopyProps.join("|") + ")$"); |
|
|
|
var defaultFilter = function(name) { |
|
return util.isIdentifier(name) && |
|
name.charAt(0) !== "_" && |
|
name !== "constructor"; |
|
}; |
|
|
|
function propsFilter(key) { |
|
return !noCopyPropsPattern.test(key); |
|
} |
|
|
|
function isPromisified(fn) { |
|
try { |
|
return fn.__isPromisified__ === true; |
|
} |
|
catch (e) { |
|
return false; |
|
} |
|
} |
|
|
|
function hasPromisified(obj, key, suffix) { |
|
var val = util.getDataPropertyOrDefault(obj, key + suffix, |
|
defaultPromisified); |
|
return val ? isPromisified(val) : false; |
|
} |
|
function checkValid(ret, suffix, suffixRegexp) { |
|
for (var i = 0; i < ret.length; i += 2) { |
|
var key = ret[i]; |
|
if (suffixRegexp.test(key)) { |
|
var keyWithoutAsyncSuffix = key.replace(suffixRegexp, ""); |
|
for (var j = 0; j < ret.length; j += 2) { |
|
if (ret[j] === keyWithoutAsyncSuffix) { |
|
throw new TypeError("Cannot promisify an API that has normal methods with '%s'-suffix\u000a\u000a See http://goo.gl/iWrZbw\u000a" |
|
.replace("%s", suffix)); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
function promisifiableMethods(obj, suffix, suffixRegexp, filter) { |
|
var keys = util.inheritedDataKeys(obj); |
|
var ret = []; |
|
for (var i = 0; i < keys.length; ++i) { |
|
var key = keys[i]; |
|
var value = obj[key]; |
|
var passesDefaultFilter = filter === defaultFilter |
|
? true : defaultFilter(key, value, obj); |
|
if (typeof value === "function" && |
|
!isPromisified(value) && |
|
!hasPromisified(obj, key, suffix) && |
|
filter(key, value, obj, passesDefaultFilter)) { |
|
ret.push(key, value); |
|
} |
|
} |
|
checkValid(ret, suffix, suffixRegexp); |
|
return ret; |
|
} |
|
|
|
var escapeIdentRegex = function(str) { |
|
return str.replace(/([$])/, "\\$"); |
|
}; |
|
|
|
var makeNodePromisifiedEval; |
|
if (!true) { |
|
var switchCaseArgumentOrder = function(likelyArgumentCount) { |
|
var ret = [likelyArgumentCount]; |
|
var min = Math.max(0, likelyArgumentCount - 1 - 3); |
|
for(var i = likelyArgumentCount - 1; i >= min; --i) { |
|
ret.push(i); |
|
} |
|
for(var i = likelyArgumentCount + 1; i <= 3; ++i) { |
|
ret.push(i); |
|
} |
|
return ret; |
|
}; |
|
|
|
var argumentSequence = function(argumentCount) { |
|
return util.filledRange(argumentCount, "_arg", ""); |
|
}; |
|
|
|
var parameterDeclaration = function(parameterCount) { |
|
return util.filledRange( |
|
Math.max(parameterCount, 3), "_arg", ""); |
|
}; |
|
|
|
var parameterCount = function(fn) { |
|
if (typeof fn.length === "number") { |
|
return Math.max(Math.min(fn.length, 1023 + 1), 0); |
|
} |
|
return 0; |
|
}; |
|
|
|
makeNodePromisifiedEval = |
|
function(callback, receiver, originalName, fn) { |
|
var newParameterCount = Math.max(0, parameterCount(fn) - 1); |
|
var argumentOrder = switchCaseArgumentOrder(newParameterCount); |
|
var shouldProxyThis = typeof callback === "string" || receiver === THIS; |
|
|
|
function generateCallForArgumentCount(count) { |
|
var args = argumentSequence(count).join(", "); |
|
var comma = count > 0 ? ", " : ""; |
|
var ret; |
|
if (shouldProxyThis) { |
|
ret = "ret = callback.call(this, {{args}}, nodeback); break;\n"; |
|
} else { |
|
ret = receiver === undefined |
|
? "ret = callback({{args}}, nodeback); break;\n" |
|
: "ret = callback.call(receiver, {{args}}, nodeback); break;\n"; |
|
} |
|
return ret.replace("{{args}}", args).replace(", ", comma); |
|
} |
|
|
|
function generateArgumentSwitchCase() { |
|
var ret = ""; |
|
for (var i = 0; i < argumentOrder.length; ++i) { |
|
ret += "case " + argumentOrder[i] +":" + |
|
generateCallForArgumentCount(argumentOrder[i]); |
|
} |
|
|
|
ret += " \n\ |
|
default: \n\ |
|
var args = new Array(len + 1); \n\ |
|
var i = 0; \n\ |
|
for (var i = 0; i < len; ++i) { \n\ |
|
args[i] = arguments[i]; \n\ |
|
} \n\ |
|
args[i] = nodeback; \n\ |
|
[CodeForCall] \n\ |
|
break; \n\ |
|
".replace("[CodeForCall]", (shouldProxyThis |
|
? "ret = callback.apply(this, args);\n" |
|
: "ret = callback.apply(receiver, args);\n")); |
|
return ret; |
|
} |
|
|
|
var getFunctionCode = typeof callback === "string" |
|
? ("this != null ? this['"+callback+"'] : fn") |
|
: "fn"; |
|
|
|
return new Function("Promise", |
|
"fn", |
|
"receiver", |
|
"withAppended", |
|
"maybeWrapAsError", |
|
"nodebackForPromise", |
|
"tryCatch", |
|
"errorObj", |
|
"notEnumerableProp", |
|
"INTERNAL","'use strict'; \n\ |
|
var ret = function (Parameters) { \n\ |
|
'use strict'; \n\ |
|
var len = arguments.length; \n\ |
|
var promise = new Promise(INTERNAL); \n\ |
|
promise._captureStackTrace(); \n\ |
|
var nodeback = nodebackForPromise(promise); \n\ |
|
var ret; \n\ |
|
var callback = tryCatch([GetFunctionCode]); \n\ |
|
switch(len) { \n\ |
|
[CodeForSwitchCase] \n\ |
|
} \n\ |
|
if (ret === errorObj) { \n\ |
|
promise._rejectCallback(maybeWrapAsError(ret.e), true, true);\n\ |
|
} \n\ |
|
return promise; \n\ |
|
}; \n\ |
|
notEnumerableProp(ret, '__isPromisified__', true); \n\ |
|
return ret; \n\ |
|
" |
|
.replace("Parameters", parameterDeclaration(newParameterCount)) |
|
.replace("[CodeForSwitchCase]", generateArgumentSwitchCase()) |
|
.replace("[GetFunctionCode]", getFunctionCode))( |
|
Promise, |
|
fn, |
|
receiver, |
|
withAppended, |
|
maybeWrapAsError, |
|
nodebackForPromise, |
|
util.tryCatch, |
|
util.errorObj, |
|
util.notEnumerableProp, |
|
INTERNAL |
|
); |
|
}; |
|
} |
|
|
|
function makeNodePromisifiedClosure(callback, receiver, _, fn) { |
|
var defaultThis = (function() {return this;})(); |
|
var method = callback; |
|
if (typeof method === "string") { |
|
callback = fn; |
|
} |
|
function promisified() { |
|
var _receiver = receiver; |
|
if (receiver === THIS) _receiver = this; |
|
var promise = new Promise(INTERNAL); |
|
promise._captureStackTrace(); |
|
var cb = typeof method === "string" && this !== defaultThis |
|
? this[method] : callback; |
|
var fn = nodebackForPromise(promise); |
|
try { |
|
cb.apply(_receiver, withAppended(arguments, fn)); |
|
} catch(e) { |
|
promise._rejectCallback(maybeWrapAsError(e), true, true); |
|
} |
|
return promise; |
|
} |
|
util.notEnumerableProp(promisified, "__isPromisified__", true); |
|
return promisified; |
|
} |
|
|
|
var makeNodePromisified = canEvaluate |
|
? makeNodePromisifiedEval |
|
: makeNodePromisifiedClosure; |
|
|
|
function promisifyAll(obj, suffix, filter, promisifier) { |
|
var suffixRegexp = new RegExp(escapeIdentRegex(suffix) + "$"); |
|
var methods = |
|
promisifiableMethods(obj, suffix, suffixRegexp, filter); |
|
|
|
for (var i = 0, len = methods.length; i < len; i+= 2) { |
|
var key = methods[i]; |
|
var fn = methods[i+1]; |
|
var promisifiedKey = key + suffix; |
|
if (promisifier === makeNodePromisified) { |
|
obj[promisifiedKey] = |
|
makeNodePromisified(key, THIS, key, fn, suffix); |
|
} else { |
|
var promisified = promisifier(fn, function() { |
|
return makeNodePromisified(key, THIS, key, fn, suffix); |
|
}); |
|
util.notEnumerableProp(promisified, "__isPromisified__", true); |
|
obj[promisifiedKey] = promisified; |
|
} |
|
} |
|
util.toFastProperties(obj); |
|
return obj; |
|
} |
|
|
|
function promisify(callback, receiver) { |
|
return makeNodePromisified(callback, receiver, undefined, callback); |
|
} |
|
|
|
Promise.promisify = function (fn, receiver) { |
|
if (typeof fn !== "function") { |
|
throw new TypeError("fn must be a function\u000a\u000a See http://goo.gl/916lJJ\u000a"); |
|
} |
|
if (isPromisified(fn)) { |
|
return fn; |
|
} |
|
var ret = promisify(fn, arguments.length < 2 ? THIS : receiver); |
|
util.copyDescriptors(fn, ret, propsFilter); |
|
return ret; |
|
}; |
|
|
|
Promise.promisifyAll = function (target, options) { |
|
if (typeof target !== "function" && typeof target !== "object") { |
|
throw new TypeError("the target of promisifyAll must be an object or a function\u000a\u000a See http://goo.gl/9ITlV0\u000a"); |
|
} |
|
options = Object(options); |
|
var suffix = options.suffix; |
|
if (typeof suffix !== "string") suffix = defaultSuffix; |
|
var filter = options.filter; |
|
if (typeof filter !== "function") filter = defaultFilter; |
|
var promisifier = options.promisifier; |
|
if (typeof promisifier !== "function") promisifier = makeNodePromisified; |
|
|
|
if (!util.isIdentifier(suffix)) { |
|
throw new RangeError("suffix must be a valid identifier\u000a\u000a See http://goo.gl/8FZo5V\u000a"); |
|
} |
|
|
|
var keys = util.inheritedDataKeys(target); |
|
for (var i = 0; i < keys.length; ++i) { |
|
var value = target[keys[i]]; |
|
if (keys[i] !== "constructor" && |
|
util.isClass(value)) { |
|
promisifyAll(value.prototype, suffix, filter, promisifier); |
|
promisifyAll(value, suffix, filter, promisifier); |
|
} |
|
} |
|
|
|
return promisifyAll(target, suffix, filter, promisifier); |
|
}; |
|
}; |
|
|
|
|
|
},{"./errors":13,"./promise_resolver.js":25,"./util.js":38}],27:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
module.exports = function( |
|
Promise, PromiseArray, tryConvertToPromise, apiRejection) { |
|
var util = _dereq_("./util.js"); |
|
var isObject = util.isObject; |
|
var es5 = _dereq_("./es5.js"); |
|
|
|
function PropertiesPromiseArray(obj) { |
|
var keys = es5.keys(obj); |
|
var len = keys.length; |
|
var values = new Array(len * 2); |
|
for (var i = 0; i < len; ++i) { |
|
var key = keys[i]; |
|
values[i] = obj[key]; |
|
values[i + len] = key; |
|
} |
|
this.constructor$(values); |
|
} |
|
util.inherits(PropertiesPromiseArray, PromiseArray); |
|
|
|
PropertiesPromiseArray.prototype._init = function () { |
|
this._init$(undefined, -3) ; |
|
}; |
|
|
|
PropertiesPromiseArray.prototype._promiseFulfilled = function (value, index) { |
|
this._values[index] = value; |
|
var totalResolved = ++this._totalResolved; |
|
if (totalResolved >= this._length) { |
|
var val = {}; |
|
var keyOffset = this.length(); |
|
for (var i = 0, len = this.length(); i < len; ++i) { |
|
val[this._values[i + keyOffset]] = this._values[i]; |
|
} |
|
this._resolve(val); |
|
} |
|
}; |
|
|
|
PropertiesPromiseArray.prototype._promiseProgressed = function (value, index) { |
|
this._promise._progress({ |
|
key: this._values[index + this.length()], |
|
value: value |
|
}); |
|
}; |
|
|
|
PropertiesPromiseArray.prototype.shouldCopyValues = function () { |
|
return false; |
|
}; |
|
|
|
PropertiesPromiseArray.prototype.getActualLength = function (len) { |
|
return len >> 1; |
|
}; |
|
|
|
function props(promises) { |
|
var ret; |
|
var castValue = tryConvertToPromise(promises); |
|
|
|
if (!isObject(castValue)) { |
|
return apiRejection("cannot await properties of a non-object\u000a\u000a See http://goo.gl/OsFKC8\u000a"); |
|
} else if (castValue instanceof Promise) { |
|
ret = castValue._then( |
|
Promise.props, undefined, undefined, undefined, undefined); |
|
} else { |
|
ret = new PropertiesPromiseArray(castValue).promise(); |
|
} |
|
|
|
if (castValue instanceof Promise) { |
|
ret._propagateFrom(castValue, 4); |
|
} |
|
return ret; |
|
} |
|
|
|
Promise.prototype.props = function () { |
|
return props(this); |
|
}; |
|
|
|
Promise.props = function (promises) { |
|
return props(promises); |
|
}; |
|
}; |
|
|
|
},{"./es5.js":14,"./util.js":38}],28:[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._unshiftOne = function(value) { |
|
var capacity = this._capacity; |
|
this._checkCapacity(this.length() + 1); |
|
var front = this._front; |
|
var i = (((( front - 1 ) & |
|
( capacity - 1) ) ^ capacity ) - capacity ); |
|
this[i] = value; |
|
this._front = i; |
|
this._length = this.length() + 1; |
|
}; |
|
|
|
Queue.prototype.unshift = function(fn, receiver, arg) { |
|
this._unshiftOne(arg); |
|
this._unshiftOne(receiver); |
|
this._unshiftOne(fn); |
|
}; |
|
|
|
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; |
|
|
|
},{}],29:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
module.exports = function( |
|
Promise, INTERNAL, tryConvertToPromise, apiRejection) { |
|
var isArray = _dereq_("./util.js").isArray; |
|
|
|
var raceLater = function (promise) { |
|
return promise.then(function(array) { |
|
return race(array, promise); |
|
}); |
|
}; |
|
|
|
function race(promises, parent) { |
|
var maybePromise = tryConvertToPromise(promises); |
|
|
|
if (maybePromise instanceof Promise) { |
|
return raceLater(maybePromise); |
|
} else if (!isArray(promises)) { |
|
return apiRejection("expecting an array, a promise or a thenable\u000a\u000a See http://goo.gl/s8MMhc\u000a"); |
|
} |
|
|
|
var ret = new Promise(INTERNAL); |
|
if (parent !== undefined) { |
|
ret._propagateFrom(parent, 4 | 1); |
|
} |
|
var fulfill = ret._fulfill; |
|
var reject = ret._reject; |
|
for (var i = 0, len = promises.length; i < len; ++i) { |
|
var val = promises[i]; |
|
|
|
if (val === undefined && !(i in promises)) { |
|
continue; |
|
} |
|
|
|
Promise.cast(val)._then(fulfill, reject, undefined, ret, null); |
|
} |
|
return ret; |
|
} |
|
|
|
Promise.race = function (promises) { |
|
return race(promises, undefined); |
|
}; |
|
|
|
Promise.prototype.race = function () { |
|
return race(this, undefined); |
|
}; |
|
|
|
}; |
|
|
|
},{"./util.js":38}],30:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
module.exports = function(Promise, |
|
PromiseArray, |
|
apiRejection, |
|
tryConvertToPromise, |
|
INTERNAL) { |
|
var getDomain = Promise._getDomain; |
|
var async = _dereq_("./async.js"); |
|
var util = _dereq_("./util.js"); |
|
var tryCatch = util.tryCatch; |
|
var errorObj = util.errorObj; |
|
function ReductionPromiseArray(promises, fn, accum, _each) { |
|
this.constructor$(promises); |
|
this._promise._captureStackTrace(); |
|
this._preservedValues = _each === INTERNAL ? [] : null; |
|
this._zerothIsAccum = (accum === undefined); |
|
this._gotAccum = false; |
|
this._reducingIndex = (this._zerothIsAccum ? 1 : 0); |
|
this._valuesPhase = undefined; |
|
var maybePromise = tryConvertToPromise(accum, this._promise); |
|
var rejected = false; |
|
var isPromise = maybePromise instanceof Promise; |
|
if (isPromise) { |
|
maybePromise = maybePromise._target(); |
|
if (maybePromise._isPending()) { |
|
maybePromise._proxyPromiseArray(this, -1); |
|
} else if (maybePromise._isFulfilled()) { |
|
accum = maybePromise._value(); |
|
this._gotAccum = true; |
|
} else { |
|
this._reject(maybePromise._reason()); |
|
rejected = true; |
|
} |
|
} |
|
if (!(isPromise || this._zerothIsAccum)) this._gotAccum = true; |
|
var domain = getDomain(); |
|
this._callback = domain === null ? fn : domain.bind(fn); |
|
this._accum = accum; |
|
if (!rejected) async.invoke(init, this, undefined); |
|
} |
|
function init() { |
|
this._init$(undefined, -5); |
|
} |
|
util.inherits(ReductionPromiseArray, PromiseArray); |
|
|
|
ReductionPromiseArray.prototype._init = function () {}; |
|
|
|
ReductionPromiseArray.prototype._resolveEmptyArray = function () { |
|
if (this._gotAccum || this._zerothIsAccum) { |
|
this._resolve(this._preservedValues !== null |
|
? [] : this._accum); |
|
} |
|
}; |
|
|
|
ReductionPromiseArray.prototype._promiseFulfilled = function (value, index) { |
|
var values = this._values; |
|
values[index] = value; |
|
var length = this.length(); |
|
var preservedValues = this._preservedValues; |
|
var isEach = preservedValues !== null; |
|
var gotAccum = this._gotAccum; |
|
var valuesPhase = this._valuesPhase; |
|
var valuesPhaseIndex; |
|
if (!valuesPhase) { |
|
valuesPhase = this._valuesPhase = new Array(length); |
|
for (valuesPhaseIndex=0; valuesPhaseIndex<length; ++valuesPhaseIndex) { |
|
valuesPhase[valuesPhaseIndex] = 0; |
|
} |
|
} |
|
valuesPhaseIndex = valuesPhase[index]; |
|
|
|
if (index === 0 && this._zerothIsAccum) { |
|
this._accum = value; |
|
this._gotAccum = gotAccum = true; |
|
valuesPhase[index] = ((valuesPhaseIndex === 0) |
|
? 1 : 2); |
|
} else if (index === -1) { |
|
this._accum = value; |
|
this._gotAccum = gotAccum = true; |
|
} else { |
|
if (valuesPhaseIndex === 0) { |
|
valuesPhase[index] = 1; |
|
} else { |
|
valuesPhase[index] = 2; |
|
this._accum = value; |
|
} |
|
} |
|
if (!gotAccum) return; |
|
|
|
var callback = this._callback; |
|
var receiver = this._promise._boundValue(); |
|
var ret; |
|
|
|
for (var i = this._reducingIndex; i < length; ++i) { |
|
valuesPhaseIndex = valuesPhase[i]; |
|
if (valuesPhaseIndex === 2) { |
|
this._reducingIndex = i + 1; |
|
continue; |
|
} |
|
if (valuesPhaseIndex !== 1) return; |
|
value = values[i]; |
|
this._promise._pushContext(); |
|
if (isEach) { |
|
preservedValues.push(value); |
|
ret = tryCatch(callback).call(receiver, value, i, length); |
|
} |
|
else { |
|
ret = tryCatch(callback) |
|
.call(receiver, this._accum, value, i, length); |
|
} |
|
this._promise._popContext(); |
|
|
|
if (ret === errorObj) return this._reject(ret.e); |
|
|
|
var maybePromise = tryConvertToPromise(ret, this._promise); |
|
if (maybePromise instanceof Promise) { |
|
maybePromise = maybePromise._target(); |
|
if (maybePromise._isPending()) { |
|
valuesPhase[i] = 4; |
|
return maybePromise._proxyPromiseArray(this, i); |
|
} else if (maybePromise._isFulfilled()) { |
|
ret = maybePromise._value(); |
|
} else { |
|
return this._reject(maybePromise._reason()); |
|
} |
|
} |
|
|
|
this._reducingIndex = i + 1; |
|
this._accum = ret; |
|
} |
|
|
|
this._resolve(isEach ? preservedValues : this._accum); |
|
}; |
|
|
|
function reduce(promises, fn, initialValue, _each) { |
|
if (typeof fn !== "function") return apiRejection("fn must be a function\u000a\u000a See http://goo.gl/916lJJ\u000a"); |
|
var array = new ReductionPromiseArray(promises, fn, initialValue, _each); |
|
return array.promise(); |
|
} |
|
|
|
Promise.prototype.reduce = function (fn, initialValue) { |
|
return reduce(this, fn, initialValue, null); |
|
}; |
|
|
|
Promise.reduce = function (promises, fn, initialValue, _each) { |
|
return reduce(promises, fn, initialValue, _each); |
|
}; |
|
}; |
|
|
|
},{"./async.js":2,"./util.js":38}],31:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
var schedule; |
|
var util = _dereq_("./util"); |
|
var noAsyncScheduler = function() { |
|
throw new Error("No async scheduler available\u000a\u000a See http://goo.gl/m3OTXk\u000a"); |
|
}; |
|
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 MutationObserver !== "undefined") && |
|
!(typeof window !== "undefined" && |
|
window.navigator && |
|
window.navigator.standalone)) { |
|
schedule = function(fn) { |
|
var div = document.createElement("div"); |
|
var observer = new MutationObserver(fn); |
|
observer.observe(div, {attributes: true}); |
|
return function() { div.classList.toggle("foo"); }; |
|
}; |
|
schedule.isStatic = true; |
|
} 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":38}],32:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
module.exports = |
|
function(Promise, PromiseArray) { |
|
var PromiseInspection = Promise.PromiseInspection; |
|
var util = _dereq_("./util.js"); |
|
|
|
function SettledPromiseArray(values) { |
|
this.constructor$(values); |
|
} |
|
util.inherits(SettledPromiseArray, PromiseArray); |
|
|
|
SettledPromiseArray.prototype._promiseResolved = function (index, inspection) { |
|
this._values[index] = inspection; |
|
var totalResolved = ++this._totalResolved; |
|
if (totalResolved >= this._length) { |
|
this._resolve(this._values); |
|
} |
|
}; |
|
|
|
SettledPromiseArray.prototype._promiseFulfilled = function (value, index) { |
|
var ret = new PromiseInspection(); |
|
ret._bitField = 268435456; |
|
ret._settledValue = value; |
|
this._promiseResolved(index, ret); |
|
}; |
|
SettledPromiseArray.prototype._promiseRejected = function (reason, index) { |
|
var ret = new PromiseInspection(); |
|
ret._bitField = 134217728; |
|
ret._settledValue = reason; |
|
this._promiseResolved(index, ret); |
|
}; |
|
|
|
Promise.settle = function (promises) { |
|
return new SettledPromiseArray(promises).promise(); |
|
}; |
|
|
|
Promise.prototype.settle = function () { |
|
return new SettledPromiseArray(this).promise(); |
|
}; |
|
}; |
|
|
|
},{"./util.js":38}],33:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
module.exports = |
|
function(Promise, PromiseArray, apiRejection) { |
|
var util = _dereq_("./util.js"); |
|
var RangeError = _dereq_("./errors.js").RangeError; |
|
var AggregateError = _dereq_("./errors.js").AggregateError; |
|
var isArray = util.isArray; |
|
|
|
|
|
function SomePromiseArray(values) { |
|
this.constructor$(values); |
|
this._howMany = 0; |
|
this._unwrap = false; |
|
this._initialized = false; |
|
} |
|
util.inherits(SomePromiseArray, PromiseArray); |
|
|
|
SomePromiseArray.prototype._init = function () { |
|
if (!this._initialized) { |
|
return; |
|
} |
|
if (this._howMany === 0) { |
|
this._resolve([]); |
|
return; |
|
} |
|
this._init$(undefined, -5); |
|
var isArrayResolved = isArray(this._values); |
|
if (!this._isResolved() && |
|
isArrayResolved && |
|
this._howMany > this._canPossiblyFulfill()) { |
|
this._reject(this._getRangeError(this.length())); |
|
} |
|
}; |
|
|
|
SomePromiseArray.prototype.init = function () { |
|
this._initialized = true; |
|
this._init(); |
|
}; |
|
|
|
SomePromiseArray.prototype.setUnwrap = function () { |
|
this._unwrap = true; |
|
}; |
|
|
|
SomePromiseArray.prototype.howMany = function () { |
|
return this._howMany; |
|
}; |
|
|
|
SomePromiseArray.prototype.setHowMany = function (count) { |
|
this._howMany = count; |
|
}; |
|
|
|
SomePromiseArray.prototype._promiseFulfilled = function (value) { |
|
this._addFulfilled(value); |
|
if (this._fulfilled() === this.howMany()) { |
|
this._values.length = this.howMany(); |
|
if (this.howMany() === 1 && this._unwrap) { |
|
this._resolve(this._values[0]); |
|
} else { |
|
this._resolve(this._values); |
|
} |
|
} |
|
|
|
}; |
|
SomePromiseArray.prototype._promiseRejected = function (reason) { |
|
this._addRejected(reason); |
|
if (this.howMany() > this._canPossiblyFulfill()) { |
|
var e = new AggregateError(); |
|
for (var i = this.length(); i < this._values.length; ++i) { |
|
e.push(this._values[i]); |
|
} |
|
this._reject(e); |
|
} |
|
}; |
|
|
|
SomePromiseArray.prototype._fulfilled = function () { |
|
return this._totalResolved; |
|
}; |
|
|
|
SomePromiseArray.prototype._rejected = function () { |
|
return this._values.length - this.length(); |
|
}; |
|
|
|
SomePromiseArray.prototype._addRejected = function (reason) { |
|
this._values.push(reason); |
|
}; |
|
|
|
SomePromiseArray.prototype._addFulfilled = function (value) { |
|
this._values[this._totalResolved++] = value; |
|
}; |
|
|
|
SomePromiseArray.prototype._canPossiblyFulfill = function () { |
|
return this.length() - this._rejected(); |
|
}; |
|
|
|
SomePromiseArray.prototype._getRangeError = function (count) { |
|
var message = "Input array must contain at least " + |
|
this._howMany + " items but contains only " + count + " items"; |
|
return new RangeError(message); |
|
}; |
|
|
|
SomePromiseArray.prototype._resolveEmptyArray = function () { |
|
this._reject(this._getRangeError(0)); |
|
}; |
|
|
|
function some(promises, howMany) { |
|
if ((howMany | 0) !== howMany || howMany < 0) { |
|
return apiRejection("expecting a positive integer\u000a\u000a See http://goo.gl/1wAmHx\u000a"); |
|
} |
|
var ret = new SomePromiseArray(promises); |
|
var promise = ret.promise(); |
|
ret.setHowMany(howMany); |
|
ret.init(); |
|
return promise; |
|
} |
|
|
|
Promise.some = function (promises, howMany) { |
|
return some(promises, howMany); |
|
}; |
|
|
|
Promise.prototype.some = function (howMany) { |
|
return some(this, howMany); |
|
}; |
|
|
|
Promise._SomePromiseArray = SomePromiseArray; |
|
}; |
|
|
|
},{"./errors.js":13,"./util.js":38}],34:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
module.exports = function(Promise) { |
|
function PromiseInspection(promise) { |
|
if (promise !== undefined) { |
|
promise = promise._target(); |
|
this._bitField = promise._bitField; |
|
this._settledValue = promise._settledValue; |
|
} |
|
else { |
|
this._bitField = 0; |
|
this._settledValue = undefined; |
|
} |
|
} |
|
|
|
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/hc1DLj\u000a"); |
|
} |
|
return this._settledValue; |
|
}; |
|
|
|
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/hPuiwB\u000a"); |
|
} |
|
return this._settledValue; |
|
}; |
|
|
|
PromiseInspection.prototype.isFulfilled = |
|
Promise.prototype._isFulfilled = function () { |
|
return (this._bitField & 268435456) > 0; |
|
}; |
|
|
|
PromiseInspection.prototype.isRejected = |
|
Promise.prototype._isRejected = function () { |
|
return (this._bitField & 134217728) > 0; |
|
}; |
|
|
|
PromiseInspection.prototype.isPending = |
|
Promise.prototype._isPending = function () { |
|
return (this._bitField & 402653184) === 0; |
|
}; |
|
|
|
PromiseInspection.prototype.isResolved = |
|
Promise.prototype._isResolved = function () { |
|
return (this._bitField & 402653184) > 0; |
|
}; |
|
|
|
Promise.prototype.isPending = function() { |
|
return this._target()._isPending(); |
|
}; |
|
|
|
Promise.prototype.isRejected = function() { |
|
return this._target()._isRejected(); |
|
}; |
|
|
|
Promise.prototype.isFulfilled = function() { |
|
return this._target()._isFulfilled(); |
|
}; |
|
|
|
Promise.prototype.isResolved = function() { |
|
return this._target()._isResolved(); |
|
}; |
|
|
|
Promise.prototype._value = function() { |
|
return this._settledValue; |
|
}; |
|
|
|
Promise.prototype._reason = function() { |
|
this._unsetRejectionIsUnhandled(); |
|
return this._settledValue; |
|
}; |
|
|
|
Promise.prototype.value = function() { |
|
var target = this._target(); |
|
if (!target.isFulfilled()) { |
|
throw new TypeError("cannot get fulfillment value of a non-fulfilled promise\u000a\u000a See http://goo.gl/hc1DLj\u000a"); |
|
} |
|
return target._settledValue; |
|
}; |
|
|
|
Promise.prototype.reason = function() { |
|
var target = this._target(); |
|
if (!target.isRejected()) { |
|
throw new TypeError("cannot get rejection reason of a non-rejected promise\u000a\u000a See http://goo.gl/hPuiwB\u000a"); |
|
} |
|
target._unsetRejectionIsUnhandled(); |
|
return target._settledValue; |
|
}; |
|
|
|
|
|
Promise.PromiseInspection = PromiseInspection; |
|
}; |
|
|
|
},{}],35:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
module.exports = function(Promise, INTERNAL) { |
|
var util = _dereq_("./util.js"); |
|
var errorObj = util.errorObj; |
|
var isObject = util.isObject; |
|
|
|
function tryConvertToPromise(obj, context) { |
|
if (isObject(obj)) { |
|
if (obj instanceof Promise) { |
|
return obj; |
|
} |
|
else if (isAnyBluebirdPromise(obj)) { |
|
var ret = new Promise(INTERNAL); |
|
obj._then( |
|
ret._fulfillUnchecked, |
|
ret._rejectUncheckedCheckError, |
|
ret._progressUnchecked, |
|
ret, |
|
null |
|
); |
|
return ret; |
|
} |
|
var then = util.tryCatch(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") { |
|
return doThenable(obj, then, context); |
|
} |
|
} |
|
return obj; |
|
} |
|
|
|
function getThen(obj) { |
|
return obj.then; |
|
} |
|
|
|
var hasProp = {}.hasOwnProperty; |
|
function isAnyBluebirdPromise(obj) { |
|
return hasProp.call(obj, "_promise0"); |
|
} |
|
|
|
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, |
|
resolveFromThenable, |
|
rejectFromThenable, |
|
progressFromThenable); |
|
synchronous = false; |
|
if (promise && result === errorObj) { |
|
promise._rejectCallback(result.e, true, true); |
|
promise = null; |
|
} |
|
|
|
function resolveFromThenable(value) { |
|
if (!promise) return; |
|
promise._resolveCallback(value); |
|
promise = null; |
|
} |
|
|
|
function rejectFromThenable(reason) { |
|
if (!promise) return; |
|
promise._rejectCallback(reason, synchronous, true); |
|
promise = null; |
|
} |
|
|
|
function progressFromThenable(value) { |
|
if (!promise) return; |
|
if (typeof promise._progress === "function") { |
|
promise._progress(value); |
|
} |
|
} |
|
return ret; |
|
} |
|
|
|
return tryConvertToPromise; |
|
}; |
|
|
|
},{"./util.js":38}],36:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
module.exports = function(Promise, INTERNAL) { |
|
var util = _dereq_("./util.js"); |
|
var TimeoutError = Promise.TimeoutError; |
|
|
|
var afterTimeout = function (promise, message) { |
|
if (!promise.isPending()) return; |
|
|
|
var err; |
|
if(!util.isPrimitive(message) && (message instanceof Error)) { |
|
err = message; |
|
} else { |
|
if (typeof message !== "string") { |
|
message = "operation timed out"; |
|
} |
|
err = new TimeoutError(message); |
|
} |
|
util.markAsOriginatingFromRejection(err); |
|
promise._attachExtraTrace(err); |
|
promise._cancel(err); |
|
}; |
|
|
|
var afterValue = function(value) { return delay(+this).thenReturn(value); }; |
|
var delay = Promise.delay = function (value, ms) { |
|
if (ms === undefined) { |
|
ms = value; |
|
value = undefined; |
|
var ret = new Promise(INTERNAL); |
|
setTimeout(function() { ret._fulfill(); }, ms); |
|
return ret; |
|
} |
|
ms = +ms; |
|
return Promise.resolve(value)._then(afterValue, null, null, ms, undefined); |
|
}; |
|
|
|
Promise.prototype.delay = function (ms) { |
|
return delay(this, ms); |
|
}; |
|
|
|
function successClear(value) { |
|
var handle = this; |
|
if (handle instanceof Number) handle = +handle; |
|
clearTimeout(handle); |
|
return value; |
|
} |
|
|
|
function failureClear(reason) { |
|
var handle = this; |
|
if (handle instanceof Number) handle = +handle; |
|
clearTimeout(handle); |
|
throw reason; |
|
} |
|
|
|
Promise.prototype.timeout = function (ms, message) { |
|
ms = +ms; |
|
var ret = this.then().cancellable(); |
|
ret._cancellationParent = this; |
|
var handle = setTimeout(function timeoutTimeout() { |
|
afterTimeout(ret, message); |
|
}, ms); |
|
return ret._then(successClear, failureClear, undefined, handle, undefined); |
|
}; |
|
|
|
}; |
|
|
|
},{"./util.js":38}],37:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
module.exports = function (Promise, apiRejection, tryConvertToPromise, |
|
createContext) { |
|
var TypeError = _dereq_("./errors.js").TypeError; |
|
var inherits = _dereq_("./util.js").inherits; |
|
var PromiseInspection = Promise.PromiseInspection; |
|
|
|
function inspectionMapper(inspections) { |
|
var len = inspections.length; |
|
for (var i = 0; i < len; ++i) { |
|
var inspection = inspections[i]; |
|
if (inspection.isRejected()) { |
|
return Promise.reject(inspection.error()); |
|
} |
|
inspections[i] = inspection._settledValue; |
|
} |
|
return inspections; |
|
} |
|
|
|
function thrower(e) { |
|
setTimeout(function(){throw e;}, 0); |
|
} |
|
|
|
function castPreservingDisposable(thenable) { |
|
var maybePromise = tryConvertToPromise(thenable); |
|
if (maybePromise !== thenable && |
|
typeof thenable._isDisposable === "function" && |
|
typeof thenable._getDisposer === "function" && |
|
thenable._isDisposable()) { |
|
maybePromise._setDisposable(thenable._getDisposer()); |
|
} |
|
return maybePromise; |
|
} |
|
function dispose(resources, inspection) { |
|
var i = 0; |
|
var len = resources.length; |
|
var ret = Promise.defer(); |
|
function iterator() { |
|
if (i >= len) return ret.resolve(); |
|
var maybePromise = castPreservingDisposable(resources[i++]); |
|
if (maybePromise instanceof Promise && |
|
maybePromise._isDisposable()) { |
|
try { |
|
maybePromise = tryConvertToPromise( |
|
maybePromise._getDisposer().tryDispose(inspection), |
|
resources.promise); |
|
} catch (e) { |
|
return thrower(e); |
|
} |
|
if (maybePromise instanceof Promise) { |
|
return maybePromise._then(iterator, thrower, |
|
null, null, null); |
|
} |
|
} |
|
iterator(); |
|
} |
|
iterator(); |
|
return ret.promise; |
|
} |
|
|
|
function disposerSuccess(value) { |
|
var inspection = new PromiseInspection(); |
|
inspection._settledValue = value; |
|
inspection._bitField = 268435456; |
|
return dispose(this, inspection).thenReturn(value); |
|
} |
|
|
|
function disposerFail(reason) { |
|
var inspection = new PromiseInspection(); |
|
inspection._settledValue = reason; |
|
inspection._bitField = 134217728; |
|
return dispose(this, inspection).thenThrow(reason); |
|
} |
|
|
|
function Disposer(data, promise, context) { |
|
this._data = data; |
|
this._promise = promise; |
|
this._context = context; |
|
} |
|
|
|
Disposer.prototype.data = function () { |
|
return this._data; |
|
}; |
|
|
|
Disposer.prototype.promise = function () { |
|
return this._promise; |
|
}; |
|
|
|
Disposer.prototype.resource = function () { |
|
if (this.promise().isFulfilled()) { |
|
return this.promise().value(); |
|
} |
|
return null; |
|
}; |
|
|
|
Disposer.prototype.tryDispose = function(inspection) { |
|
var resource = this.resource(); |
|
var context = this._context; |
|
if (context !== undefined) context._pushContext(); |
|
var ret = resource !== null |
|
? this.doDispose(resource, inspection) : null; |
|
if (context !== undefined) context._popContext(); |
|
this._promise._unsetDisposable(); |
|
this._data = null; |
|
return ret; |
|
}; |
|
|
|
Disposer.isDisposer = function (d) { |
|
return (d != null && |
|
typeof d.resource === "function" && |
|
typeof d.tryDispose === "function"); |
|
}; |
|
|
|
function FunctionDisposer(fn, promise, context) { |
|
this.constructor$(fn, promise, context); |
|
} |
|
inherits(FunctionDisposer, Disposer); |
|
|
|
FunctionDisposer.prototype.doDispose = function (resource, inspection) { |
|
var fn = this.data(); |
|
return fn.call(resource, resource, inspection); |
|
}; |
|
|
|
function maybeUnwrapDisposer(value) { |
|
if (Disposer.isDisposer(value)) { |
|
this.resources[this.index]._setDisposable(value); |
|
return value.promise(); |
|
} |
|
return value; |
|
} |
|
|
|
Promise.using = function () { |
|
var len = arguments.length; |
|
if (len < 2) return apiRejection( |
|
"you must pass at least 2 arguments to Promise.using"); |
|
var fn = arguments[len - 1]; |
|
if (typeof fn !== "function") return apiRejection("fn must be a function\u000a\u000a See http://goo.gl/916lJJ\u000a"); |
|
|
|
var input; |
|
var spreadArgs = true; |
|
if (len === 2 && Array.isArray(arguments[0])) { |
|
input = arguments[0]; |
|
len = input.length; |
|
spreadArgs = false; |
|
} else { |
|
input = arguments; |
|
len--; |
|
} |
|
var resources = new Array(len); |
|
for (var i = 0; i < len; ++i) { |
|
var resource = input[i]; |
|
if (Disposer.isDisposer(resource)) { |
|
var disposer = resource; |
|
resource = resource.promise(); |
|
resource._setDisposable(disposer); |
|
} else { |
|
var maybePromise = tryConvertToPromise(resource); |
|
if (maybePromise instanceof Promise) { |
|
resource = |
|
maybePromise._then(maybeUnwrapDisposer, null, null, { |
|
resources: resources, |
|
index: i |
|
}, undefined); |
|
} |
|
} |
|
resources[i] = resource; |
|
} |
|
|
|
var promise = Promise.settle(resources) |
|
.then(inspectionMapper) |
|
.then(function(vals) { |
|
promise._pushContext(); |
|
var ret; |
|
try { |
|
ret = spreadArgs |
|
? fn.apply(undefined, vals) : fn.call(undefined, vals); |
|
} finally { |
|
promise._popContext(); |
|
} |
|
return ret; |
|
}) |
|
._then( |
|
disposerSuccess, disposerFail, undefined, resources, undefined); |
|
resources.promise = promise; |
|
return promise; |
|
}; |
|
|
|
Promise.prototype._setDisposable = function (disposer) { |
|
this._bitField = this._bitField | 262144; |
|
this._disposer = disposer; |
|
}; |
|
|
|
Promise.prototype._isDisposable = function () { |
|
return (this._bitField & 262144) > 0; |
|
}; |
|
|
|
Promise.prototype._getDisposer = function () { |
|
return this._disposer; |
|
}; |
|
|
|
Promise.prototype._unsetDisposable = function () { |
|
this._bitField = this._bitField & (~262144); |
|
this._disposer = undefined; |
|
}; |
|
|
|
Promise.prototype.disposer = function (fn) { |
|
if (typeof fn === "function") { |
|
return new FunctionDisposer(fn, this, createContext()); |
|
} |
|
throw new TypeError(); |
|
}; |
|
|
|
}; |
|
|
|
},{"./errors.js":13,"./util.js":38}],38:[function(_dereq_,module,exports){ |
|
"use strict"; |
|
var es5 = _dereq_("./es5.js"); |
|
var canEvaluate = typeof navigator == "undefined"; |
|
var haveGetters = (function(){ |
|
try { |
|
var o = {}; |
|
es5.defineProperty(o, "f", { |
|
get: function () { |
|
return 3; |
|
} |
|
}); |
|
return o.f === 3; |
|
} |
|
catch (e) { |
|
return false; |
|
} |
|
|
|
})(); |
|
|
|
var errorObj = {e: {}}; |
|
var tryCatchTarget; |
|
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 !isPrimitive(value); |
|
} |
|
|
|
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 f() {} |
|
f.prototype = obj; |
|
var l = 8; |
|
while (l--) new f(); |
|
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 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 obj instanceof Error && 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 ret = { |
|
isClass: isClass, |
|
isIdentifier: isIdentifier, |
|
inheritedDataKeys: inheritedDataKeys, |
|
getDataPropertyOrDefault: getDataPropertyOrDefault, |
|
thrower: thrower, |
|
isArray: es5.isArray, |
|
haveGetters: haveGetters, |
|
notEnumerableProp: notEnumerableProp, |
|
isPrimitive: isPrimitive, |
|
isObject: isObject, |
|
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, |
|
hasDevTools: typeof chrome !== "undefined" && chrome && |
|
typeof chrome.loadTimes === "function", |
|
isNode: typeof process !== "undefined" && |
|
classString(process).toLowerCase() === "[object process]" |
|
}; |
|
ret.isRecentNode = ret.isNode && (function() { |
|
var version = process.versions.node.split(".").map(Number); |
|
return (version[0] === 0 && version[1] > 10) || (version[0] > 0); |
|
})(); |
|
|
|
if (ret.isNode) ret.toFastProperties(process); |
|
|
|
try {throw new Error(); } catch (e) {ret.lastLineError = e;} |
|
module.exports = ret; |
|
|
|
},{"./es5.js":14}]},{},[4])(4) |
|
}); ;if (typeof window !== 'undefined' && window !== null) { window.P = window.Promise; } else if (typeof self !== 'undefined' && self !== null) { self.P = self.Promise; } |