/instantMessage/bower_components/velocity/test/bluebird.js |
@@ -0,0 +1,5176 @@ |
/** |
* bluebird build version 2.2.1 |
* Features enabled: core, race, call_get, generators, map, nodeify, promisify, props, reduce, settle, some, progress, cancel, using, filter, any, each, timers |
*/ |
/** |
* @preserve Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
!function(e){"object"==typeof exports?module.exports=e():"function"==typeof define&&define.amd?define(e):"undefined"!=typeof window?window.Promise=e():"undefined"!=typeof global?global.Promise=e():"undefined"!=typeof self&&(self.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 require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
module.exports = function(Promise) { |
var SomePromiseArray = Promise._SomePromiseArray; |
function Promise$_Any(promises) { |
var ret = new SomePromiseArray(promises); |
var promise = ret.promise(); |
if (promise.isRejected()) { |
return promise; |
} |
ret.setHowMany(1); |
ret.setUnwrap(); |
ret.init(); |
return promise; |
} |
|
Promise.any = function Promise$Any(promises) { |
return Promise$_Any(promises); |
}; |
|
Promise.prototype.any = function Promise$any() { |
return Promise$_Any(this); |
}; |
|
}; |
|
},{}],2:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
var schedule = require("./schedule.js"); |
var Queue = require("./queue.js"); |
var errorObj = require("./util.js").errorObj; |
var tryCatch1 = require("./util.js").tryCatch1; |
var _process = typeof process !== "undefined" ? process : void 0; |
|
function Async() { |
this._isTickUsed = false; |
this._schedule = schedule; |
this._length = 0; |
this._lateBuffer = new Queue(16); |
this._functionBuffer = new Queue(65536); |
var self = this; |
this.consumeFunctionBuffer = function Async$consumeFunctionBuffer() { |
self._consumeFunctionBuffer(); |
}; |
} |
|
Async.prototype.haveItemsQueued = function Async$haveItemsQueued() { |
return this._length > 0; |
}; |
|
Async.prototype.invokeLater = function Async$invokeLater(fn, receiver, arg) { |
if (_process !== void 0 && |
_process.domain != null && |
!fn.domain) { |
fn = _process.domain.bind(fn); |
} |
this._lateBuffer.push(fn, receiver, arg); |
this._queueTick(); |
}; |
|
Async.prototype.invoke = function Async$invoke(fn, receiver, arg) { |
if (_process !== void 0 && |
_process.domain != null && |
!fn.domain) { |
fn = _process.domain.bind(fn); |
} |
var functionBuffer = this._functionBuffer; |
functionBuffer.push(fn, receiver, arg); |
this._length = functionBuffer.length(); |
this._queueTick(); |
}; |
|
Async.prototype._consumeFunctionBuffer = |
function Async$_consumeFunctionBuffer() { |
var functionBuffer = this._functionBuffer; |
while (functionBuffer.length() > 0) { |
var fn = functionBuffer.shift(); |
var receiver = functionBuffer.shift(); |
var arg = functionBuffer.shift(); |
fn.call(receiver, arg); |
} |
this._reset(); |
this._consumeLateBuffer(); |
}; |
|
Async.prototype._consumeLateBuffer = function Async$_consumeLateBuffer() { |
var buffer = this._lateBuffer; |
while(buffer.length() > 0) { |
var fn = buffer.shift(); |
var receiver = buffer.shift(); |
var arg = buffer.shift(); |
var res = tryCatch1(fn, receiver, arg); |
if (res === errorObj) { |
this._queueTick(); |
if (fn.domain != null) { |
fn.domain.emit("error", res.e); |
} else { |
throw res.e; |
} |
} |
} |
}; |
|
Async.prototype._queueTick = function Async$_queue() { |
if (!this._isTickUsed) { |
this._schedule(this.consumeFunctionBuffer); |
this._isTickUsed = true; |
} |
}; |
|
Async.prototype._reset = function Async$_reset() { |
this._isTickUsed = false; |
this._length = 0; |
}; |
|
module.exports = new Async(); |
|
},{"./queue.js":25,"./schedule.js":28,"./util.js":35}],3:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
var Promise = require("./promise.js")(); |
module.exports = Promise; |
},{"./promise.js":20}],4:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
var cr = Object.create; |
var callerCache = cr && cr(null); |
var getterCache = cr && cr(null); |
callerCache[" size"] = getterCache[" size"] = 0; |
module.exports = function(Promise) { |
var util = require("./util.js"); |
var canEvaluate = util.canEvaluate; |
var isIdentifier = util.isIdentifier; |
|
function makeMethodCaller (methodName) { |
return new Function("obj", " \n\ |
'use strict' \n\ |
var len = this.length; \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: return obj.methodName.apply(obj, this); \n\ |
} \n\ |
".replace(/methodName/g, methodName)); |
} |
|
function makeGetter (propertyName) { |
return new Function("obj", " \n\ |
'use strict'; \n\ |
return obj.propertyName; \n\ |
".replace("propertyName", propertyName)); |
} |
|
function getCompiled(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; |
} |
|
function getMethodCaller(name) { |
return getCompiled(name, makeMethodCaller, callerCache); |
} |
|
function getGetter(name) { |
return getCompiled(name, makeGetter, getterCache); |
} |
|
function caller(obj) { |
return obj[this.pop()].apply(obj, this); |
} |
Promise.prototype.call = function Promise$call(methodName) { |
var $_len = arguments.length;var args = new Array($_len - 1); for(var $_i = 1; $_i < $_len; ++$_i) {args[$_i - 1] = arguments[$_i];} |
if (canEvaluate) { |
var maybeCaller = getMethodCaller(methodName); |
if (maybeCaller !== null) { |
return this._then(maybeCaller, void 0, void 0, args, void 0); |
} |
} |
args.push(methodName); |
return this._then(caller, void 0, void 0, args, void 0); |
}; |
|
function namedGetter(obj) { |
return obj[this]; |
} |
function indexedGetter(obj) { |
return obj[this]; |
} |
Promise.prototype.get = function Promise$get(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, void 0, void 0, propertyName, void 0); |
}; |
}; |
|
},{"./util.js":35}],5:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
module.exports = function(Promise, INTERNAL) { |
var errors = require("./errors.js"); |
var canAttach = errors.canAttach; |
var async = require("./async.js"); |
var CancellationError = errors.CancellationError; |
|
Promise.prototype._cancel = function Promise$_cancel(reason) { |
if (!this.isCancellable()) return this; |
var parent; |
var promiseToReject = this; |
while ((parent = promiseToReject._cancellationParent) !== void 0 && |
parent.isCancellable()) { |
promiseToReject = parent; |
} |
promiseToReject._attachExtraTrace(reason); |
promiseToReject._rejectUnchecked(reason); |
}; |
|
Promise.prototype.cancel = function Promise$cancel(reason) { |
if (!this.isCancellable()) return this; |
reason = reason !== void 0 |
? (canAttach(reason) ? reason : new Error(reason + "")) |
: new CancellationError(); |
async.invokeLater(this._cancel, this, reason); |
return this; |
}; |
|
Promise.prototype.cancellable = function Promise$cancellable() { |
if (this._cancellable()) return this; |
this._setCancellable(); |
this._cancellationParent = void 0; |
return this; |
}; |
|
Promise.prototype.uncancellable = function Promise$uncancellable() { |
var ret = new Promise(INTERNAL); |
ret._propagateFrom(this, 2 | 4); |
ret._follow(this); |
ret._unsetCancellable(); |
return ret; |
}; |
|
Promise.prototype.fork = |
function Promise$fork(didFulfill, didReject, didProgress) { |
var ret = this._then(didFulfill, didReject, didProgress, |
void 0, void 0); |
|
ret._setCancellable(); |
ret._cancellationParent = void 0; |
return ret; |
}; |
}; |
|
},{"./async.js":2,"./errors.js":10}],6:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
module.exports = function() { |
var inherits = require("./util.js").inherits; |
var defineProperty = require("./es5.js").defineProperty; |
|
var rignore = new RegExp( |
"\\b(?:[a-zA-Z0-9.]+\\$_\\w+|" + |
"tryCatch(?:1|2|3|4|Apply)|new \\w*PromiseArray|" + |
"\\w*PromiseArray\\.\\w*PromiseArray|" + |
"setTimeout|CatchFilter\\$_\\w+|makeNodePromisified|processImmediate|" + |
"process._tickCallback|nextTick|Async\\$\\w+)\\b" |
); |
|
var rtraceline = null; |
var formatStack = null; |
|
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) + "..."; |
} |
|
function CapturedTrace(ignoreUntil, isTopLevel) { |
this.captureStackTrace(CapturedTrace, isTopLevel); |
|
} |
inherits(CapturedTrace, Error); |
|
CapturedTrace.prototype.captureStackTrace = |
function CapturedTrace$captureStackTrace(ignoreUntil, isTopLevel) { |
captureStackTrace(this, ignoreUntil, isTopLevel); |
}; |
|
CapturedTrace.possiblyUnhandledRejection = |
function CapturedTrace$PossiblyUnhandledRejection(reason) { |
if (typeof console === "object") { |
var message; |
if (typeof reason === "object" || typeof reason === "function") { |
var stack = reason.stack; |
message = "Possibly unhandled " + formatStack(stack, reason); |
} else { |
message = "Possibly unhandled " + String(reason); |
} |
if (typeof console.error === "function" || |
typeof console.error === "object") { |
console.error(message); |
} else if (typeof console.log === "function" || |
typeof console.log === "object") { |
console.log(message); |
} |
} |
}; |
|
CapturedTrace.combine = function CapturedTrace$Combine(current, prev) { |
var curLast = current.length - 1; |
for (var i = prev.length - 1; i >= 0; --i) { |
var line = prev[i]; |
if (current[curLast] === line) { |
current.pop(); |
curLast--; |
} else { |
break; |
} |
} |
|
current.push("From previous event:"); |
var lines = current.concat(prev); |
|
var ret = []; |
|
for (var i = 0, len = lines.length; i < len; ++i) { |
|
if ((rignore.test(lines[i]) || |
(i > 0 && !rtraceline.test(lines[i])) && |
lines[i] !== "From previous event:") |
) { |
continue; |
} |
ret.push(lines[i]); |
} |
return ret; |
}; |
|
CapturedTrace.protectErrorMessageNewlines = function(stack) { |
for (var i = 0; i < stack.length; ++i) { |
if (rtraceline.test(stack[i])) { |
break; |
} |
} |
|
if (i <= 1) return; |
|
var errorMessageLines = []; |
for (var j = 0; j < i; ++j) { |
errorMessageLines.push(stack.shift()); |
} |
stack.unshift(errorMessageLines.join("\u0002\u0000\u0001")); |
}; |
|
CapturedTrace.isSupported = function CapturedTrace$IsSupported() { |
return typeof captureStackTrace === "function"; |
}; |
|
var captureStackTrace = (function stackDetection() { |
if (typeof Error.stackTraceLimit === "number" && |
typeof Error.captureStackTrace === "function") { |
rtraceline = /^\s*at\s*/; |
formatStack = function(stack, error) { |
if (typeof stack === "string") return stack; |
|
if (error.name !== void 0 && |
error.message !== void 0) { |
return error.name + ". " + error.message; |
} |
return formatNonError(error); |
|
|
}; |
var captureStackTrace = Error.captureStackTrace; |
return function CapturedTrace$_captureStackTrace( |
receiver, ignoreUntil) { |
captureStackTrace(receiver, ignoreUntil); |
}; |
} |
var err = new Error(); |
|
if (typeof err.stack === "string" && |
typeof "".startsWith === "function" && |
(err.stack.startsWith("stackDetection@")) && |
stackDetection.name === "stackDetection") { |
|
defineProperty(Error, "stackTraceLimit", { |
writable: true, |
enumerable: false, |
configurable: false, |
value: 25 |
}); |
rtraceline = /@/; |
var rline = /[@\n]/; |
|
formatStack = function(stack, error) { |
if (typeof stack === "string") { |
return (error.name + ". " + error.message + "\n" + stack); |
} |
|
if (error.name !== void 0 && |
error.message !== void 0) { |
return error.name + ". " + error.message; |
} |
return formatNonError(error); |
}; |
|
return function captureStackTrace(o) { |
var stack = new Error().stack; |
var split = stack.split(rline); |
var len = split.length; |
var ret = ""; |
for (var i = 0; i < len; i += 2) { |
ret += split[i]; |
ret += "@"; |
ret += split[i + 1]; |
ret += "\n"; |
} |
o.stack = ret; |
}; |
} else { |
formatStack = function(stack, error) { |
if (typeof stack === "string") return stack; |
|
if ((typeof error === "object" || |
typeof error === "function") && |
error.name !== void 0 && |
error.message !== void 0) { |
return error.name + ". " + error.message; |
} |
return formatNonError(error); |
}; |
|
return null; |
} |
})(); |
|
return CapturedTrace; |
}; |
|
},{"./es5.js":12,"./util.js":35}],7:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
module.exports = function(NEXT_FILTER) { |
var util = require("./util.js"); |
var errors = require("./errors.js"); |
var tryCatch1 = util.tryCatch1; |
var errorObj = util.errorObj; |
var keys = require("./es5.js").keys; |
var TypeError = errors.TypeError; |
|
function CatchFilter(instances, callback, promise) { |
this._instances = instances; |
this._callback = callback; |
this._promise = promise; |
} |
|
function CatchFilter$_safePredicate(predicate, e) { |
var safeObject = {}; |
var retfilter = tryCatch1(predicate, 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"); |
return errorObj; |
} |
return retfilter; |
} |
|
CatchFilter.prototype.doFilter = function CatchFilter$_doFilter(e) { |
var cb = this._callback; |
var promise = this._promise; |
var boundTo = promise._boundTo; |
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 = tryCatch1(cb, boundTo, e); |
if (ret === errorObj) { |
NEXT_FILTER.e = ret.e; |
return NEXT_FILTER; |
} |
return ret; |
} else if (typeof item === "function" && !itemIsErrorType) { |
var shouldHandle = CatchFilter$_safePredicate(item, e); |
if (shouldHandle === errorObj) { |
var trace = errors.canAttach(errorObj.e) |
? errorObj.e |
: new Error(errorObj.e + ""); |
this._promise._attachExtraTrace(trace); |
e = errorObj.e; |
break; |
} else if (shouldHandle) { |
var ret = tryCatch1(cb, 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":10,"./es5.js":12,"./util.js":35}],8:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
var util = require("./util.js"); |
var isPrimitive = util.isPrimitive; |
var wrapsPrimitiveReceiver = util.wrapsPrimitiveReceiver; |
|
module.exports = function(Promise) { |
var returner = function Promise$_returner() { |
return this; |
}; |
var thrower = function Promise$_thrower() { |
throw this; |
}; |
|
var wrapper = function Promise$_wrapper(value, action) { |
if (action === 1) { |
return function Promise$_thrower() { |
throw value; |
}; |
} else if (action === 2) { |
return function Promise$_returner() { |
return value; |
}; |
} |
}; |
|
|
Promise.prototype["return"] = |
Promise.prototype.thenReturn = |
function Promise$thenReturn(value) { |
if (wrapsPrimitiveReceiver && isPrimitive(value)) { |
return this._then( |
wrapper(value, 2), |
void 0, |
void 0, |
void 0, |
void 0 |
); |
} |
return this._then(returner, void 0, void 0, value, void 0); |
}; |
|
Promise.prototype["throw"] = |
Promise.prototype.thenThrow = |
function Promise$thenThrow(reason) { |
if (wrapsPrimitiveReceiver && isPrimitive(reason)) { |
return this._then( |
wrapper(reason, 1), |
void 0, |
void 0, |
void 0, |
void 0 |
); |
} |
return this._then(thrower, void 0, void 0, reason, void 0); |
}; |
}; |
|
},{"./util.js":35}],9:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
module.exports = function(Promise, INTERNAL) { |
var PromiseReduce = Promise.reduce; |
|
Promise.prototype.each = function Promise$each(fn) { |
return PromiseReduce(this, fn, null, INTERNAL); |
}; |
|
Promise.each = function Promise$Each(promises, fn) { |
return PromiseReduce(promises, fn, null, INTERNAL); |
}; |
}; |
|
},{}],10:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
var Objectfreeze = require("./es5.js").freeze; |
var util = require("./util.js"); |
var inherits = util.inherits; |
var notEnumerableProp = util.notEnumerableProp; |
|
function markAsOriginatingFromRejection(e) { |
try { |
notEnumerableProp(e, "isOperational", true); |
} |
catch(ignore) {} |
} |
|
function originatesFromRejection(e) { |
if (e == null) return false; |
return ((e instanceof OperationalError) || |
e["isOperational"] === true); |
} |
|
function isError(obj) { |
return obj instanceof Error; |
} |
|
function canAttach(obj) { |
return isError(obj); |
} |
|
function subError(nameProperty, defaultMessage) { |
function SubError(message) { |
if (!(this instanceof SubError)) return new SubError(message); |
this.message = typeof message === "string" ? message : defaultMessage; |
this.name = nameProperty; |
if (Error.captureStackTrace) { |
Error.captureStackTrace(this, this.constructor); |
} |
} |
inherits(SubError, Error); |
return SubError; |
} |
|
var _TypeError, _RangeError; |
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]]; |
} |
} |
|
AggregateError.prototype.length = 0; |
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) { |
this.name = "OperationalError"; |
this.message = message; |
this.cause = message; |
this["isOperational"] = true; |
|
if (message instanceof Error) { |
this.message = message.message; |
this.stack = message.stack; |
} else if (Error.captureStackTrace) { |
Error.captureStackTrace(this, this.constructor); |
} |
|
} |
inherits(OperationalError, Error); |
|
var key = "__BluebirdErrorTypes__"; |
var errorTypes = Error[key]; |
if (!errorTypes) { |
errorTypes = Objectfreeze({ |
CancellationError: CancellationError, |
TimeoutError: TimeoutError, |
OperationalError: OperationalError, |
RejectionError: OperationalError, |
AggregateError: AggregateError |
}); |
notEnumerableProp(Error, key, errorTypes); |
} |
|
module.exports = { |
Error: Error, |
TypeError: _TypeError, |
RangeError: _RangeError, |
CancellationError: errorTypes.CancellationError, |
OperationalError: errorTypes.OperationalError, |
TimeoutError: errorTypes.TimeoutError, |
AggregateError: errorTypes.AggregateError, |
originatesFromRejection: originatesFromRejection, |
markAsOriginatingFromRejection: markAsOriginatingFromRejection, |
canAttach: canAttach |
}; |
|
},{"./es5.js":12,"./util.js":35}],11:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
module.exports = function(Promise) { |
var TypeError = require('./errors.js').TypeError; |
|
function apiRejection(msg) { |
var error = new TypeError(msg); |
var ret = Promise.rejected(error); |
var parent = ret._peekContext(); |
if (parent != null) { |
parent._attachExtraTrace(error); |
} |
return ret; |
} |
|
return apiRejection; |
}; |
|
},{"./errors.js":10}],12:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
var isES5 = (function(){ |
"use strict"; |
return this === void 0; |
})(); |
|
if (isES5) { |
module.exports = { |
freeze: Object.freeze, |
defineProperty: Object.defineProperty, |
keys: Object.keys, |
getPrototypeOf: Object.getPrototypeOf, |
isArray: Array.isArray, |
isES5: isES5 |
}; |
} else { |
var has = {}.hasOwnProperty; |
var str = {}.toString; |
var proto = {}.constructor.prototype; |
|
var ObjectKeys = function ObjectKeys(o) { |
var ret = []; |
for (var key in o) { |
if (has.call(o, key)) { |
ret.push(key); |
} |
} |
return ret; |
} |
|
var ObjectDefineProperty = function ObjectDefineProperty(o, key, desc) { |
o[key] = desc.value; |
return o; |
} |
|
var ObjectFreeze = function ObjectFreeze(obj) { |
return obj; |
} |
|
var ObjectGetPrototypeOf = function ObjectGetPrototypeOf(obj) { |
try { |
return Object(obj).constructor.prototype; |
} |
catch (e) { |
return proto; |
} |
} |
|
var ArrayIsArray = function ArrayIsArray(obj) { |
try { |
return str.call(obj) === "[object Array]"; |
} |
catch(e) { |
return false; |
} |
} |
|
module.exports = { |
isArray: ArrayIsArray, |
keys: ObjectKeys, |
defineProperty: ObjectDefineProperty, |
freeze: ObjectFreeze, |
getPrototypeOf: ObjectGetPrototypeOf, |
isES5: isES5 |
}; |
} |
|
},{}],13:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
module.exports = function(Promise, INTERNAL) { |
var PromiseMap = Promise.map; |
|
Promise.prototype.filter = function Promise$filter(fn, options) { |
return PromiseMap(this, fn, options, INTERNAL); |
}; |
|
Promise.filter = function Promise$Filter(promises, fn, options) { |
return PromiseMap(promises, fn, options, INTERNAL); |
}; |
}; |
|
},{}],14:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
module.exports = function(Promise, NEXT_FILTER, cast) { |
var util = require("./util.js"); |
var wrapsPrimitiveReceiver = util.wrapsPrimitiveReceiver; |
var isPrimitive = util.isPrimitive; |
var thrower = util.thrower; |
|
function returnThis() { |
return this; |
} |
function throwThis() { |
throw this; |
} |
function return$(r) { |
return function Promise$_returner() { |
return r; |
}; |
} |
function throw$(r) { |
return function Promise$_thrower() { |
throw r; |
}; |
} |
function promisedFinally(ret, reasonOrValue, isFulfilled) { |
var then; |
if (wrapsPrimitiveReceiver && isPrimitive(reasonOrValue)) { |
then = isFulfilled ? return$(reasonOrValue) : throw$(reasonOrValue); |
} else { |
then = isFulfilled ? returnThis : throwThis; |
} |
return ret._then(then, thrower, void 0, reasonOrValue, void 0); |
} |
|
function finallyHandler(reasonOrValue) { |
var promise = this.promise; |
var handler = this.handler; |
|
var ret = promise._isBound() |
? handler.call(promise._boundTo) |
: handler(); |
|
if (ret !== void 0) { |
var maybePromise = cast(ret, void 0); |
if (maybePromise instanceof Promise) { |
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._boundTo, value) |
: handler(value); |
|
if (ret !== void 0) { |
var maybePromise = cast(ret, void 0); |
if (maybePromise instanceof Promise) { |
return promisedFinally(maybePromise, value, true); |
} |
} |
return value; |
} |
|
Promise.prototype._passThroughHandler = |
function Promise$_passThroughHandler(handler, isFinally) { |
if (typeof handler !== "function") return this.then(); |
|
var promiseAndHandler = { |
promise: this, |
handler: handler |
}; |
|
return this._then( |
isFinally ? finallyHandler : tapHandler, |
isFinally ? finallyHandler : void 0, void 0, |
promiseAndHandler, void 0); |
}; |
|
Promise.prototype.lastly = |
Promise.prototype["finally"] = function Promise$finally(handler) { |
return this._passThroughHandler(handler, true); |
}; |
|
Promise.prototype.tap = function Promise$tap(handler) { |
return this._passThroughHandler(handler, false); |
}; |
}; |
|
},{"./util.js":35}],15:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
module.exports = function(Promise, apiRejection, INTERNAL, cast) { |
var errors = require("./errors.js"); |
var TypeError = errors.TypeError; |
var deprecated = require("./util.js").deprecated; |
var util = require("./util.js"); |
var errorObj = util.errorObj; |
var tryCatch1 = util.tryCatch1; |
var yieldHandlers = []; |
|
function promiseFromYieldHandler(value, yieldHandlers) { |
var _errorObj = errorObj; |
var _Promise = Promise; |
var len = yieldHandlers.length; |
for (var i = 0; i < len; ++i) { |
var result = tryCatch1(yieldHandlers[i], void 0, value); |
if (result === _errorObj) { |
return _Promise.reject(_errorObj.e); |
} |
var maybePromise = cast(result, promiseFromYieldHandler); |
if (maybePromise instanceof _Promise) return maybePromise; |
} |
return null; |
} |
|
function PromiseSpawn(generatorFunction, receiver, yieldHandler) { |
var promise = this._promise = new Promise(INTERNAL); |
promise._setTrace(void 0); |
this._generatorFunction = generatorFunction; |
this._receiver = receiver; |
this._generator = void 0; |
this._yieldHandlers = typeof yieldHandler === "function" |
? [yieldHandler].concat(yieldHandlers) |
: yieldHandlers; |
} |
|
PromiseSpawn.prototype.promise = function PromiseSpawn$promise() { |
return this._promise; |
}; |
|
PromiseSpawn.prototype._run = function PromiseSpawn$_run() { |
this._generator = this._generatorFunction.call(this._receiver); |
this._receiver = |
this._generatorFunction = void 0; |
this._next(void 0); |
}; |
|
PromiseSpawn.prototype._continue = function PromiseSpawn$_continue(result) { |
if (result === errorObj) { |
this._generator = void 0; |
var trace = errors.canAttach(result.e) |
? result.e : new Error(result.e + ""); |
this._promise._attachExtraTrace(trace); |
this._promise._reject(result.e, trace); |
return; |
} |
|
var value = result.value; |
if (result.done === true) { |
this._generator = void 0; |
if (!this._promise._tryFollow(value)) { |
this._promise._fulfill(value); |
} |
} else { |
var maybePromise = cast(value, void 0); |
if (!(maybePromise instanceof Promise)) { |
maybePromise = |
promiseFromYieldHandler(maybePromise, this._yieldHandlers); |
if (maybePromise === null) { |
this._throw(new TypeError("A value was yielded that could not be treated as a promise")); |
return; |
} |
} |
maybePromise._then( |
this._next, |
this._throw, |
void 0, |
this, |
null |
); |
} |
}; |
|
PromiseSpawn.prototype._throw = function PromiseSpawn$_throw(reason) { |
if (errors.canAttach(reason)) |
this._promise._attachExtraTrace(reason); |
this._continue( |
tryCatch1(this._generator["throw"], this._generator, reason) |
); |
}; |
|
PromiseSpawn.prototype._next = function PromiseSpawn$_next(value) { |
this._continue( |
tryCatch1(this._generator.next, this._generator, value) |
); |
}; |
|
Promise.coroutine = |
function Promise$Coroutine(generatorFunction, options) { |
if (typeof generatorFunction !== "function") { |
throw new TypeError("generatorFunction must be a function"); |
} |
var yieldHandler = Object(options).yieldHandler; |
var PromiseSpawn$ = PromiseSpawn; |
return function () { |
var generator = generatorFunction.apply(this, arguments); |
var spawn = new PromiseSpawn$(void 0, void 0, yieldHandler); |
spawn._generator = generator; |
spawn._next(void 0); |
return spawn.promise(); |
}; |
}; |
|
Promise.coroutine.addYieldHandler = function(fn) { |
if (typeof fn !== "function") throw new TypeError("fn must be a function"); |
yieldHandlers.push(fn); |
}; |
|
Promise.spawn = function Promise$Spawn(generatorFunction) { |
deprecated("Promise.spawn is deprecated. Use Promise.coroutine instead."); |
if (typeof generatorFunction !== "function") { |
return apiRejection("generatorFunction must be a function"); |
} |
var spawn = new PromiseSpawn(generatorFunction, this); |
var ret = spawn.promise(); |
spawn._run(Promise.spawn); |
return ret; |
}; |
}; |
|
},{"./errors.js":10,"./util.js":35}],16:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
module.exports = |
function(Promise, PromiseArray, cast, INTERNAL) { |
var util = require("./util.js"); |
var canEvaluate = util.canEvaluate; |
var tryCatch1 = util.tryCatch1; |
var errorObj = util.errorObj; |
|
|
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 = [void 0]; |
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]; |
var ret = tryCatch1(handler, void 0, this); |
if (ret === errorObj) { |
promise._rejectUnchecked(ret.e); |
} else if (!promise._tryFollow(ret)) { |
promise._fulfillUnchecked(ret); |
} |
} else { |
this.now = now; |
} |
}; |
} |
|
|
|
|
Promise.join = function Promise$Join() { |
var last = arguments.length - 1; |
var fn; |
if (last > 0 && typeof arguments[last] === "function") { |
fn = arguments[last]; |
if (last < 6 && canEvaluate) { |
var ret = new Promise(INTERNAL); |
ret._setTrace(void 0); |
var holder = new Holder(last, fn); |
var reject = ret._reject; |
var callbacks = thenCallbacks; |
for (var i = 0; i < last; ++i) { |
var maybePromise = cast(arguments[i], void 0); |
if (maybePromise instanceof Promise) { |
if (maybePromise.isPending()) { |
maybePromise._then(callbacks[i], reject, |
void 0, ret, holder); |
} else if (maybePromise.isFulfilled()) { |
callbacks[i].call(ret, |
maybePromise._settledValue, holder); |
} else { |
ret._reject(maybePromise._settledValue); |
maybePromise._unsetRejectionIsUnhandled(); |
} |
} 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];} |
var ret = new PromiseArray(args).promise(); |
return fn !== void 0 ? ret.spread(fn) : ret; |
}; |
|
}; |
|
},{"./util.js":35}],17:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
module.exports = function(Promise, PromiseArray, apiRejection, cast, INTERNAL) { |
var util = require("./util.js"); |
var tryCatch3 = util.tryCatch3; |
var errorObj = util.errorObj; |
var PENDING = {}; |
var EMPTY_ARRAY = []; |
|
function MappingPromiseArray(promises, fn, limit, _filter) { |
this.constructor$(promises); |
this._callback = fn; |
this._preservedValues = _filter === INTERNAL |
? new Array(this.length()) |
: null; |
this._limit = limit; |
this._inFlight = 0; |
this._queue = limit >= 1 ? [] : EMPTY_ARRAY; |
this._init$(void 0, -2); |
} |
util.inherits(MappingPromiseArray, PromiseArray); |
|
MappingPromiseArray.prototype._init = function MappingPromiseArray$_init() {}; |
|
MappingPromiseArray.prototype._promiseFulfilled = |
function MappingPromiseArray$_promiseFulfilled(value, index) { |
var values = this._values; |
if (values === null) return; |
|
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._boundTo; |
var ret = tryCatch3(callback, receiver, value, index, length); |
if (ret === errorObj) return this._reject(ret.e); |
|
var maybePromise = cast(ret, void 0); |
if (maybePromise instanceof Promise) { |
if (maybePromise.isPending()) { |
if (limit >= 1) this._inFlight++; |
values[index] = PENDING; |
return maybePromise._proxyPromiseArray(this, index); |
} else if (maybePromise.isFulfilled()) { |
ret = maybePromise.value(); |
} else { |
maybePromise._unsetRejectionIsUnhandled(); |
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 MappingPromiseArray$_drainQueue() { |
var queue = this._queue; |
var limit = this._limit; |
var values = this._values; |
while (queue.length > 0 && this._inFlight < limit) { |
var index = queue.pop(); |
this._promiseFulfilled(values[index], index); |
} |
}; |
|
MappingPromiseArray.prototype._filter = |
function MappingPromiseArray$_filter(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 MappingPromiseArray$preserveValues() { |
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 Promise$map(fn, options) { |
if (typeof fn !== "function") return apiRejection("fn must be a function"); |
|
return map(this, fn, options, null).promise(); |
}; |
|
Promise.map = function Promise$Map(promises, fn, options, _filter) { |
if (typeof fn !== "function") return apiRejection("fn must be a function"); |
return map(promises, fn, options, _filter).promise(); |
}; |
|
|
}; |
|
},{"./util.js":35}],18:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
module.exports = function(Promise) { |
var util = require("./util.js"); |
var async = require("./async.js"); |
var tryCatch2 = util.tryCatch2; |
var tryCatch1 = util.tryCatch1; |
var errorObj = util.errorObj; |
|
function thrower(r) { |
throw r; |
} |
|
function Promise$_spreadAdapter(val, receiver) { |
if (!util.isArray(val)) return Promise$_successAdapter(val, receiver); |
var ret = util.tryCatchApply(this, [null].concat(val), receiver); |
if (ret === errorObj) { |
async.invokeLater(thrower, void 0, ret.e); |
} |
} |
|
function Promise$_successAdapter(val, receiver) { |
var nodeback = this; |
var ret = val === void 0 |
? tryCatch1(nodeback, receiver, null) |
: tryCatch2(nodeback, receiver, null, val); |
if (ret === errorObj) { |
async.invokeLater(thrower, void 0, ret.e); |
} |
} |
function Promise$_errorAdapter(reason, receiver) { |
var nodeback = this; |
var ret = tryCatch1(nodeback, receiver, reason); |
if (ret === errorObj) { |
async.invokeLater(thrower, void 0, ret.e); |
} |
} |
|
Promise.prototype.nodeify = function Promise$nodeify(nodeback, options) { |
if (typeof nodeback == "function") { |
var adapter = Promise$_successAdapter; |
if (options !== void 0 && Object(options).spread) { |
adapter = Promise$_spreadAdapter; |
} |
this._then( |
adapter, |
Promise$_errorAdapter, |
void 0, |
nodeback, |
this._boundTo |
); |
} |
return this; |
}; |
}; |
|
},{"./async.js":2,"./util.js":35}],19:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
module.exports = function(Promise, PromiseArray) { |
var util = require("./util.js"); |
var async = require("./async.js"); |
var errors = require("./errors.js"); |
var tryCatch1 = util.tryCatch1; |
var errorObj = util.errorObj; |
|
Promise.prototype.progressed = function Promise$progressed(handler) { |
return this._then(void 0, void 0, handler, void 0, void 0); |
}; |
|
Promise.prototype._progress = function Promise$_progress(progressValue) { |
if (this._isFollowingOrFulfilledOrRejected()) return; |
this._progressUnchecked(progressValue); |
|
}; |
|
Promise.prototype._progressHandlerAt = |
function Promise$_progressHandlerAt(index) { |
return index === 0 |
? this._progressHandler0 |
: this[(index << 2) + index - 5 + 2]; |
}; |
|
Promise.prototype._doProgressWith = |
function Promise$_doProgressWith(progression) { |
var progressValue = progression.value; |
var handler = progression.handler; |
var promise = progression.promise; |
var receiver = progression.receiver; |
|
var ret = tryCatch1(handler, receiver, progressValue); |
if (ret === errorObj) { |
if (ret.e != null && |
ret.e.name !== "StopProgressPropagation") { |
var trace = errors.canAttach(ret.e) |
? ret.e : new Error(ret.e + ""); |
promise._attachExtraTrace(trace); |
promise._progress(ret.e); |
} |
} else if (ret instanceof Promise) { |
ret._then(promise._progress, null, null, promise, void 0); |
} else { |
promise._progress(ret); |
} |
}; |
|
|
Promise.prototype._progressUnchecked = |
function Promise$_progressUnchecked(progressValue) { |
if (!this.isPending()) return; |
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 Promise && receiver._isProxied()) { |
receiver._progressUnchecked(progressValue); |
} else if (receiver instanceof PromiseArray) { |
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,"./errors.js":10,"./util.js":35}],20:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
var old; |
if (typeof Promise !== "undefined") old = Promise; |
function noConflict(bluebird) { |
try { if (Promise === bluebird) Promise = old; } |
catch (e) {} |
return bluebird; |
} |
module.exports = function() { |
var util = require("./util.js"); |
var async = require("./async.js"); |
var errors = require("./errors.js"); |
|
var INTERNAL = function(){}; |
var APPLY = {}; |
var NEXT_FILTER = {e: null}; |
|
var cast = require("./thenables.js")(Promise, INTERNAL); |
var PromiseArray = require("./promise_array.js")(Promise, INTERNAL, cast); |
var CapturedTrace = require("./captured_trace.js")(); |
var CatchFilter = require("./catch_filter.js")(NEXT_FILTER); |
var PromiseResolver = require("./promise_resolver.js"); |
|
var isArray = util.isArray; |
|
var errorObj = util.errorObj; |
var tryCatch1 = util.tryCatch1; |
var tryCatch2 = util.tryCatch2; |
var tryCatchApply = util.tryCatchApply; |
var RangeError = errors.RangeError; |
var TypeError = errors.TypeError; |
var CancellationError = errors.CancellationError; |
var TimeoutError = errors.TimeoutError; |
var OperationalError = errors.OperationalError; |
var originatesFromRejection = errors.originatesFromRejection; |
var markAsOriginatingFromRejection = errors.markAsOriginatingFromRejection; |
var canAttach = errors.canAttach; |
var thrower = util.thrower; |
var apiRejection = require("./errors_api_rejection")(Promise); |
|
|
var makeSelfResolutionError = function Promise$_makeSelfResolutionError() { |
return new TypeError("circular promise resolution chain"); |
}; |
|
function Promise(resolver) { |
if (typeof resolver !== "function") { |
throw new TypeError("the promise constructor requires a resolver function"); |
} |
if (this.constructor !== Promise) { |
throw new TypeError("the promise constructor cannot be invoked directly"); |
} |
this._bitField = 0; |
this._fulfillmentHandler0 = void 0; |
this._rejectionHandler0 = void 0; |
this._promise0 = void 0; |
this._receiver0 = void 0; |
this._settledValue = void 0; |
this._boundTo = void 0; |
if (resolver !== INTERNAL) this._resolveFromResolver(resolver); |
} |
|
Promise.prototype.bind = function Promise$bind(thisArg) { |
var ret = new Promise(INTERNAL); |
ret._follow(this); |
ret._propagateFrom(this, 2 | 1); |
ret._setBoundTo(thisArg); |
return ret; |
}; |
|
Promise.prototype.toString = function Promise$toString() { |
return "[object Promise]"; |
}; |
|
Promise.prototype.caught = Promise.prototype["catch"] = |
function Promise$catch(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 { |
var catchFilterTypeError = |
new TypeError( |
"A catch filter must be an error constructor " |
+ "or a filter function"); |
|
this._attachExtraTrace(catchFilterTypeError); |
async.invoke(this._reject, this, catchFilterTypeError); |
return; |
} |
} |
catchInstances.length = j; |
fn = arguments[i]; |
|
this._resetTrace(); |
var catchFilter = new CatchFilter(catchInstances, fn, this); |
return this._then(void 0, catchFilter.doFilter, void 0, |
catchFilter, void 0); |
} |
return this._then(void 0, fn, void 0, void 0, void 0); |
}; |
|
Promise.prototype.then = |
function Promise$then(didFulfill, didReject, didProgress) { |
return this._then(didFulfill, didReject, didProgress, |
void 0, void 0); |
}; |
|
|
Promise.prototype.done = |
function Promise$done(didFulfill, didReject, didProgress) { |
var promise = this._then(didFulfill, didReject, didProgress, |
void 0, void 0); |
promise._setIsFinal(); |
}; |
|
Promise.prototype.spread = function Promise$spread(didFulfill, didReject) { |
return this._then(didFulfill, didReject, void 0, |
APPLY, void 0); |
}; |
|
Promise.prototype.isCancellable = function Promise$isCancellable() { |
return !this.isResolved() && |
this._cancellable(); |
}; |
|
Promise.prototype.toJSON = function Promise$toJSON() { |
var ret = { |
isFulfilled: false, |
isRejected: false, |
fulfillmentValue: void 0, |
rejectionReason: void 0 |
}; |
if (this.isFulfilled()) { |
ret.fulfillmentValue = this._settledValue; |
ret.isFulfilled = true; |
} else if (this.isRejected()) { |
ret.rejectionReason = this._settledValue; |
ret.isRejected = true; |
} |
return ret; |
}; |
|
Promise.prototype.all = function Promise$all() { |
return new PromiseArray(this).promise(); |
}; |
|
|
Promise.is = function Promise$Is(val) { |
return val instanceof Promise; |
}; |
|
Promise.all = function Promise$All(promises) { |
return new PromiseArray(promises).promise(); |
}; |
|
Promise.prototype.error = function Promise$_error(fn) { |
return this.caught(originatesFromRejection, fn); |
}; |
|
Promise.prototype._resolveFromSyncValue = |
function Promise$_resolveFromSyncValue(value) { |
if (value === errorObj) { |
this._cleanValues(); |
this._setRejected(); |
this._settledValue = value.e; |
this._ensurePossibleRejectionHandled(); |
} else { |
var maybePromise = cast(value, void 0); |
if (maybePromise instanceof Promise) { |
this._follow(maybePromise); |
} else { |
this._cleanValues(); |
this._setFulfilled(); |
this._settledValue = value; |
} |
} |
}; |
|
Promise.method = function Promise$_Method(fn) { |
if (typeof fn !== "function") { |
throw new TypeError("fn must be a function"); |
} |
return function Promise$_method() { |
var value; |
switch(arguments.length) { |
case 0: value = tryCatch1(fn, this, void 0); break; |
case 1: value = tryCatch1(fn, this, arguments[0]); break; |
case 2: value = tryCatch2(fn, this, arguments[0], arguments[1]); break; |
default: |
var $_len = arguments.length;var args = new Array($_len); for(var $_i = 0; $_i < $_len; ++$_i) {args[$_i] = arguments[$_i];} |
value = tryCatchApply(fn, args, this); break; |
} |
var ret = new Promise(INTERNAL); |
ret._setTrace(void 0); |
ret._resolveFromSyncValue(value); |
return ret; |
}; |
}; |
|
Promise.attempt = Promise["try"] = function Promise$_Try(fn, args, ctx) { |
if (typeof fn !== "function") { |
return apiRejection("fn must be a function"); |
} |
var value = isArray(args) |
? tryCatchApply(fn, args, ctx) |
: tryCatch1(fn, ctx, args); |
|
var ret = new Promise(INTERNAL); |
ret._setTrace(void 0); |
ret._resolveFromSyncValue(value); |
return ret; |
}; |
|
Promise.defer = Promise.pending = function Promise$Defer() { |
var promise = new Promise(INTERNAL); |
promise._setTrace(void 0); |
return new PromiseResolver(promise); |
}; |
|
Promise.bind = function Promise$Bind(thisArg) { |
var ret = new Promise(INTERNAL); |
ret._setTrace(void 0); |
ret._setFulfilled(); |
ret._setBoundTo(thisArg); |
return ret; |
}; |
|
Promise.cast = function Promise$_Cast(obj) { |
var ret = cast(obj, void 0); |
if (!(ret instanceof Promise)) { |
var val = ret; |
ret = new Promise(INTERNAL); |
ret._setTrace(void 0); |
ret._setFulfilled(); |
ret._cleanValues(); |
ret._settledValue = val; |
} |
return ret; |
}; |
|
Promise.resolve = Promise.fulfilled = Promise.cast; |
|
Promise.reject = Promise.rejected = function Promise$Reject(reason) { |
var ret = new Promise(INTERNAL); |
ret._setTrace(void 0); |
markAsOriginatingFromRejection(reason); |
ret._cleanValues(); |
ret._setRejected(); |
ret._settledValue = reason; |
if (!canAttach(reason)) { |
var trace = new Error(reason + ""); |
ret._setCarriedStackTrace(trace); |
} |
ret._ensurePossibleRejectionHandled(); |
return ret; |
}; |
|
Promise.onPossiblyUnhandledRejection = |
function Promise$OnPossiblyUnhandledRejection(fn) { |
CapturedTrace.possiblyUnhandledRejection = typeof fn === "function" |
? fn : void 0; |
}; |
|
var unhandledRejectionHandled; |
Promise.onUnhandledRejectionHandled = |
function Promise$onUnhandledRejectionHandled(fn) { |
unhandledRejectionHandled = typeof fn === "function" ? fn : void 0; |
}; |
|
var debugging = false || !!( |
typeof process !== "undefined" && |
typeof process.execPath === "string" && |
typeof process.env === "object" && |
(process.env["BLUEBIRD_DEBUG"] || |
process.env["NODE_ENV"] === "development") |
); |
|
|
Promise.longStackTraces = function Promise$LongStackTraces() { |
if (async.haveItemsQueued() && |
debugging === false |
) { |
throw new Error("cannot enable long stack traces after promises have been created"); |
} |
debugging = CapturedTrace.isSupported(); |
}; |
|
Promise.hasLongStackTraces = function Promise$HasLongStackTraces() { |
return debugging && CapturedTrace.isSupported(); |
}; |
|
Promise.prototype._then = |
function Promise$_then( |
didFulfill, |
didReject, |
didProgress, |
receiver, |
internalData |
) { |
var haveInternalData = internalData !== void 0; |
var ret = haveInternalData ? internalData : new Promise(INTERNAL); |
|
if (!haveInternalData) { |
if (debugging) { |
var haveSameContext = this._peekContext() === this._traceParent; |
ret._traceParent = haveSameContext ? this._traceParent : this; |
} |
ret._propagateFrom(this, 7); |
} |
|
var callbackIndex = |
this._addCallbacks(didFulfill, didReject, didProgress, ret, receiver); |
|
if (this.isResolved()) { |
async.invoke(this._queueSettleAt, this, callbackIndex); |
} |
|
return ret; |
}; |
|
Promise.prototype._length = function Promise$_length() { |
return this._bitField & 262143; |
}; |
|
Promise.prototype._isFollowingOrFulfilledOrRejected = |
function Promise$_isFollowingOrFulfilledOrRejected() { |
return (this._bitField & 939524096) > 0; |
}; |
|
Promise.prototype._isFollowing = function Promise$_isFollowing() { |
return (this._bitField & 536870912) === 536870912; |
}; |
|
Promise.prototype._setLength = function Promise$_setLength(len) { |
this._bitField = (this._bitField & -262144) | |
(len & 262143); |
}; |
|
Promise.prototype._setFulfilled = function Promise$_setFulfilled() { |
this._bitField = this._bitField | 268435456; |
}; |
|
Promise.prototype._setRejected = function Promise$_setRejected() { |
this._bitField = this._bitField | 134217728; |
}; |
|
Promise.prototype._setFollowing = function Promise$_setFollowing() { |
this._bitField = this._bitField | 536870912; |
}; |
|
Promise.prototype._setIsFinal = function Promise$_setIsFinal() { |
this._bitField = this._bitField | 33554432; |
}; |
|
Promise.prototype._isFinal = function Promise$_isFinal() { |
return (this._bitField & 33554432) > 0; |
}; |
|
Promise.prototype._cancellable = function Promise$_cancellable() { |
return (this._bitField & 67108864) > 0; |
}; |
|
Promise.prototype._setCancellable = function Promise$_setCancellable() { |
this._bitField = this._bitField | 67108864; |
}; |
|
Promise.prototype._unsetCancellable = function Promise$_unsetCancellable() { |
this._bitField = this._bitField & (~67108864); |
}; |
|
Promise.prototype._setRejectionIsUnhandled = |
function Promise$_setRejectionIsUnhandled() { |
this._bitField = this._bitField | 2097152; |
}; |
|
Promise.prototype._unsetRejectionIsUnhandled = |
function Promise$_unsetRejectionIsUnhandled() { |
this._bitField = this._bitField & (~2097152); |
if (this._isUnhandledRejectionNotified()) { |
this._unsetUnhandledRejectionIsNotified(); |
this._notifyUnhandledRejectionIsHandled(); |
} |
}; |
|
Promise.prototype._isRejectionUnhandled = |
function Promise$_isRejectionUnhandled() { |
return (this._bitField & 2097152) > 0; |
}; |
|
Promise.prototype._setUnhandledRejectionIsNotified = |
function Promise$_setUnhandledRejectionIsNotified() { |
this._bitField = this._bitField | 524288; |
}; |
|
Promise.prototype._unsetUnhandledRejectionIsNotified = |
function Promise$_unsetUnhandledRejectionIsNotified() { |
this._bitField = this._bitField & (~524288); |
}; |
|
Promise.prototype._isUnhandledRejectionNotified = |
function Promise$_isUnhandledRejectionNotified() { |
return (this._bitField & 524288) > 0; |
}; |
|
Promise.prototype._setCarriedStackTrace = |
function Promise$_setCarriedStackTrace(capturedTrace) { |
this._bitField = this._bitField | 1048576; |
this._fulfillmentHandler0 = capturedTrace; |
}; |
|
Promise.prototype._unsetCarriedStackTrace = |
function Promise$_unsetCarriedStackTrace() { |
this._bitField = this._bitField & (~1048576); |
this._fulfillmentHandler0 = void 0; |
}; |
|
Promise.prototype._isCarryingStackTrace = |
function Promise$_isCarryingStackTrace() { |
return (this._bitField & 1048576) > 0; |
}; |
|
Promise.prototype._getCarriedStackTrace = |
function Promise$_getCarriedStackTrace() { |
return this._isCarryingStackTrace() |
? this._fulfillmentHandler0 |
: void 0; |
}; |
|
Promise.prototype._receiverAt = function Promise$_receiverAt(index) { |
var ret = index === 0 |
? this._receiver0 |
: this[(index << 2) + index - 5 + 4]; |
if (this._isBound() && ret === void 0) { |
return this._boundTo; |
} |
return ret; |
}; |
|
Promise.prototype._promiseAt = function Promise$_promiseAt(index) { |
return index === 0 |
? this._promise0 |
: this[(index << 2) + index - 5 + 3]; |
}; |
|
Promise.prototype._fulfillmentHandlerAt = |
function Promise$_fulfillmentHandlerAt(index) { |
return index === 0 |
? this._fulfillmentHandler0 |
: this[(index << 2) + index - 5 + 0]; |
}; |
|
Promise.prototype._rejectionHandlerAt = |
function Promise$_rejectionHandlerAt(index) { |
return index === 0 |
? this._rejectionHandler0 |
: this[(index << 2) + index - 5 + 1]; |
}; |
|
Promise.prototype._addCallbacks = function Promise$_addCallbacks( |
fulfill, |
reject, |
progress, |
promise, |
receiver |
) { |
var index = this._length(); |
|
if (index >= 262143 - 5) { |
index = 0; |
this._setLength(0); |
} |
|
if (index === 0) { |
this._promise0 = promise; |
if (receiver !== void 0) this._receiver0 = receiver; |
if (typeof fulfill === "function" && !this._isCarryingStackTrace()) |
this._fulfillmentHandler0 = fulfill; |
if (typeof reject === "function") this._rejectionHandler0 = reject; |
if (typeof progress === "function") this._progressHandler0 = progress; |
} else { |
var base = (index << 2) + index - 5; |
this[base + 3] = promise; |
this[base + 4] = receiver; |
this[base + 0] = typeof fulfill === "function" |
? fulfill : void 0; |
this[base + 1] = typeof reject === "function" |
? reject : void 0; |
this[base + 2] = typeof progress === "function" |
? progress : void 0; |
} |
this._setLength(index + 1); |
return index; |
}; |
|
Promise.prototype._setProxyHandlers = |
function Promise$_setProxyHandlers(receiver, promiseSlotValue) { |
var index = this._length(); |
|
if (index >= 262143 - 5) { |
index = 0; |
this._setLength(0); |
} |
if (index === 0) { |
this._promise0 = promiseSlotValue; |
this._receiver0 = receiver; |
} else { |
var base = (index << 2) + index - 5; |
this[base + 3] = promiseSlotValue; |
this[base + 4] = receiver; |
this[base + 0] = |
this[base + 1] = |
this[base + 2] = void 0; |
} |
this._setLength(index + 1); |
}; |
|
Promise.prototype._proxyPromiseArray = |
function Promise$_proxyPromiseArray(promiseArray, index) { |
this._setProxyHandlers(promiseArray, index); |
}; |
|
Promise.prototype._proxyPromise = function Promise$_proxyPromise(promise) { |
promise._setProxied(); |
this._setProxyHandlers(promise, -1); |
}; |
|
Promise.prototype._setBoundTo = function Promise$_setBoundTo(obj) { |
if (obj !== void 0) { |
this._bitField = this._bitField | 8388608; |
this._boundTo = obj; |
} else { |
this._bitField = this._bitField & (~8388608); |
} |
}; |
|
Promise.prototype._isBound = function Promise$_isBound() { |
return (this._bitField & 8388608) === 8388608; |
}; |
|
Promise.prototype._resolveFromResolver = |
function Promise$_resolveFromResolver(resolver) { |
var promise = this; |
this._setTrace(void 0); |
this._pushContext(); |
|
function Promise$_resolver(val) { |
if (promise._tryFollow(val)) { |
return; |
} |
promise._fulfill(val); |
} |
function Promise$_rejecter(val) { |
var trace = canAttach(val) ? val : new Error(val + ""); |
promise._attachExtraTrace(trace); |
markAsOriginatingFromRejection(val); |
promise._reject(val, trace === val ? void 0 : trace); |
} |
var r = tryCatch2(resolver, void 0, Promise$_resolver, Promise$_rejecter); |
this._popContext(); |
|
if (r !== void 0 && r === errorObj) { |
var e = r.e; |
var trace = canAttach(e) ? e : new Error(e + ""); |
promise._reject(e, trace); |
} |
}; |
|
Promise.prototype._spreadSlowCase = |
function Promise$_spreadSlowCase(targetFn, promise, values, boundTo) { |
var promiseForAll = new PromiseArray(values).promise(); |
var promise2 = promiseForAll._then(function() { |
return targetFn.apply(boundTo, arguments); |
}, void 0, void 0, APPLY, void 0); |
promise._follow(promise2); |
}; |
|
Promise.prototype._callSpread = |
function Promise$_callSpread(handler, promise, value) { |
var boundTo = this._boundTo; |
if (isArray(value)) { |
for (var i = 0, len = value.length; i < len; ++i) { |
if (cast(value[i], void 0) instanceof Promise) { |
this._spreadSlowCase(handler, promise, value, boundTo); |
return; |
} |
} |
} |
promise._pushContext(); |
return tryCatchApply(handler, value, boundTo); |
}; |
|
Promise.prototype._callHandler = |
function Promise$_callHandler( |
handler, receiver, promise, value) { |
var x; |
if (receiver === APPLY && !this.isRejected()) { |
x = this._callSpread(handler, promise, value); |
} else { |
promise._pushContext(); |
x = tryCatch1(handler, receiver, value); |
} |
promise._popContext(); |
return x; |
}; |
|
Promise.prototype._settlePromiseFromHandler = |
function Promise$_settlePromiseFromHandler( |
handler, receiver, value, promise |
) { |
if (!(promise instanceof Promise)) { |
handler.call(receiver, value, promise); |
return; |
} |
var x = this._callHandler(handler, receiver, promise, value); |
if (promise._isFollowing()) return; |
|
if (x === errorObj || x === promise || x === NEXT_FILTER) { |
var err = x === promise |
? makeSelfResolutionError() |
: x.e; |
var trace = canAttach(err) ? err : new Error(err + ""); |
if (x !== NEXT_FILTER) promise._attachExtraTrace(trace); |
promise._rejectUnchecked(err, trace); |
} else { |
var castValue = cast(x, promise); |
if (castValue instanceof Promise) { |
if (castValue.isRejected() && |
!castValue._isCarryingStackTrace() && |
!canAttach(castValue._settledValue)) { |
var trace = new Error(castValue._settledValue + ""); |
promise._attachExtraTrace(trace); |
castValue._setCarriedStackTrace(trace); |
} |
promise._follow(castValue); |
promise._propagateFrom(castValue, 1); |
} else { |
promise._fulfillUnchecked(x); |
} |
} |
}; |
|
Promise.prototype._follow = |
function Promise$_follow(promise) { |
this._setFollowing(); |
|
if (promise.isPending()) { |
this._propagateFrom(promise, 1); |
promise._proxyPromise(this); |
} else if (promise.isFulfilled()) { |
this._fulfillUnchecked(promise._settledValue); |
} else { |
this._rejectUnchecked(promise._settledValue, |
promise._getCarriedStackTrace()); |
} |
|
if (promise._isRejectionUnhandled()) promise._unsetRejectionIsUnhandled(); |
|
if (debugging && |
promise._traceParent == null) { |
promise._traceParent = this; |
} |
}; |
|
Promise.prototype._tryFollow = |
function Promise$_tryFollow(value) { |
if (this._isFollowingOrFulfilledOrRejected() || |
value === this) { |
return false; |
} |
var maybePromise = cast(value, void 0); |
if (!(maybePromise instanceof Promise)) { |
return false; |
} |
this._follow(maybePromise); |
return true; |
}; |
|
Promise.prototype._resetTrace = function Promise$_resetTrace() { |
if (debugging) { |
this._trace = new CapturedTrace(this._peekContext() === void 0); |
} |
}; |
|
Promise.prototype._setTrace = function Promise$_setTrace(parent) { |
if (debugging) { |
var context = this._peekContext(); |
this._traceParent = context; |
var isTopLevel = context === void 0; |
if (parent !== void 0 && |
parent._traceParent === context) { |
this._trace = parent._trace; |
} else { |
this._trace = new CapturedTrace(isTopLevel); |
} |
} |
return this; |
}; |
|
Promise.prototype._attachExtraTrace = |
function Promise$_attachExtraTrace(error) { |
if (debugging) { |
var promise = this; |
var stack = error.stack; |
stack = typeof stack === "string" ? stack.split("\n") : []; |
CapturedTrace.protectErrorMessageNewlines(stack); |
var headerLineCount = 1; |
var combinedTraces = 1; |
while(promise != null && |
promise._trace != null) { |
stack = CapturedTrace.combine( |
stack, |
promise._trace.stack.split("\n") |
); |
promise = promise._traceParent; |
combinedTraces++; |
} |
|
var stackTraceLimit = Error.stackTraceLimit || 10; |
var max = (stackTraceLimit + headerLineCount) * combinedTraces; |
var len = stack.length; |
if (len > max) { |
stack.length = max; |
} |
|
if (len > 0) |
stack[0] = stack[0].split("\u0002\u0000\u0001").join("\n"); |
|
if (stack.length <= headerLineCount) { |
error.stack = "(No stack trace)"; |
} else { |
error.stack = stack.join("\n"); |
} |
} |
}; |
|
Promise.prototype._cleanValues = function Promise$_cleanValues() { |
if (this._cancellable()) { |
this._cancellationParent = void 0; |
} |
}; |
|
Promise.prototype._propagateFrom = |
function Promise$_propagateFrom(parent, flags) { |
if ((flags & 1) > 0 && parent._cancellable()) { |
this._setCancellable(); |
this._cancellationParent = parent; |
} |
if ((flags & 4) > 0) { |
this._setBoundTo(parent._boundTo); |
} |
if ((flags & 2) > 0) { |
this._setTrace(parent); |
} |
}; |
|
Promise.prototype._fulfill = function Promise$_fulfill(value) { |
if (this._isFollowingOrFulfilledOrRejected()) return; |
this._fulfillUnchecked(value); |
}; |
|
Promise.prototype._reject = |
function Promise$_reject(reason, carriedStackTrace) { |
if (this._isFollowingOrFulfilledOrRejected()) return; |
this._rejectUnchecked(reason, carriedStackTrace); |
}; |
|
Promise.prototype._settlePromiseAt = function Promise$_settlePromiseAt(index) { |
var handler = this.isFulfilled() |
? this._fulfillmentHandlerAt(index) |
: this._rejectionHandlerAt(index); |
|
var value = this._settledValue; |
var receiver = this._receiverAt(index); |
var promise = this._promiseAt(index); |
|
if (typeof handler === "function") { |
this._settlePromiseFromHandler(handler, receiver, value, promise); |
} else { |
var done = false; |
var isFulfilled = this.isFulfilled(); |
if (receiver !== void 0) { |
if (receiver instanceof Promise && |
receiver._isProxied()) { |
receiver._unsetProxied(); |
|
if (isFulfilled) receiver._fulfillUnchecked(value); |
else receiver._rejectUnchecked(value, |
this._getCarriedStackTrace()); |
done = true; |
} else if (receiver instanceof PromiseArray) { |
if (isFulfilled) receiver._promiseFulfilled(value, promise); |
else receiver._promiseRejected(value, promise); |
done = true; |
} |
} |
|
if (!done) { |
if (isFulfilled) promise._fulfill(value); |
else promise._reject(value, this._getCarriedStackTrace()); |
} |
} |
|
if (index >= 256) { |
this._queueGC(); |
} |
}; |
|
Promise.prototype._isProxied = function Promise$_isProxied() { |
return (this._bitField & 4194304) === 4194304; |
}; |
|
Promise.prototype._setProxied = function Promise$_setProxied() { |
this._bitField = this._bitField | 4194304; |
}; |
|
Promise.prototype._unsetProxied = function Promise$_unsetProxied() { |
this._bitField = this._bitField & (~4194304); |
}; |
|
Promise.prototype._isGcQueued = function Promise$_isGcQueued() { |
return (this._bitField & -1073741824) === -1073741824; |
}; |
|
Promise.prototype._setGcQueued = function Promise$_setGcQueued() { |
this._bitField = this._bitField | -1073741824; |
}; |
|
Promise.prototype._unsetGcQueued = function Promise$_unsetGcQueued() { |
this._bitField = this._bitField & (~-1073741824); |
}; |
|
Promise.prototype._queueGC = function Promise$_queueGC() { |
if (this._isGcQueued()) return; |
this._setGcQueued(); |
async.invokeLater(this._gc, this, void 0); |
}; |
|
Promise.prototype._gc = function Promise$gc() { |
var len = this._length() * 5; |
for (var i = 0; i < len; i++) { |
delete this[i]; |
} |
this._setLength(0); |
this._unsetGcQueued(); |
}; |
|
Promise.prototype._queueSettleAt = function Promise$_queueSettleAt(index) { |
if (this._isRejectionUnhandled()) this._unsetRejectionIsUnhandled(); |
async.invoke(this._settlePromiseAt, this, index); |
}; |
|
Promise.prototype._fulfillUnchecked = |
function Promise$_fulfillUnchecked(value) { |
if (!this.isPending()) return; |
if (value === this) { |
var err = makeSelfResolutionError(); |
this._attachExtraTrace(err); |
return this._rejectUnchecked(err, void 0); |
} |
this._cleanValues(); |
this._setFulfilled(); |
this._settledValue = value; |
var len = this._length(); |
|
if (len > 0) { |
async.invoke(this._settlePromises, this, len); |
} |
}; |
|
Promise.prototype._rejectUncheckedCheckError = |
function Promise$_rejectUncheckedCheckError(reason) { |
var trace = canAttach(reason) ? reason : new Error(reason + ""); |
this._rejectUnchecked(reason, trace === reason ? void 0 : trace); |
}; |
|
Promise.prototype._rejectUnchecked = |
function Promise$_rejectUnchecked(reason, trace) { |
if (!this.isPending()) return; |
if (reason === this) { |
var err = makeSelfResolutionError(); |
this._attachExtraTrace(err); |
return this._rejectUnchecked(err); |
} |
this._cleanValues(); |
this._setRejected(); |
this._settledValue = reason; |
|
if (this._isFinal()) { |
async.invokeLater(thrower, void 0, trace === void 0 ? reason : trace); |
return; |
} |
var len = this._length(); |
|
if (trace !== void 0) this._setCarriedStackTrace(trace); |
|
if (len > 0) { |
async.invoke(this._rejectPromises, this, null); |
} else { |
this._ensurePossibleRejectionHandled(); |
} |
}; |
|
Promise.prototype._rejectPromises = function Promise$_rejectPromises() { |
this._settlePromises(); |
this._unsetCarriedStackTrace(); |
}; |
|
Promise.prototype._settlePromises = function Promise$_settlePromises() { |
var len = this._length(); |
for (var i = 0; i < len; i++) { |
this._settlePromiseAt(i); |
} |
}; |
|
Promise.prototype._ensurePossibleRejectionHandled = |
function Promise$_ensurePossibleRejectionHandled() { |
this._setRejectionIsUnhandled(); |
if (CapturedTrace.possiblyUnhandledRejection !== void 0) { |
async.invokeLater(this._notifyUnhandledRejection, this, void 0); |
} |
}; |
|
Promise.prototype._notifyUnhandledRejectionIsHandled = |
function Promise$_notifyUnhandledRejectionIsHandled() { |
if (typeof unhandledRejectionHandled === "function") { |
async.invokeLater(unhandledRejectionHandled, void 0, this); |
} |
}; |
|
Promise.prototype._notifyUnhandledRejection = |
function Promise$_notifyUnhandledRejection() { |
if (this._isRejectionUnhandled()) { |
var reason = this._settledValue; |
var trace = this._getCarriedStackTrace(); |
|
this._setUnhandledRejectionIsNotified(); |
|
if (trace !== void 0) { |
this._unsetCarriedStackTrace(); |
reason = trace; |
} |
if (typeof CapturedTrace.possiblyUnhandledRejection === "function") { |
CapturedTrace.possiblyUnhandledRejection(reason, this); |
} |
} |
}; |
|
var contextStack = []; |
Promise.prototype._peekContext = function Promise$_peekContext() { |
var lastIndex = contextStack.length - 1; |
if (lastIndex >= 0) { |
return contextStack[lastIndex]; |
} |
return void 0; |
|
}; |
|
Promise.prototype._pushContext = function Promise$_pushContext() { |
if (!debugging) return; |
contextStack.push(this); |
}; |
|
Promise.prototype._popContext = function Promise$_popContext() { |
if (!debugging) return; |
contextStack.pop(); |
}; |
|
Promise.noConflict = function Promise$NoConflict() { |
return noConflict(Promise); |
}; |
|
Promise.setScheduler = function(fn) { |
if (typeof fn !== "function") throw new TypeError("fn must be a function"); |
async._schedule = fn; |
}; |
|
if (!CapturedTrace.isSupported()) { |
Promise.longStackTraces = function(){}; |
debugging = false; |
} |
|
Promise._makeSelfResolutionError = makeSelfResolutionError; |
require("./finally.js")(Promise, NEXT_FILTER, cast); |
require("./direct_resolve.js")(Promise); |
require("./synchronous_inspection.js")(Promise); |
require("./join.js")(Promise, PromiseArray, cast, INTERNAL); |
Promise.RangeError = RangeError; |
Promise.CancellationError = CancellationError; |
Promise.TimeoutError = TimeoutError; |
Promise.TypeError = TypeError; |
Promise.OperationalError = OperationalError; |
Promise.RejectionError = OperationalError; |
Promise.AggregateError = errors.AggregateError; |
|
util.toFastProperties(Promise); |
util.toFastProperties(Promise.prototype); |
Promise.Promise = Promise; |
require('./timers.js')(Promise,INTERNAL,cast); |
require('./race.js')(Promise,INTERNAL,cast); |
require('./call_get.js')(Promise); |
require('./generators.js')(Promise,apiRejection,INTERNAL,cast); |
require('./map.js')(Promise,PromiseArray,apiRejection,cast,INTERNAL); |
require('./nodeify.js')(Promise); |
require('./promisify.js')(Promise,INTERNAL); |
require('./props.js')(Promise,PromiseArray,cast); |
require('./reduce.js')(Promise,PromiseArray,apiRejection,cast,INTERNAL); |
require('./settle.js')(Promise,PromiseArray); |
require('./some.js')(Promise,PromiseArray,apiRejection); |
require('./progress.js')(Promise,PromiseArray); |
require('./cancel.js')(Promise,INTERNAL); |
require('./filter.js')(Promise,INTERNAL); |
require('./any.js')(Promise,PromiseArray); |
require('./each.js')(Promise,INTERNAL); |
require('./using.js')(Promise,apiRejection,cast); |
|
Promise.prototype = Promise.prototype; |
return Promise; |
|
}; |
|
},{"./any.js":1,"./async.js":2,"./call_get.js":4,"./cancel.js":5,"./captured_trace.js":6,"./catch_filter.js":7,"./direct_resolve.js":8,"./each.js":9,"./errors.js":10,"./errors_api_rejection":11,"./filter.js":13,"./finally.js":14,"./generators.js":15,"./join.js":16,"./map.js":17,"./nodeify.js":18,"./progress.js":19,"./promise_array.js":21,"./promise_resolver.js":22,"./promisify.js":23,"./props.js":24,"./race.js":26,"./reduce.js":27,"./settle.js":29,"./some.js":30,"./synchronous_inspection.js":31,"./thenables.js":32,"./timers.js":33,"./using.js":34,"./util.js":35}],21:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
module.exports = function(Promise, INTERNAL, cast) { |
var canAttach = require("./errors.js").canAttach; |
var util = require("./util.js"); |
var isArray = util.isArray; |
|
function toResolutionValue(val) { |
switch(val) { |
case -1: return void 0; |
case -2: return []; |
case -3: return {}; |
} |
} |
|
function PromiseArray(values) { |
var promise = this._promise = new Promise(INTERNAL); |
var parent = void 0; |
if (values instanceof Promise) { |
parent = values; |
promise._propagateFrom(parent, 1 | 4); |
} |
promise._setTrace(parent); |
this._values = values; |
this._length = 0; |
this._totalResolved = 0; |
this._init(void 0, -2); |
} |
PromiseArray.prototype.length = function PromiseArray$length() { |
return this._length; |
}; |
|
PromiseArray.prototype.promise = function PromiseArray$promise() { |
return this._promise; |
}; |
|
PromiseArray.prototype._init = |
function PromiseArray$_init(_, resolveValueIfEmpty) { |
var values = cast(this._values, void 0); |
if (values instanceof Promise) { |
this._values = values; |
values._setBoundTo(this._promise._boundTo); |
if (values.isFulfilled()) { |
values = values._settledValue; |
if (!isArray(values)) { |
var err = new Promise.TypeError("expecting an array, a promise or a thenable"); |
this.__hardReject__(err); |
return; |
} |
} else if (values.isPending()) { |
values._then( |
PromiseArray$_init, |
this._reject, |
void 0, |
this, |
resolveValueIfEmpty |
); |
return; |
} else { |
values._unsetRejectionIsUnhandled(); |
this._reject(values._settledValue); |
return; |
} |
} else if (!isArray(values)) { |
var err = new Promise.TypeError("expecting an array, a promise or a thenable"); |
this.__hardReject__(err); |
return; |
} |
|
if (values.length === 0) { |
if (resolveValueIfEmpty === -5) { |
this._resolveEmptyArray(); |
} |
else { |
this._resolve(toResolutionValue(resolveValueIfEmpty)); |
} |
return; |
} |
var len = this.getActualLength(values.length); |
var newLen = len; |
var newValues = this.shouldCopyValues() ? new Array(len) : this._values; |
var isDirectScanNeeded = false; |
for (var i = 0; i < len; ++i) { |
var maybePromise = cast(values[i], void 0); |
if (maybePromise instanceof Promise) { |
if (maybePromise.isPending()) { |
maybePromise._proxyPromiseArray(this, i); |
} else { |
maybePromise._unsetRejectionIsUnhandled(); |
isDirectScanNeeded = true; |
} |
} else { |
isDirectScanNeeded = true; |
} |
newValues[i] = maybePromise; |
} |
this._values = newValues; |
this._length = newLen; |
if (isDirectScanNeeded) { |
this._scanDirectValues(len); |
} |
}; |
|
PromiseArray.prototype._settlePromiseAt = |
function PromiseArray$_settlePromiseAt(index) { |
var value = this._values[index]; |
if (!(value instanceof Promise)) { |
this._promiseFulfilled(value, index); |
} else if (value.isFulfilled()) { |
this._promiseFulfilled(value._settledValue, index); |
} else if (value.isRejected()) { |
this._promiseRejected(value._settledValue, index); |
} |
}; |
|
PromiseArray.prototype._scanDirectValues = |
function PromiseArray$_scanDirectValues(len) { |
for (var i = 0; i < len; ++i) { |
if (this._isResolved()) { |
break; |
} |
this._settlePromiseAt(i); |
} |
}; |
|
PromiseArray.prototype._isResolved = function PromiseArray$_isResolved() { |
return this._values === null; |
}; |
|
PromiseArray.prototype._resolve = function PromiseArray$_resolve(value) { |
this._values = null; |
this._promise._fulfill(value); |
}; |
|
PromiseArray.prototype.__hardReject__ = |
PromiseArray.prototype._reject = function PromiseArray$_reject(reason) { |
this._values = null; |
var trace = canAttach(reason) ? reason : new Error(reason + ""); |
this._promise._attachExtraTrace(trace); |
this._promise._reject(reason, trace); |
}; |
|
PromiseArray.prototype._promiseProgressed = |
function PromiseArray$_promiseProgressed(progressValue, index) { |
if (this._isResolved()) return; |
this._promise._progress({ |
index: index, |
value: progressValue |
}); |
}; |
|
|
PromiseArray.prototype._promiseFulfilled = |
function PromiseArray$_promiseFulfilled(value, index) { |
if (this._isResolved()) return; |
this._values[index] = value; |
var totalResolved = ++this._totalResolved; |
if (totalResolved >= this._length) { |
this._resolve(this._values); |
} |
}; |
|
PromiseArray.prototype._promiseRejected = |
function PromiseArray$_promiseRejected(reason, index) { |
if (this._isResolved()) return; |
this._totalResolved++; |
this._reject(reason); |
}; |
|
PromiseArray.prototype.shouldCopyValues = |
function PromiseArray$_shouldCopyValues() { |
return true; |
}; |
|
PromiseArray.prototype.getActualLength = |
function PromiseArray$getActualLength(len) { |
return len; |
}; |
|
return PromiseArray; |
}; |
|
},{"./errors.js":10,"./util.js":35}],22:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
var util = require("./util.js"); |
var maybeWrapAsError = util.maybeWrapAsError; |
var errors = require("./errors.js"); |
var TimeoutError = errors.TimeoutError; |
var OperationalError = errors.OperationalError; |
var async = require("./async.js"); |
var haveGetters = util.haveGetters; |
var es5 = require("./es5.js"); |
|
function isUntypedError(obj) { |
return obj instanceof Error && |
es5.getPrototypeOf(obj) === Error.prototype; |
} |
|
function wrapAsOperationalError(obj) { |
var ret; |
if (isUntypedError(obj)) { |
ret = new OperationalError(obj); |
} else { |
ret = obj; |
} |
errors.markAsOriginatingFromRejection(ret); |
return ret; |
} |
|
function nodebackForPromise(promise) { |
function PromiseResolver$_callback(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; |
} |
return PromiseResolver$_callback; |
} |
|
|
var PromiseResolver; |
if (!haveGetters) { |
PromiseResolver = function PromiseResolver(promise) { |
this.promise = promise; |
this.asCallback = nodebackForPromise(promise); |
this.callback = this.asCallback; |
}; |
} |
else { |
PromiseResolver = function PromiseResolver(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 PromiseResolver$toString() { |
return "[object PromiseResolver]"; |
}; |
|
PromiseResolver.prototype.resolve = |
PromiseResolver.prototype.fulfill = function PromiseResolver$resolve(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."); |
} |
|
var promise = this.promise; |
if (promise._tryFollow(value)) { |
return; |
} |
async.invoke(promise._fulfill, promise, value); |
}; |
|
PromiseResolver.prototype.reject = function PromiseResolver$reject(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."); |
} |
|
var promise = this.promise; |
errors.markAsOriginatingFromRejection(reason); |
var trace = errors.canAttach(reason) ? reason : new Error(reason + ""); |
promise._attachExtraTrace(trace); |
async.invoke(promise._reject, promise, reason); |
if (trace !== reason) { |
async.invoke(this._setCarriedStackTrace, this, trace); |
} |
}; |
|
PromiseResolver.prototype.progress = |
function PromiseResolver$progress(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."); |
} |
async.invoke(this.promise._progress, this.promise, value); |
}; |
|
PromiseResolver.prototype.cancel = function PromiseResolver$cancel() { |
async.invoke(this.promise.cancel, this.promise, void 0); |
}; |
|
PromiseResolver.prototype.timeout = function PromiseResolver$timeout() { |
this.reject(new TimeoutError("timeout")); |
}; |
|
PromiseResolver.prototype.isResolved = function PromiseResolver$isResolved() { |
return this.promise.isResolved(); |
}; |
|
PromiseResolver.prototype.toJSON = function PromiseResolver$toJSON() { |
return this.promise.toJSON(); |
}; |
|
PromiseResolver.prototype._setCarriedStackTrace = |
function PromiseResolver$_setCarriedStackTrace(trace) { |
if (this.promise.isRejected()) { |
this.promise._setCarriedStackTrace(trace); |
} |
}; |
|
module.exports = PromiseResolver; |
|
},{"./async.js":2,"./errors.js":10,"./es5.js":12,"./util.js":35}],23:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
module.exports = function(Promise, INTERNAL) { |
var THIS = {}; |
var util = require("./util.js"); |
var nodebackForPromise = require("./promise_resolver.js") |
._nodebackForPromise; |
var withAppended = util.withAppended; |
var maybeWrapAsError = util.maybeWrapAsError; |
var canEvaluate = util.canEvaluate; |
var TypeError = require("./errors").TypeError; |
var defaultSuffix = "Async"; |
var defaultFilter = function(name, func) { |
return util.isIdentifier(name) && |
name.charAt(0) !== "_" && |
!util.isClass(func); |
}; |
var defaultPromisified = {__isPromisified__: true}; |
|
|
function escapeIdentRegex(str) { |
return str.replace(/([$])/, "\\$"); |
} |
|
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 '"+suffix+"'-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]; |
if (typeof value === "function" && |
!isPromisified(value) && |
!hasPromisified(obj, key, suffix) && |
filter(key, value, obj)) { |
ret.push(key, value); |
} |
} |
checkValid(ret, suffix, suffixRegexp); |
return ret; |
} |
|
function switchCaseArgumentOrder(likelyArgumentCount) { |
var ret = [likelyArgumentCount]; |
var min = Math.max(0, likelyArgumentCount - 1 - 5); |
for(var i = likelyArgumentCount - 1; i >= min; --i) { |
if (i === likelyArgumentCount) continue; |
ret.push(i); |
} |
for(var i = likelyArgumentCount + 1; i <= 5; ++i) { |
ret.push(i); |
} |
return ret; |
} |
|
function argumentSequence(argumentCount) { |
return util.filledRange(argumentCount, "arguments[", "]"); |
} |
|
function parameterDeclaration(parameterCount) { |
return util.filledRange(parameterCount, "_arg", ""); |
} |
|
function parameterCount(fn) { |
if (typeof fn.length === "number") { |
return Math.max(Math.min(fn.length, 1023 + 1), 0); |
} |
return 0; |
} |
|
function generatePropertyAccess(key) { |
if (util.isIdentifier(key)) { |
return "." + key; |
} |
else return "['" + key.replace(/(['\\])/g, "\\$1") + "']"; |
} |
|
function makeNodePromisifiedEval(callback, receiver, originalName, fn, suffix) { |
var newParameterCount = Math.max(0, parameterCount(fn) - 1); |
var argumentOrder = switchCaseArgumentOrder(newParameterCount); |
var callbackName = |
(typeof originalName === "string" && util.isIdentifier(originalName) |
? originalName + suffix |
: "promisified"); |
|
function generateCallForArgumentCount(count) { |
var args = argumentSequence(count).join(", "); |
var comma = count > 0 ? ", " : ""; |
var ret; |
if (typeof callback === "string") { |
ret = " \n\ |
this.method(args, fn); \n\ |
break; \n\ |
".replace(".method", generatePropertyAccess(callback)); |
} else if (receiver === THIS) { |
ret = " \n\ |
callback.call(this, args, fn); \n\ |
break; \n\ |
"; |
} else if (receiver !== void 0) { |
ret = " \n\ |
callback.call(receiver, args, fn); \n\ |
break; \n\ |
"; |
} else { |
ret = " \n\ |
callback(args, fn); \n\ |
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]); |
} |
var codeForCall; |
if (typeof callback === "string") { |
codeForCall = " \n\ |
this.property.apply(this, args); \n\ |
" |
.replace(".property", generatePropertyAccess(callback)); |
} else if (receiver === THIS) { |
codeForCall = " \n\ |
callback.apply(this, args); \n\ |
"; |
} else { |
codeForCall = " \n\ |
callback.apply(receiver, args); \n\ |
"; |
} |
|
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] = fn; \n\ |
[CodeForCall] \n\ |
break; \n\ |
".replace("[CodeForCall]", codeForCall); |
return ret; |
} |
|
return new Function("Promise", |
"callback", |
"receiver", |
"withAppended", |
"maybeWrapAsError", |
"nodebackForPromise", |
"INTERNAL"," \n\ |
var ret = function FunctionName(Parameters) { \n\ |
'use strict'; \n\ |
var len = arguments.length; \n\ |
var promise = new Promise(INTERNAL); \n\ |
promise._setTrace(void 0); \n\ |
var fn = nodebackForPromise(promise); \n\ |
try { \n\ |
switch(len) { \n\ |
[CodeForSwitchCase] \n\ |
} \n\ |
} catch (e) { \n\ |
var wrapped = maybeWrapAsError(e); \n\ |
promise._attachExtraTrace(wrapped); \n\ |
promise._reject(wrapped); \n\ |
} \n\ |
return promise; \n\ |
}; \n\ |
ret.__isPromisified__ = true; \n\ |
return ret; \n\ |
" |
.replace("FunctionName", callbackName) |
.replace("Parameters", parameterDeclaration(newParameterCount)) |
.replace("[CodeForSwitchCase]", generateArgumentSwitchCase()))( |
Promise, |
callback, |
receiver, |
withAppended, |
maybeWrapAsError, |
nodebackForPromise, |
INTERNAL |
); |
} |
|
function makeNodePromisifiedClosure(callback, receiver) { |
function promisified() { |
var _receiver = receiver; |
if (receiver === THIS) _receiver = this; |
if (typeof callback === "string") { |
callback = _receiver[callback]; |
} |
var promise = new Promise(INTERNAL); |
promise._setTrace(void 0); |
var fn = nodebackForPromise(promise); |
try { |
callback.apply(_receiver, withAppended(arguments, fn)); |
} catch(e) { |
var wrapped = maybeWrapAsError(e); |
promise._attachExtraTrace(wrapped); |
promise._reject(wrapped); |
} |
return promise; |
} |
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; |
obj[promisifiedKey] = promisifier === makeNodePromisified |
? makeNodePromisified(key, THIS, key, fn, suffix) |
: promisifier(fn); |
} |
util.toFastProperties(obj); |
return obj; |
} |
|
function promisify(callback, receiver) { |
return makeNodePromisified(callback, receiver, void 0, callback); |
} |
|
Promise.promisify = function Promise$Promisify(fn, receiver) { |
if (typeof fn !== "function") { |
throw new TypeError("fn must be a function"); |
} |
if (isPromisified(fn)) { |
return fn; |
} |
return promisify(fn, arguments.length < 2 ? THIS : receiver); |
}; |
|
Promise.promisifyAll = function Promise$PromisifyAll(target, options) { |
if (typeof target !== "function" && typeof target !== "object") { |
throw new TypeError("the target of promisifyAll must be an object or a function"); |
} |
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"); |
} |
|
var keys = util.inheritedDataKeys(target, {includeHidden: true}); |
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":10,"./promise_resolver.js":22,"./util.js":35}],24:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
module.exports = function(Promise, PromiseArray, cast) { |
var util = require("./util.js"); |
var apiRejection = require("./errors_api_rejection")(Promise); |
var isObject = util.isObject; |
var es5 = require("./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 PropertiesPromiseArray$_init() { |
this._init$(void 0, -3) ; |
}; |
|
PropertiesPromiseArray.prototype._promiseFulfilled = |
function PropertiesPromiseArray$_promiseFulfilled(value, index) { |
if (this._isResolved()) return; |
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 PropertiesPromiseArray$_promiseProgressed(value, index) { |
if (this._isResolved()) return; |
|
this._promise._progress({ |
key: this._values[index + this.length()], |
value: value |
}); |
}; |
|
PropertiesPromiseArray.prototype.shouldCopyValues = |
function PropertiesPromiseArray$_shouldCopyValues() { |
return false; |
}; |
|
PropertiesPromiseArray.prototype.getActualLength = |
function PropertiesPromiseArray$getActualLength(len) { |
return len >> 1; |
}; |
|
function Promise$_Props(promises) { |
var ret; |
var castValue = cast(promises, void 0); |
|
if (!isObject(castValue)) { |
return apiRejection("cannot await properties of a non-object"); |
} else if (castValue instanceof Promise) { |
ret = castValue._then(Promise.props, void 0, void 0, void 0, void 0); |
} else { |
ret = new PropertiesPromiseArray(castValue).promise(); |
} |
|
if (castValue instanceof Promise) { |
ret._propagateFrom(castValue, 4); |
} |
return ret; |
} |
|
Promise.prototype.props = function Promise$props() { |
return Promise$_Props(this); |
}; |
|
Promise.props = function Promise$Props(promises) { |
return Promise$_Props(promises); |
}; |
}; |
|
},{"./errors_api_rejection":11,"./es5.js":12,"./util.js":35}],25:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
function arrayCopy(src, srcIndex, dst, dstIndex, len) { |
for (var j = 0; j < len; ++j) { |
dst[j + dstIndex] = src[j + srcIndex]; |
} |
} |
|
function Queue(capacity) { |
this._capacity = capacity; |
this._length = 0; |
this._front = 0; |
this._makeCapacity(); |
} |
|
Queue.prototype._willBeOverCapacity = |
function Queue$_willBeOverCapacity(size) { |
return this._capacity < size; |
}; |
|
Queue.prototype._pushOne = function Queue$_pushOne(arg) { |
var length = this.length(); |
this._checkCapacity(length + 1); |
var i = (this._front + length) & (this._capacity - 1); |
this[i] = arg; |
this._length = length + 1; |
}; |
|
Queue.prototype.push = function Queue$push(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 Queue$shift() { |
var front = this._front, |
ret = this[front]; |
|
this[front] = void 0; |
this._front = (front + 1) & (this._capacity - 1); |
this._length--; |
return ret; |
}; |
|
Queue.prototype.length = function Queue$length() { |
return this._length; |
}; |
|
Queue.prototype._makeCapacity = function Queue$_makeCapacity() { |
var len = this._capacity; |
for (var i = 0; i < len; ++i) { |
this[i] = void 0; |
} |
}; |
|
Queue.prototype._checkCapacity = function Queue$_checkCapacity(size) { |
if (this._capacity < size) { |
this._resizeTo(this._capacity << 3); |
} |
}; |
|
Queue.prototype._resizeTo = function Queue$_resizeTo(capacity) { |
var oldFront = this._front; |
var oldCapacity = this._capacity; |
var oldQueue = new Array(oldCapacity); |
var length = this.length(); |
|
arrayCopy(this, 0, oldQueue, 0, oldCapacity); |
this._capacity = capacity; |
this._makeCapacity(); |
this._front = 0; |
if (oldFront + length <= oldCapacity) { |
arrayCopy(oldQueue, oldFront, this, 0, length); |
} else { var lengthBeforeWrapping = |
length - ((oldFront + length) & (oldCapacity - 1)); |
|
arrayCopy(oldQueue, oldFront, this, 0, lengthBeforeWrapping); |
arrayCopy(oldQueue, 0, this, lengthBeforeWrapping, |
length - lengthBeforeWrapping); |
} |
}; |
|
module.exports = Queue; |
|
},{}],26:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
module.exports = function(Promise, INTERNAL, cast) { |
var apiRejection = require("./errors_api_rejection.js")(Promise); |
var isArray = require("./util.js").isArray; |
|
var raceLater = function Promise$_raceLater(promise) { |
return promise.then(function(array) { |
return Promise$_Race(array, promise); |
}); |
}; |
|
var hasOwn = {}.hasOwnProperty; |
function Promise$_Race(promises, parent) { |
var maybePromise = cast(promises, void 0); |
|
if (maybePromise instanceof Promise) { |
return raceLater(maybePromise); |
} else if (!isArray(promises)) { |
return apiRejection("expecting an array, a promise or a thenable"); |
} |
|
var ret = new Promise(INTERNAL); |
if (parent !== void 0) { |
ret._propagateFrom(parent, 7); |
} else { |
ret._setTrace(void 0); |
} |
var fulfill = ret._fulfill; |
var reject = ret._reject; |
for (var i = 0, len = promises.length; i < len; ++i) { |
var val = promises[i]; |
|
if (val === void 0 && !(hasOwn.call(promises, i))) { |
continue; |
} |
|
Promise.cast(val)._then(fulfill, reject, void 0, ret, null); |
} |
return ret; |
} |
|
Promise.race = function Promise$Race(promises) { |
return Promise$_Race(promises, void 0); |
}; |
|
Promise.prototype.race = function Promise$race() { |
return Promise$_Race(this, void 0); |
}; |
|
}; |
|
},{"./errors_api_rejection.js":11,"./util.js":35}],27:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
module.exports = function(Promise, PromiseArray, apiRejection, cast, INTERNAL) { |
var util = require("./util.js"); |
var tryCatch4 = util.tryCatch4; |
var tryCatch3 = util.tryCatch3; |
var errorObj = util.errorObj; |
function ReductionPromiseArray(promises, fn, accum, _each) { |
this.constructor$(promises); |
this._preservedValues = _each === INTERNAL ? [] : null; |
this._zerothIsAccum = (accum === void 0); |
this._gotAccum = false; |
this._reducingIndex = (this._zerothIsAccum ? 1 : 0); |
this._valuesPhase = undefined; |
|
var maybePromise = cast(accum, void 0); |
var rejected = false; |
var isPromise = maybePromise instanceof Promise; |
if (isPromise) { |
if (maybePromise.isPending()) { |
maybePromise._proxyPromiseArray(this, -1); |
} else if (maybePromise.isFulfilled()) { |
accum = maybePromise.value(); |
this._gotAccum = true; |
} else { |
maybePromise._unsetRejectionIsUnhandled(); |
this._reject(maybePromise.reason()); |
rejected = true; |
} |
} |
if (!(isPromise || this._zerothIsAccum)) this._gotAccum = true; |
this._callback = fn; |
this._accum = accum; |
if (!rejected) this._init$(void 0, -5); |
} |
util.inherits(ReductionPromiseArray, PromiseArray); |
|
ReductionPromiseArray.prototype._init = |
function ReductionPromiseArray$_init() {}; |
|
ReductionPromiseArray.prototype._resolveEmptyArray = |
function ReductionPromiseArray$_resolveEmptyArray() { |
if (this._gotAccum || this._zerothIsAccum) { |
this._resolve(this._preservedValues !== null |
? [] : this._accum); |
} |
}; |
|
ReductionPromiseArray.prototype._promiseFulfilled = |
function ReductionPromiseArray$_promiseFulfilled(value, index) { |
var values = this._values; |
if (values === null) return; |
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 = Array(length); |
for (valuesPhaseIndex=0; valuesPhaseIndex<length; ++valuesPhaseIndex) { |
valuesPhase[valuesPhaseIndex] = 0; |
} |
} |
valuesPhaseIndex = valuesPhase[index]; |
|
if (index === 0 && this._zerothIsAccum) { |
if (!gotAccum) { |
this._accum = value; |
this._gotAccum = gotAccum = true; |
} |
valuesPhase[index] = ((valuesPhaseIndex === 0) |
? 1 : 2); |
} else if (index === -1) { |
if (!gotAccum) { |
this._accum = value; |
this._gotAccum = gotAccum = true; |
} |
} else { |
if (valuesPhaseIndex === 0) { |
valuesPhase[index] = 1; |
} |
else { |
valuesPhase[index] = 2; |
if (gotAccum) { |
this._accum = value; |
} |
} |
} |
if (!gotAccum) return; |
|
var callback = this._callback; |
var receiver = this._promise._boundTo; |
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]; |
if (value instanceof Promise) { |
if (value.isFulfilled()) { |
value = value._settledValue; |
} else if (value.isPending()) { |
return; |
} else { |
value._unsetRejectionIsUnhandled(); |
return this._reject(value.reason()); |
} |
} |
|
if (isEach) { |
preservedValues.push(value); |
ret = tryCatch3(callback, receiver, value, i, length); |
} |
else { |
ret = tryCatch4(callback, receiver, this._accum, value, i, length); |
} |
|
if (ret === errorObj) return this._reject(ret.e); |
|
var maybePromise = cast(ret, void 0); |
if (maybePromise instanceof Promise) { |
if (maybePromise.isPending()) { |
valuesPhase[i] = 4; |
return maybePromise._proxyPromiseArray(this, i); |
} else if (maybePromise.isFulfilled()) { |
ret = maybePromise.value(); |
} else { |
maybePromise._unsetRejectionIsUnhandled(); |
return this._reject(maybePromise.reason()); |
} |
} |
|
this._reducingIndex = i + 1; |
this._accum = ret; |
} |
|
if (this._reducingIndex < length) return; |
this._resolve(isEach ? preservedValues : this._accum); |
}; |
|
function reduce(promises, fn, initialValue, _each) { |
if (typeof fn !== "function") return apiRejection("fn must be a function"); |
var array = new ReductionPromiseArray(promises, fn, initialValue, _each); |
return array.promise(); |
} |
|
Promise.prototype.reduce = function Promise$reduce(fn, initialValue) { |
return reduce(this, fn, initialValue, null); |
}; |
|
Promise.reduce = function Promise$Reduce(promises, fn, initialValue, _each) { |
return reduce(promises, fn, initialValue, _each); |
}; |
}; |
|
},{"./util.js":35}],28:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
var schedule; |
var _MutationObserver; |
if (typeof process === "object" && typeof process.version === "string") { |
schedule = function Promise$_Scheduler(fn) { |
process.nextTick(fn); |
}; |
} |
else if ((typeof MutationObserver !== "undefined" && |
(_MutationObserver = MutationObserver)) || |
(typeof WebKitMutationObserver !== "undefined" && |
(_MutationObserver = WebKitMutationObserver))) { |
schedule = (function() { |
var div = document.createElement("div"); |
var queuedFn = void 0; |
var observer = new _MutationObserver( |
function Promise$_Scheduler() { |
var fn = queuedFn; |
queuedFn = void 0; |
fn(); |
} |
); |
observer.observe(div, { |
attributes: true |
}); |
return function Promise$_Scheduler(fn) { |
queuedFn = fn; |
div.setAttribute("class", "foo"); |
}; |
|
})(); |
} |
else if (typeof setTimeout !== "undefined") { |
schedule = function Promise$_Scheduler(fn) { |
setTimeout(fn, 0); |
}; |
} |
else throw new Error("no async scheduler available"); |
module.exports = schedule; |
|
},{}],29:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
module.exports = |
function(Promise, PromiseArray) { |
var PromiseInspection = Promise.PromiseInspection; |
var util = require("./util.js"); |
|
function SettledPromiseArray(values) { |
this.constructor$(values); |
} |
util.inherits(SettledPromiseArray, PromiseArray); |
|
SettledPromiseArray.prototype._promiseResolved = |
function SettledPromiseArray$_promiseResolved(index, inspection) { |
this._values[index] = inspection; |
var totalResolved = ++this._totalResolved; |
if (totalResolved >= this._length) { |
this._resolve(this._values); |
} |
}; |
|
SettledPromiseArray.prototype._promiseFulfilled = |
function SettledPromiseArray$_promiseFulfilled(value, index) { |
if (this._isResolved()) return; |
var ret = new PromiseInspection(); |
ret._bitField = 268435456; |
ret._settledValue = value; |
this._promiseResolved(index, ret); |
}; |
SettledPromiseArray.prototype._promiseRejected = |
function SettledPromiseArray$_promiseRejected(reason, index) { |
if (this._isResolved()) return; |
var ret = new PromiseInspection(); |
ret._bitField = 134217728; |
ret._settledValue = reason; |
this._promiseResolved(index, ret); |
}; |
|
Promise.settle = function Promise$Settle(promises) { |
return new SettledPromiseArray(promises).promise(); |
}; |
|
Promise.prototype.settle = function Promise$settle() { |
return new SettledPromiseArray(this).promise(); |
}; |
}; |
|
},{"./util.js":35}],30:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
module.exports = |
function(Promise, PromiseArray, apiRejection) { |
var util = require("./util.js"); |
var RangeError = require("./errors.js").RangeError; |
var AggregateError = require("./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 SomePromiseArray$_init() { |
if (!this._initialized) { |
return; |
} |
if (this._howMany === 0) { |
this._resolve([]); |
return; |
} |
this._init$(void 0, -5); |
var isArrayResolved = isArray(this._values); |
if (!this._isResolved() && |
isArrayResolved && |
this._howMany > this._canPossiblyFulfill()) { |
this._reject(this._getRangeError(this.length())); |
} |
}; |
|
SomePromiseArray.prototype.init = function SomePromiseArray$init() { |
this._initialized = true; |
this._init(); |
}; |
|
SomePromiseArray.prototype.setUnwrap = function SomePromiseArray$setUnwrap() { |
this._unwrap = true; |
}; |
|
SomePromiseArray.prototype.howMany = function SomePromiseArray$howMany() { |
return this._howMany; |
}; |
|
SomePromiseArray.prototype.setHowMany = |
function SomePromiseArray$setHowMany(count) { |
if (this._isResolved()) return; |
this._howMany = count; |
}; |
|
SomePromiseArray.prototype._promiseFulfilled = |
function SomePromiseArray$_promiseFulfilled(value) { |
if (this._isResolved()) return; |
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 SomePromiseArray$_promiseRejected(reason) { |
if (this._isResolved()) return; |
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 SomePromiseArray$_fulfilled() { |
return this._totalResolved; |
}; |
|
SomePromiseArray.prototype._rejected = function SomePromiseArray$_rejected() { |
return this._values.length - this.length(); |
}; |
|
SomePromiseArray.prototype._addRejected = |
function SomePromiseArray$_addRejected(reason) { |
this._values.push(reason); |
}; |
|
SomePromiseArray.prototype._addFulfilled = |
function SomePromiseArray$_addFulfilled(value) { |
this._values[this._totalResolved++] = value; |
}; |
|
SomePromiseArray.prototype._canPossiblyFulfill = |
function SomePromiseArray$_canPossiblyFulfill() { |
return this.length() - this._rejected(); |
}; |
|
SomePromiseArray.prototype._getRangeError = |
function SomePromiseArray$_getRangeError(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 SomePromiseArray$_resolveEmptyArray() { |
this._reject(this._getRangeError(0)); |
}; |
|
function Promise$_Some(promises, howMany) { |
if ((howMany | 0) !== howMany || howMany < 0) { |
return apiRejection("expecting a positive integer"); |
} |
var ret = new SomePromiseArray(promises); |
var promise = ret.promise(); |
if (promise.isRejected()) { |
return promise; |
} |
ret.setHowMany(howMany); |
ret.init(); |
return promise; |
} |
|
Promise.some = function Promise$Some(promises, howMany) { |
return Promise$_Some(promises, howMany); |
}; |
|
Promise.prototype.some = function Promise$some(howMany) { |
return Promise$_Some(this, howMany); |
}; |
|
Promise._SomePromiseArray = SomePromiseArray; |
}; |
|
},{"./errors.js":10,"./util.js":35}],31:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
module.exports = function(Promise) { |
function PromiseInspection(promise) { |
if (promise !== void 0) { |
this._bitField = promise._bitField; |
this._settledValue = promise.isResolved() |
? promise._settledValue |
: void 0; |
} |
else { |
this._bitField = 0; |
this._settledValue = void 0; |
} |
} |
|
PromiseInspection.prototype.isFulfilled = |
Promise.prototype.isFulfilled = function Promise$isFulfilled() { |
return (this._bitField & 268435456) > 0; |
}; |
|
PromiseInspection.prototype.isRejected = |
Promise.prototype.isRejected = function Promise$isRejected() { |
return (this._bitField & 134217728) > 0; |
}; |
|
PromiseInspection.prototype.isPending = |
Promise.prototype.isPending = function Promise$isPending() { |
return (this._bitField & 402653184) === 0; |
}; |
|
PromiseInspection.prototype.value = |
Promise.prototype.value = function Promise$value() { |
if (!this.isFulfilled()) { |
throw new TypeError("cannot get fulfillment value of a non-fulfilled promise"); |
} |
return this._settledValue; |
}; |
|
PromiseInspection.prototype.error = |
PromiseInspection.prototype.reason = |
Promise.prototype.reason = function Promise$reason() { |
if (!this.isRejected()) { |
throw new TypeError("cannot get rejection reason of a non-rejected promise"); |
} |
return this._settledValue; |
}; |
|
PromiseInspection.prototype.isResolved = |
Promise.prototype.isResolved = function Promise$isResolved() { |
return (this._bitField & 402653184) > 0; |
}; |
|
Promise.PromiseInspection = PromiseInspection; |
}; |
|
},{}],32:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
module.exports = function(Promise, INTERNAL) { |
var util = require("./util.js"); |
var canAttach = require("./errors.js").canAttach; |
var errorObj = util.errorObj; |
var isObject = util.isObject; |
|
function getThen(obj) { |
try { |
return obj.then; |
} |
catch(e) { |
errorObj.e = e; |
return errorObj; |
} |
} |
|
function Promise$_Cast(obj, originalPromise) { |
if (isObject(obj)) { |
if (obj instanceof Promise) { |
return obj; |
} |
else if (isAnyBluebirdPromise(obj)) { |
var ret = new Promise(INTERNAL); |
ret._setTrace(void 0); |
obj._then( |
ret._fulfillUnchecked, |
ret._rejectUncheckedCheckError, |
ret._progressUnchecked, |
ret, |
null |
); |
ret._setFollowing(); |
return ret; |
} |
var then = getThen(obj); |
if (then === errorObj) { |
if (originalPromise !== void 0 && canAttach(then.e)) { |
originalPromise._attachExtraTrace(then.e); |
} |
return Promise.reject(then.e); |
} else if (typeof then === "function") { |
return Promise$_doThenable(obj, then, originalPromise); |
} |
} |
return obj; |
} |
|
var hasProp = {}.hasOwnProperty; |
function isAnyBluebirdPromise(obj) { |
return hasProp.call(obj, "_promise0"); |
} |
|
function Promise$_doThenable(x, then, originalPromise) { |
var resolver = Promise.defer(); |
var called = false; |
try { |
then.call( |
x, |
Promise$_resolveFromThenable, |
Promise$_rejectFromThenable, |
Promise$_progressFromThenable |
); |
} catch(e) { |
if (!called) { |
called = true; |
var trace = canAttach(e) ? e : new Error(e + ""); |
if (originalPromise !== void 0) { |
originalPromise._attachExtraTrace(trace); |
} |
resolver.promise._reject(e, trace); |
} |
} |
return resolver.promise; |
|
function Promise$_resolveFromThenable(y) { |
if (called) return; |
called = true; |
|
if (x === y) { |
var e = Promise._makeSelfResolutionError(); |
if (originalPromise !== void 0) { |
originalPromise._attachExtraTrace(e); |
} |
resolver.promise._reject(e, void 0); |
return; |
} |
resolver.resolve(y); |
} |
|
function Promise$_rejectFromThenable(r) { |
if (called) return; |
called = true; |
var trace = canAttach(r) ? r : new Error(r + ""); |
if (originalPromise !== void 0) { |
originalPromise._attachExtraTrace(trace); |
} |
resolver.promise._reject(r, trace); |
} |
|
function Promise$_progressFromThenable(v) { |
if (called) return; |
var promise = resolver.promise; |
if (typeof promise._progress === "function") { |
promise._progress(v); |
} |
} |
} |
|
return Promise$_Cast; |
}; |
|
},{"./errors.js":10,"./util.js":35}],33:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
var _setTimeout = function(fn, ms) { |
var len = arguments.length; |
var arg0 = arguments[2]; |
var arg1 = arguments[3]; |
var arg2 = len >= 5 ? arguments[4] : void 0; |
setTimeout(function() { |
fn(arg0, arg1, arg2); |
}, ms); |
}; |
|
module.exports = function(Promise, INTERNAL, cast) { |
var util = require("./util.js"); |
var errors = require("./errors.js"); |
var apiRejection = require("./errors_api_rejection")(Promise); |
var TimeoutError = Promise.TimeoutError; |
|
var afterTimeout = function Promise$_afterTimeout(promise, message, ms) { |
if (!promise.isPending()) return; |
if (typeof message !== "string") { |
message = "operation timed out after" + " " + ms + " ms" |
} |
var err = new TimeoutError(message); |
errors.markAsOriginatingFromRejection(err); |
promise._attachExtraTrace(err); |
promise._cancel(err); |
}; |
|
var afterDelay = function Promise$_afterDelay(value, promise) { |
promise._fulfill(value); |
}; |
|
var delay = Promise.delay = function Promise$Delay(value, ms) { |
if (ms === void 0) { |
ms = value; |
value = void 0; |
} |
ms = +ms; |
var maybePromise = cast(value, void 0); |
var promise = new Promise(INTERNAL); |
|
if (maybePromise instanceof Promise) { |
promise._propagateFrom(maybePromise, 7); |
promise._follow(maybePromise); |
return promise.then(function(value) { |
return Promise.delay(value, ms); |
}); |
} else { |
promise._setTrace(void 0); |
_setTimeout(afterDelay, ms, value, promise); |
} |
return promise; |
}; |
|
Promise.prototype.delay = function Promise$delay(ms) { |
return delay(this, ms); |
}; |
|
Promise.prototype.timeout = function Promise$timeout(ms, message) { |
ms = +ms; |
|
var ret = new Promise(INTERNAL); |
ret._propagateFrom(this, 7); |
ret._follow(this); |
_setTimeout(afterTimeout, ms, ret, message, ms); |
return ret.cancellable(); |
}; |
|
}; |
|
},{"./errors.js":10,"./errors_api_rejection":11,"./util.js":35}],34:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
module.exports = function (Promise, apiRejection, cast) { |
var TypeError = require("./errors.js").TypeError; |
var inherits = require("./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.value(); |
} |
return inspections; |
} |
|
function thrower(e) { |
setTimeout(function(){throw e;}, 0); |
} |
|
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 = cast(resources[i++], void 0); |
if (maybePromise instanceof Promise && |
maybePromise._isDisposable()) { |
try { |
maybePromise = cast(maybePromise._getDisposer() |
.tryDispose(inspection), void 0); |
} 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) { |
this._data = data; |
this._promise = promise; |
} |
|
Disposer.prototype.data = function Disposer$data() { |
return this._data; |
}; |
|
Disposer.prototype.promise = function Disposer$promise() { |
return this._promise; |
}; |
|
Disposer.prototype.resource = function Disposer$resource() { |
if (this.promise().isFulfilled()) { |
return this.promise().value(); |
} |
return null; |
}; |
|
Disposer.prototype.tryDispose = function(inspection) { |
var resource = this.resource(); |
var ret = resource !== null |
? this.doDispose(resource, inspection) : null; |
this._promise._unsetDisposable(); |
this._data = this._promise = null; |
return ret; |
}; |
|
function FunctionDisposer(fn, promise) { |
this.constructor$(fn, promise); |
} |
inherits(FunctionDisposer, Disposer); |
|
FunctionDisposer.prototype.doDispose = function (resource, inspection) { |
var fn = this.data(); |
return fn.call(resource, resource, inspection); |
}; |
|
Promise.using = function Promise$using() { |
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"); |
len--; |
var resources = new Array(len); |
for (var i = 0; i < len; ++i) { |
var resource = arguments[i]; |
if (resource instanceof Disposer) { |
var disposer = resource; |
resource = resource.promise(); |
resource._setDisposable(disposer); |
} |
resources[i] = resource; |
} |
|
return Promise.settle(resources) |
.then(inspectionMapper) |
.spread(fn) |
._then(disposerSuccess, disposerFail, void 0, resources, void 0); |
}; |
|
Promise.prototype._setDisposable = |
function Promise$_setDisposable(disposer) { |
this._bitField = this._bitField | 262144; |
this._disposer = disposer; |
}; |
|
Promise.prototype._isDisposable = function Promise$_isDisposable() { |
return (this._bitField & 262144) > 0; |
}; |
|
Promise.prototype._getDisposer = function Promise$_getDisposer() { |
return this._disposer; |
}; |
|
Promise.prototype._unsetDisposable = function Promise$_unsetDisposable() { |
this._bitField = this._bitField & (~262144); |
this._disposer = void 0; |
}; |
|
Promise.prototype.disposer = function Promise$disposer(fn) { |
if (typeof fn === "function") { |
return new FunctionDisposer(fn, this); |
} |
throw new TypeError(); |
}; |
|
}; |
|
},{"./errors.js":10,"./util.js":35}],35:[function(require,module,exports){ |
/** |
* Copyright (c) 2014 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:</p> |
* |
* 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. |
* |
*/ |
"use strict"; |
var es5 = require("./es5.js"); |
var haveGetters = (function(){ |
try { |
var o = {}; |
es5.defineProperty(o, "f", { |
get: function () { |
return 3; |
} |
}); |
return o.f === 3; |
} |
catch (e) { |
return false; |
} |
|
})(); |
var canEvaluate = typeof navigator == "undefined"; |
var errorObj = {e: {}}; |
function tryCatch1(fn, receiver, arg) { |
try { return fn.call(receiver, arg); } |
catch (e) { |
errorObj.e = e; |
return errorObj; |
} |
} |
|
function tryCatch2(fn, receiver, arg, arg2) { |
try { return fn.call(receiver, arg, arg2); } |
catch (e) { |
errorObj.e = e; |
return errorObj; |
} |
} |
|
function tryCatch3(fn, receiver, arg, arg2, arg3) { |
try { return fn.call(receiver, arg, arg2, arg3); } |
catch (e) { |
errorObj.e = e; |
return errorObj; |
} |
} |
|
function tryCatch4(fn, receiver, arg, arg2, arg3, arg4) { |
try { return fn.call(receiver, arg, arg2, arg3, arg4); } |
catch (e) { |
errorObj.e = e; |
return errorObj; |
} |
} |
|
function tryCatchApply(fn, args, receiver) { |
try { return fn.apply(receiver, args); } |
catch (e) { |
errorObj.e = e; |
return errorObj; |
} |
} |
|
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 asString(val) { |
return typeof val === "string" ? val : ("" + val); |
} |
|
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(asString(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] : void 0; |
} |
} |
|
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; |
} |
|
|
var wrapsPrimitiveReceiver = (function() { |
return this !== "string"; |
}).call("string"); |
|
function thrower(r) { |
throw r; |
} |
|
var inheritedDataKeys = (function() { |
if (es5.isES5) { |
return function(obj, opts) { |
var ret = []; |
var visitedKeys = Object.create(null); |
var getKeys = Object(opts).includeHidden |
? Object.getOwnPropertyNames |
: Object.keys; |
while (obj != null) { |
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 { |
return function(obj) { |
var ret = []; |
/*jshint forin:false */ |
for (var key in obj) { |
ret.push(key); |
} |
return ret; |
}; |
} |
|
})(); |
|
function isClass(fn) { |
try { |
if (typeof fn === "function") { |
var keys = es5.keys(fn.prototype); |
return keys.length > 0 && |
!(keys.length === 1 && keys[0] === "constructor"); |
} |
return false; |
} catch (e) { |
return false; |
} |
} |
|
function toFastProperties(obj) { |
/*jshint -W027*/ |
function f() {} |
f.prototype = obj; |
return f; |
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; |
} |
|
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, |
tryCatch1: tryCatch1, |
tryCatch2: tryCatch2, |
tryCatch3: tryCatch3, |
tryCatch4: tryCatch4, |
tryCatchApply: tryCatchApply, |
inherits: inherits, |
withAppended: withAppended, |
asString: asString, |
maybeWrapAsError: maybeWrapAsError, |
wrapsPrimitiveReceiver: wrapsPrimitiveReceiver, |
toFastProperties: toFastProperties, |
filledRange: filledRange |
}; |
|
module.exports = ret; |
|
},{"./es5.js":12}]},{},[3]) |
(3) |
}); |
; |