db0fa3c33e
Promise-based rewrite of most of the codebase, with asynchronous database and file access -- see https://github.com/zotero/zotero/issues/518 for details. WARNING: This includes backwards-incompatible schema changes. An incomplete list of other changes: - Schema overhaul - Replace main tables with new versions with updated schema - Enable real foreign key support and remove previous triggers - Don't use NULLs for local libraryID, which broke the UNIQUE index preventing object key duplication. All code (Zotero and third-party) using NULL for the local library will need to be updated to use 0 instead (already done for Zotero code) - Add 'compatibility' DB version that can be incremented manually to break DB compatibility with previous versions. 'userdata' upgrades will no longer automatically break compatibility. - Demote creators and tags from first-class objects to item properties - New API syncing properties - 'synced'/'version' properties to data objects - 'etag' to groups - 'version' to libraries - Create Zotero.DataObject that other objects inherit from - Consolidate data object loading into Zotero.DataObjects - Change object reloading so that only the loaded and changed parts of objects are reloaded, instead of reloading all data from the database (with some exceptions, including item primary data) - Items and collections now have .parentItem and .parentKey properties, replacing item.getSource() and item.getSourceKey() - New function Zotero.serial(fn), to wrap an async function such that all calls are run serially - New function Zotero.Utilities.Internal.forEachChunkAsync(arr, chunkSize, func) - Add tag selector loading message - Various API and name changes, since everything was breaking anyway Known broken things: - Syncing (will be completely rewritten for API syncing) - Translation architecture (needs promise-based rewrite) - Duplicates view - DB integrity check (from schema changes) - Dragging (may be difficult to fix) Lots of other big and little things are certainly broken, particularly with the UI, which can be affected by async code in all sorts of subtle ways.
5261 lines
No EOL
174 KiB
JavaScript
5261 lines
No EOL
174 KiB
JavaScript
/**
|
|
* bluebird build version 2.2.2
|
|
* 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){
|
|
//
|
|
// Added by Zotero
|
|
//
|
|
EXPORTED_SYMBOLS = ["Promise"];
|
|
|
|
// Set BackstagePass (which contains .Error, etc.) as global object
|
|
global = this;
|
|
|
|
// Provide an implementation of setTimeout
|
|
global.setTimeout = new function() {
|
|
// We need to maintain references to running nsITimers. Otherwise, they can
|
|
// get garbage collected before they fire.
|
|
var _runningTimers = [];
|
|
|
|
return function setTimeout(func, ms) {
|
|
var useMethodjit = Components.utils.methodjit;
|
|
var timer = Components.classes["@mozilla.org/timer;1"]
|
|
.createInstance(Components.interfaces.nsITimer);
|
|
timer.initWithCallback({"notify":function() {
|
|
// Remove timer from array so it can be garbage collected
|
|
_runningTimers.splice(_runningTimers.indexOf(timer), 1);
|
|
|
|
// Execute callback function
|
|
try {
|
|
func();
|
|
} catch(err) {
|
|
// Rethrow errors that occur so that they appear in the error
|
|
// console with the appropriate name and line numbers. While the
|
|
// the errors appear without this, the line numbers get eaten.
|
|
var scriptError = Components.classes["@mozilla.org/scripterror;1"]
|
|
.createInstance(Components.interfaces.nsIScriptError);
|
|
scriptError.init(
|
|
err.message || err.toString(),
|
|
err.fileName || err.filename || null,
|
|
null,
|
|
err.lineNumber || null,
|
|
null,
|
|
scriptError.errorFlag,
|
|
'component javascript'
|
|
);
|
|
Components.classes["@mozilla.org/consoleservice;1"]
|
|
.getService(Components.interfaces.nsIConsoleService)
|
|
.logMessage(scriptError);
|
|
global.debug(err, 1);
|
|
global.debug(err.stack, 1);
|
|
}
|
|
}}, ms, Components.interfaces.nsITimer.TYPE_ONE_SHOT);
|
|
_runningTimers.push(timer);
|
|
}
|
|
};
|
|
|
|
global.debug = function (msg) {
|
|
dump(msg + "\n\n");
|
|
};
|
|
|
|
Promise = e();
|
|
// TEMP: Only turn on if debug logging enabled?
|
|
Promise.longStackTraces();
|
|
Promise.onPossiblyUnhandledRejection(function(error) {
|
|
global.debug('===========');
|
|
global.debug(error);
|
|
global.debug(error.stack);
|
|
throw error;
|
|
});
|
|
return;
|
|
|
|
|
|
"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;
|
|
if (cr) {
|
|
var callerCache = cr(null);
|
|
var getterCache = 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) {
|
|
// Added by Zotero
|
|
return obj.message && obj.stack;
|
|
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) {
|
|
// Added by Zotero
|
|
let e = new TypeError(
|
|
"A value was yielded that could not be treated as a promise: " + value
|
|
);
|
|
global.debug(e);
|
|
global.debug(e.stack);
|
|
|
|
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);
|
|
};
|
|
|
|
// Added by Zotero to allow yielding arrays of promises in coroutines
|
|
Promise.coroutine.addYieldHandler(function(yieldedValue) {
|
|
if (Array.isArray(yieldedValue)) return Promise.all(yieldedValue);
|
|
});
|
|
|
|
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)
|
|
});
|
|
; |