1265 lines
38 KiB
JavaScript
1265 lines
38 KiB
JavaScript
/*!
|
|
* async
|
|
* https://github.com/caolan/async
|
|
*
|
|
* Copyright 2010-2014 Caolan McMahon
|
|
* Released under the MIT license
|
|
*/
|
|
(function () {
|
|
|
|
var async = {};
|
|
function noop() {}
|
|
function identity(v) {
|
|
return v;
|
|
}
|
|
function toBool(v) {
|
|
return !!v;
|
|
}
|
|
function notId(v) {
|
|
return !v;
|
|
}
|
|
|
|
// global on the server, window in the browser
|
|
var previous_async;
|
|
|
|
// Establish the root object, `window` (`self`) in the browser, `global`
|
|
// on the server, or `this` in some virtual machines. We use `self`
|
|
// instead of `window` for `WebWorker` support.
|
|
var root = typeof self === 'object' && self.self === self && self ||
|
|
typeof global === 'object' && global.global === global && global ||
|
|
this;
|
|
|
|
if (root != null) {
|
|
previous_async = root.async;
|
|
}
|
|
|
|
async.noConflict = function () {
|
|
root.async = previous_async;
|
|
return async;
|
|
};
|
|
|
|
function only_once(fn) {
|
|
return function() {
|
|
if (fn === null) throw new Error("Callback was already called.");
|
|
fn.apply(this, arguments);
|
|
fn = null;
|
|
};
|
|
}
|
|
|
|
function _once(fn) {
|
|
return function() {
|
|
if (fn === null) return;
|
|
fn.apply(this, arguments);
|
|
fn = null;
|
|
};
|
|
}
|
|
|
|
//// cross-browser compatiblity functions ////
|
|
|
|
var _toString = Object.prototype.toString;
|
|
|
|
var _isArray = Array.isArray || function (obj) {
|
|
return _toString.call(obj) === '[object Array]';
|
|
};
|
|
|
|
// Ported from underscore.js isObject
|
|
var _isObject = function(obj) {
|
|
var type = typeof obj;
|
|
return type === 'function' || type === 'object' && !!obj;
|
|
};
|
|
|
|
function _isArrayLike(arr) {
|
|
return _isArray(arr) || (
|
|
// has a positive integer length property
|
|
typeof arr.length === "number" &&
|
|
arr.length >= 0 &&
|
|
arr.length % 1 === 0
|
|
);
|
|
}
|
|
|
|
function _arrayEach(arr, iterator) {
|
|
var index = -1,
|
|
length = arr.length;
|
|
|
|
while (++index < length) {
|
|
iterator(arr[index], index, arr);
|
|
}
|
|
}
|
|
|
|
function _map(arr, iterator) {
|
|
var index = -1,
|
|
length = arr.length,
|
|
result = Array(length);
|
|
|
|
while (++index < length) {
|
|
result[index] = iterator(arr[index], index, arr);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function _range(count) {
|
|
return _map(Array(count), function (v, i) { return i; });
|
|
}
|
|
|
|
function _reduce(arr, iterator, memo) {
|
|
_arrayEach(arr, function (x, i, a) {
|
|
memo = iterator(memo, x, i, a);
|
|
});
|
|
return memo;
|
|
}
|
|
|
|
function _forEachOf(object, iterator) {
|
|
_arrayEach(_keys(object), function (key) {
|
|
iterator(object[key], key);
|
|
});
|
|
}
|
|
|
|
function _indexOf(arr, item) {
|
|
for (var i = 0; i < arr.length; i++) {
|
|
if (arr[i] === item) return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
var _keys = Object.keys || function (obj) {
|
|
var keys = [];
|
|
for (var k in obj) {
|
|
if (obj.hasOwnProperty(k)) {
|
|
keys.push(k);
|
|
}
|
|
}
|
|
return keys;
|
|
};
|
|
|
|
function _keyIterator(coll) {
|
|
var i = -1;
|
|
var len;
|
|
var keys;
|
|
if (_isArrayLike(coll)) {
|
|
len = coll.length;
|
|
return function next() {
|
|
i++;
|
|
return i < len ? i : null;
|
|
};
|
|
} else {
|
|
keys = _keys(coll);
|
|
len = keys.length;
|
|
return function next() {
|
|
i++;
|
|
return i < len ? keys[i] : null;
|
|
};
|
|
}
|
|
}
|
|
|
|
// Similar to ES6's rest param (http://ariya.ofilabs.com/2013/03/es6-and-rest-parameter.html)
|
|
// This accumulates the arguments passed into an array, after a given index.
|
|
// From underscore.js (https://github.com/jashkenas/underscore/pull/2140).
|
|
function _restParam(func, startIndex) {
|
|
startIndex = startIndex == null ? func.length - 1 : +startIndex;
|
|
return function() {
|
|
var length = Math.max(arguments.length - startIndex, 0);
|
|
var rest = Array(length);
|
|
for (var index = 0; index < length; index++) {
|
|
rest[index] = arguments[index + startIndex];
|
|
}
|
|
switch (startIndex) {
|
|
case 0: return func.call(this, rest);
|
|
case 1: return func.call(this, arguments[0], rest);
|
|
}
|
|
// Currently unused but handle cases outside of the switch statement:
|
|
// var args = Array(startIndex + 1);
|
|
// for (index = 0; index < startIndex; index++) {
|
|
// args[index] = arguments[index];
|
|
// }
|
|
// args[startIndex] = rest;
|
|
// return func.apply(this, args);
|
|
};
|
|
}
|
|
|
|
function _withoutIndex(iterator) {
|
|
return function (value, index, callback) {
|
|
return iterator(value, callback);
|
|
};
|
|
}
|
|
|
|
//// exported async module functions ////
|
|
|
|
//// nextTick implementation with browser-compatible fallback ////
|
|
|
|
// capture the global reference to guard against fakeTimer mocks
|
|
var _setImmediate = typeof setImmediate === 'function' && setImmediate;
|
|
|
|
var _delay = _setImmediate ? function(fn) {
|
|
// not a direct alias for IE10 compatibility
|
|
_setImmediate(fn);
|
|
} : function(fn) {
|
|
setTimeout(fn, 0);
|
|
};
|
|
|
|
if (typeof process === 'object' && typeof process.nextTick === 'function') {
|
|
async.nextTick = process.nextTick;
|
|
} else {
|
|
async.nextTick = _delay;
|
|
}
|
|
async.setImmediate = _setImmediate ? _delay : async.nextTick;
|
|
|
|
|
|
async.forEach =
|
|
async.each = function (arr, iterator, callback) {
|
|
return async.eachOf(arr, _withoutIndex(iterator), callback);
|
|
};
|
|
|
|
async.forEachSeries =
|
|
async.eachSeries = function (arr, iterator, callback) {
|
|
return async.eachOfSeries(arr, _withoutIndex(iterator), callback);
|
|
};
|
|
|
|
|
|
async.forEachLimit =
|
|
async.eachLimit = function (arr, limit, iterator, callback) {
|
|
return _eachOfLimit(limit)(arr, _withoutIndex(iterator), callback);
|
|
};
|
|
|
|
async.forEachOf =
|
|
async.eachOf = function (object, iterator, callback) {
|
|
callback = _once(callback || noop);
|
|
object = object || [];
|
|
|
|
var iter = _keyIterator(object);
|
|
var key, completed = 0;
|
|
|
|
while ((key = iter()) != null) {
|
|
completed += 1;
|
|
iterator(object[key], key, only_once(done));
|
|
}
|
|
|
|
if (completed === 0) callback(null);
|
|
|
|
function done(err) {
|
|
completed--;
|
|
if (err) {
|
|
callback(err);
|
|
}
|
|
// Check key is null in case iterator isn't exhausted
|
|
// and done resolved synchronously.
|
|
else if (key === null && completed <= 0) {
|
|
callback(null);
|
|
}
|
|
}
|
|
};
|
|
|
|
async.forEachOfSeries =
|
|
async.eachOfSeries = function (obj, iterator, callback) {
|
|
callback = _once(callback || noop);
|
|
obj = obj || [];
|
|
var nextKey = _keyIterator(obj);
|
|
var key = nextKey();
|
|
function iterate() {
|
|
var sync = true;
|
|
if (key === null) {
|
|
return callback(null);
|
|
}
|
|
iterator(obj[key], key, only_once(function (err) {
|
|
if (err) {
|
|
callback(err);
|
|
}
|
|
else {
|
|
key = nextKey();
|
|
if (key === null) {
|
|
return callback(null);
|
|
} else {
|
|
if (sync) {
|
|
async.setImmediate(iterate);
|
|
} else {
|
|
iterate();
|
|
}
|
|
}
|
|
}
|
|
}));
|
|
sync = false;
|
|
}
|
|
iterate();
|
|
};
|
|
|
|
|
|
|
|
async.forEachOfLimit =
|
|
async.eachOfLimit = function (obj, limit, iterator, callback) {
|
|
_eachOfLimit(limit)(obj, iterator, callback);
|
|
};
|
|
|
|
function _eachOfLimit(limit) {
|
|
|
|
return function (obj, iterator, callback) {
|
|
callback = _once(callback || noop);
|
|
obj = obj || [];
|
|
var nextKey = _keyIterator(obj);
|
|
if (limit <= 0) {
|
|
return callback(null);
|
|
}
|
|
var done = false;
|
|
var running = 0;
|
|
var errored = false;
|
|
|
|
(function replenish () {
|
|
if (done && running <= 0) {
|
|
return callback(null);
|
|
}
|
|
|
|
while (running < limit && !errored) {
|
|
var key = nextKey();
|
|
if (key === null) {
|
|
done = true;
|
|
if (running <= 0) {
|
|
callback(null);
|
|
}
|
|
return;
|
|
}
|
|
running += 1;
|
|
iterator(obj[key], key, only_once(function (err) {
|
|
running -= 1;
|
|
if (err) {
|
|
callback(err);
|
|
errored = true;
|
|
}
|
|
else {
|
|
replenish();
|
|
}
|
|
}));
|
|
}
|
|
})();
|
|
};
|
|
}
|
|
|
|
|
|
function doParallel(fn) {
|
|
return function (obj, iterator, callback) {
|
|
return fn(async.eachOf, obj, iterator, callback);
|
|
};
|
|
}
|
|
function doParallelLimit(fn) {
|
|
return function (obj, limit, iterator, callback) {
|
|
return fn(_eachOfLimit(limit), obj, iterator, callback);
|
|
};
|
|
}
|
|
function doSeries(fn) {
|
|
return function (obj, iterator, callback) {
|
|
return fn(async.eachOfSeries, obj, iterator, callback);
|
|
};
|
|
}
|
|
|
|
function _asyncMap(eachfn, arr, iterator, callback) {
|
|
callback = _once(callback || noop);
|
|
arr = arr || [];
|
|
var results = _isArrayLike(arr) ? [] : {};
|
|
eachfn(arr, function (value, index, callback) {
|
|
iterator(value, function (err, v) {
|
|
results[index] = v;
|
|
callback(err);
|
|
});
|
|
}, function (err) {
|
|
callback(err, results);
|
|
});
|
|
}
|
|
|
|
async.map = doParallel(_asyncMap);
|
|
async.mapSeries = doSeries(_asyncMap);
|
|
async.mapLimit = doParallelLimit(_asyncMap);
|
|
|
|
// reduce only has a series version, as doing reduce in parallel won't
|
|
// work in many situations.
|
|
async.inject =
|
|
async.foldl =
|
|
async.reduce = function (arr, memo, iterator, callback) {
|
|
async.eachOfSeries(arr, function (x, i, callback) {
|
|
iterator(memo, x, function (err, v) {
|
|
memo = v;
|
|
callback(err);
|
|
});
|
|
}, function (err) {
|
|
callback(err, memo);
|
|
});
|
|
};
|
|
|
|
async.foldr =
|
|
async.reduceRight = function (arr, memo, iterator, callback) {
|
|
var reversed = _map(arr, identity).reverse();
|
|
async.reduce(reversed, memo, iterator, callback);
|
|
};
|
|
|
|
async.transform = function (arr, memo, iterator, callback) {
|
|
if (arguments.length === 3) {
|
|
callback = iterator;
|
|
iterator = memo;
|
|
memo = _isArray(arr) ? [] : {};
|
|
}
|
|
|
|
async.eachOf(arr, function(v, k, cb) {
|
|
iterator(memo, v, k, cb);
|
|
}, function(err) {
|
|
callback(err, memo);
|
|
});
|
|
};
|
|
|
|
function _filter(eachfn, arr, iterator, callback) {
|
|
var results = [];
|
|
eachfn(arr, function (x, index, callback) {
|
|
iterator(x, function (v) {
|
|
if (v) {
|
|
results.push({index: index, value: x});
|
|
}
|
|
callback();
|
|
});
|
|
}, function () {
|
|
callback(_map(results.sort(function (a, b) {
|
|
return a.index - b.index;
|
|
}), function (x) {
|
|
return x.value;
|
|
}));
|
|
});
|
|
}
|
|
|
|
async.select =
|
|
async.filter = doParallel(_filter);
|
|
|
|
async.selectLimit =
|
|
async.filterLimit = doParallelLimit(_filter);
|
|
|
|
async.selectSeries =
|
|
async.filterSeries = doSeries(_filter);
|
|
|
|
function _reject(eachfn, arr, iterator, callback) {
|
|
_filter(eachfn, arr, function(value, cb) {
|
|
iterator(value, function(v) {
|
|
cb(!v);
|
|
});
|
|
}, callback);
|
|
}
|
|
async.reject = doParallel(_reject);
|
|
async.rejectLimit = doParallelLimit(_reject);
|
|
async.rejectSeries = doSeries(_reject);
|
|
|
|
function _createTester(eachfn, check, getResult) {
|
|
return function(arr, limit, iterator, cb) {
|
|
function done() {
|
|
if (cb) cb(getResult(false, void 0));
|
|
}
|
|
function iteratee(x, _, callback) {
|
|
if (!cb) return callback();
|
|
iterator(x, function (v) {
|
|
if (cb && check(v)) {
|
|
cb(getResult(true, x));
|
|
cb = iterator = false;
|
|
}
|
|
callback();
|
|
});
|
|
}
|
|
if (arguments.length > 3) {
|
|
eachfn(arr, limit, iteratee, done);
|
|
} else {
|
|
cb = iterator;
|
|
iterator = limit;
|
|
eachfn(arr, iteratee, done);
|
|
}
|
|
};
|
|
}
|
|
|
|
async.any =
|
|
async.some = _createTester(async.eachOf, toBool, identity);
|
|
|
|
async.someLimit = _createTester(async.eachOfLimit, toBool, identity);
|
|
|
|
async.all =
|
|
async.every = _createTester(async.eachOf, notId, notId);
|
|
|
|
async.everyLimit = _createTester(async.eachOfLimit, notId, notId);
|
|
|
|
function _findGetResult(v, x) {
|
|
return x;
|
|
}
|
|
async.detect = _createTester(async.eachOf, identity, _findGetResult);
|
|
async.detectSeries = _createTester(async.eachOfSeries, identity, _findGetResult);
|
|
async.detectLimit = _createTester(async.eachOfLimit, identity, _findGetResult);
|
|
|
|
async.sortBy = function (arr, iterator, callback) {
|
|
async.map(arr, function (x, callback) {
|
|
iterator(x, function (err, criteria) {
|
|
if (err) {
|
|
callback(err);
|
|
}
|
|
else {
|
|
callback(null, {value: x, criteria: criteria});
|
|
}
|
|
});
|
|
}, function (err, results) {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
else {
|
|
callback(null, _map(results.sort(comparator), function (x) {
|
|
return x.value;
|
|
}));
|
|
}
|
|
|
|
});
|
|
|
|
function comparator(left, right) {
|
|
var a = left.criteria, b = right.criteria;
|
|
return a < b ? -1 : a > b ? 1 : 0;
|
|
}
|
|
};
|
|
|
|
async.auto = function (tasks, concurrency, callback) {
|
|
if (typeof arguments[1] === 'function') {
|
|
// concurrency is optional, shift the args.
|
|
callback = concurrency;
|
|
concurrency = null;
|
|
}
|
|
callback = _once(callback || noop);
|
|
var keys = _keys(tasks);
|
|
var remainingTasks = keys.length;
|
|
if (!remainingTasks) {
|
|
return callback(null);
|
|
}
|
|
if (!concurrency) {
|
|
concurrency = remainingTasks;
|
|
}
|
|
|
|
var results = {};
|
|
var runningTasks = 0;
|
|
|
|
var hasError = false;
|
|
|
|
var listeners = [];
|
|
function addListener(fn) {
|
|
listeners.unshift(fn);
|
|
}
|
|
function removeListener(fn) {
|
|
var idx = _indexOf(listeners, fn);
|
|
if (idx >= 0) listeners.splice(idx, 1);
|
|
}
|
|
function taskComplete() {
|
|
remainingTasks--;
|
|
_arrayEach(listeners.slice(0), function (fn) {
|
|
fn();
|
|
});
|
|
}
|
|
|
|
addListener(function () {
|
|
if (!remainingTasks) {
|
|
callback(null, results);
|
|
}
|
|
});
|
|
|
|
_arrayEach(keys, function (k) {
|
|
if (hasError) return;
|
|
var task = _isArray(tasks[k]) ? tasks[k]: [tasks[k]];
|
|
var taskCallback = _restParam(function(err, args) {
|
|
runningTasks--;
|
|
if (args.length <= 1) {
|
|
args = args[0];
|
|
}
|
|
if (err) {
|
|
var safeResults = {};
|
|
_forEachOf(results, function(val, rkey) {
|
|
safeResults[rkey] = val;
|
|
});
|
|
safeResults[k] = args;
|
|
hasError = true;
|
|
|
|
callback(err, safeResults);
|
|
}
|
|
else {
|
|
results[k] = args;
|
|
async.setImmediate(taskComplete);
|
|
}
|
|
});
|
|
var requires = task.slice(0, task.length - 1);
|
|
// prevent dead-locks
|
|
var len = requires.length;
|
|
var dep;
|
|
while (len--) {
|
|
if (!(dep = tasks[requires[len]])) {
|
|
throw new Error('Has nonexistent dependency in ' + requires.join(', '));
|
|
}
|
|
if (_isArray(dep) && _indexOf(dep, k) >= 0) {
|
|
throw new Error('Has cyclic dependencies');
|
|
}
|
|
}
|
|
function ready() {
|
|
return runningTasks < concurrency && _reduce(requires, function (a, x) {
|
|
return (a && results.hasOwnProperty(x));
|
|
}, true) && !results.hasOwnProperty(k);
|
|
}
|
|
if (ready()) {
|
|
runningTasks++;
|
|
task[task.length - 1](taskCallback, results);
|
|
}
|
|
else {
|
|
addListener(listener);
|
|
}
|
|
function listener() {
|
|
if (ready()) {
|
|
runningTasks++;
|
|
removeListener(listener);
|
|
task[task.length - 1](taskCallback, results);
|
|
}
|
|
}
|
|
});
|
|
};
|
|
|
|
|
|
|
|
async.retry = function(times, task, callback) {
|
|
var DEFAULT_TIMES = 5;
|
|
var DEFAULT_INTERVAL = 0;
|
|
|
|
var attempts = [];
|
|
|
|
var opts = {
|
|
times: DEFAULT_TIMES,
|
|
interval: DEFAULT_INTERVAL
|
|
};
|
|
|
|
function parseTimes(acc, t){
|
|
if(typeof t === 'number'){
|
|
acc.times = parseInt(t, 10) || DEFAULT_TIMES;
|
|
} else if(typeof t === 'object'){
|
|
acc.times = parseInt(t.times, 10) || DEFAULT_TIMES;
|
|
acc.interval = parseInt(t.interval, 10) || DEFAULT_INTERVAL;
|
|
} else {
|
|
throw new Error('Unsupported argument type for \'times\': ' + typeof t);
|
|
}
|
|
}
|
|
|
|
var length = arguments.length;
|
|
if (length < 1 || length > 3) {
|
|
throw new Error('Invalid arguments - must be either (task), (task, callback), (times, task) or (times, task, callback)');
|
|
} else if (length <= 2 && typeof times === 'function') {
|
|
callback = task;
|
|
task = times;
|
|
}
|
|
if (typeof times !== 'function') {
|
|
parseTimes(opts, times);
|
|
}
|
|
opts.callback = callback;
|
|
opts.task = task;
|
|
|
|
function wrappedTask(wrappedCallback, wrappedResults) {
|
|
function retryAttempt(task, finalAttempt) {
|
|
return function(seriesCallback) {
|
|
task(function(err, result){
|
|
seriesCallback(!err || finalAttempt, {err: err, result: result});
|
|
}, wrappedResults);
|
|
};
|
|
}
|
|
|
|
function retryInterval(interval){
|
|
return function(seriesCallback){
|
|
setTimeout(function(){
|
|
seriesCallback(null);
|
|
}, interval);
|
|
};
|
|
}
|
|
|
|
while (opts.times) {
|
|
|
|
var finalAttempt = !(opts.times-=1);
|
|
attempts.push(retryAttempt(opts.task, finalAttempt));
|
|
if(!finalAttempt && opts.interval > 0){
|
|
attempts.push(retryInterval(opts.interval));
|
|
}
|
|
}
|
|
|
|
async.series(attempts, function(done, data){
|
|
data = data[data.length - 1];
|
|
(wrappedCallback || opts.callback)(data.err, data.result);
|
|
});
|
|
}
|
|
|
|
// If a callback is passed, run this as a controll flow
|
|
return opts.callback ? wrappedTask() : wrappedTask;
|
|
};
|
|
|
|
async.waterfall = function (tasks, callback) {
|
|
callback = _once(callback || noop);
|
|
if (!_isArray(tasks)) {
|
|
var err = new Error('First argument to waterfall must be an array of functions');
|
|
return callback(err);
|
|
}
|
|
if (!tasks.length) {
|
|
return callback();
|
|
}
|
|
function wrapIterator(iterator) {
|
|
return _restParam(function (err, args) {
|
|
if (err) {
|
|
callback.apply(null, [err].concat(args));
|
|
}
|
|
else {
|
|
var next = iterator.next();
|
|
if (next) {
|
|
args.push(wrapIterator(next));
|
|
}
|
|
else {
|
|
args.push(callback);
|
|
}
|
|
ensureAsync(iterator).apply(null, args);
|
|
}
|
|
});
|
|
}
|
|
wrapIterator(async.iterator(tasks))();
|
|
};
|
|
|
|
function _parallel(eachfn, tasks, callback) {
|
|
callback = callback || noop;
|
|
var results = _isArrayLike(tasks) ? [] : {};
|
|
|
|
eachfn(tasks, function (task, key, callback) {
|
|
task(_restParam(function (err, args) {
|
|
if (args.length <= 1) {
|
|
args = args[0];
|
|
}
|
|
results[key] = args;
|
|
callback(err);
|
|
}));
|
|
}, function (err) {
|
|
callback(err, results);
|
|
});
|
|
}
|
|
|
|
async.parallel = function (tasks, callback) {
|
|
_parallel(async.eachOf, tasks, callback);
|
|
};
|
|
|
|
async.parallelLimit = function(tasks, limit, callback) {
|
|
_parallel(_eachOfLimit(limit), tasks, callback);
|
|
};
|
|
|
|
async.series = function(tasks, callback) {
|
|
_parallel(async.eachOfSeries, tasks, callback);
|
|
};
|
|
|
|
async.iterator = function (tasks) {
|
|
function makeCallback(index) {
|
|
function fn() {
|
|
if (tasks.length) {
|
|
tasks[index].apply(null, arguments);
|
|
}
|
|
return fn.next();
|
|
}
|
|
fn.next = function () {
|
|
return (index < tasks.length - 1) ? makeCallback(index + 1): null;
|
|
};
|
|
return fn;
|
|
}
|
|
return makeCallback(0);
|
|
};
|
|
|
|
async.apply = _restParam(function (fn, args) {
|
|
return _restParam(function (callArgs) {
|
|
return fn.apply(
|
|
null, args.concat(callArgs)
|
|
);
|
|
});
|
|
});
|
|
|
|
function _concat(eachfn, arr, fn, callback) {
|
|
var result = [];
|
|
eachfn(arr, function (x, index, cb) {
|
|
fn(x, function (err, y) {
|
|
result = result.concat(y || []);
|
|
cb(err);
|
|
});
|
|
}, function (err) {
|
|
callback(err, result);
|
|
});
|
|
}
|
|
async.concat = doParallel(_concat);
|
|
async.concatSeries = doSeries(_concat);
|
|
|
|
async.whilst = function (test, iterator, callback) {
|
|
callback = callback || noop;
|
|
if (test()) {
|
|
var next = _restParam(function(err, args) {
|
|
if (err) {
|
|
callback(err);
|
|
} else if (test.apply(this, args)) {
|
|
iterator(next);
|
|
} else {
|
|
callback.apply(null, [null].concat(args));
|
|
}
|
|
});
|
|
iterator(next);
|
|
} else {
|
|
callback(null);
|
|
}
|
|
};
|
|
|
|
async.doWhilst = function (iterator, test, callback) {
|
|
var calls = 0;
|
|
return async.whilst(function() {
|
|
return ++calls <= 1 || test.apply(this, arguments);
|
|
}, iterator, callback);
|
|
};
|
|
|
|
async.until = function (test, iterator, callback) {
|
|
return async.whilst(function() {
|
|
return !test.apply(this, arguments);
|
|
}, iterator, callback);
|
|
};
|
|
|
|
async.doUntil = function (iterator, test, callback) {
|
|
return async.doWhilst(iterator, function() {
|
|
return !test.apply(this, arguments);
|
|
}, callback);
|
|
};
|
|
|
|
async.during = function (test, iterator, callback) {
|
|
callback = callback || noop;
|
|
|
|
var next = _restParam(function(err, args) {
|
|
if (err) {
|
|
callback(err);
|
|
} else {
|
|
args.push(check);
|
|
test.apply(this, args);
|
|
}
|
|
});
|
|
|
|
var check = function(err, truth) {
|
|
if (err) {
|
|
callback(err);
|
|
} else if (truth) {
|
|
iterator(next);
|
|
} else {
|
|
callback(null);
|
|
}
|
|
};
|
|
|
|
test(check);
|
|
};
|
|
|
|
async.doDuring = function (iterator, test, callback) {
|
|
var calls = 0;
|
|
async.during(function(next) {
|
|
if (calls++ < 1) {
|
|
next(null, true);
|
|
} else {
|
|
test.apply(this, arguments);
|
|
}
|
|
}, iterator, callback);
|
|
};
|
|
|
|
function _queue(worker, concurrency, payload) {
|
|
if (concurrency == null) {
|
|
concurrency = 1;
|
|
}
|
|
else if(concurrency === 0) {
|
|
throw new Error('Concurrency must not be zero');
|
|
}
|
|
function _insert(q, data, pos, callback) {
|
|
if (callback != null && typeof callback !== "function") {
|
|
throw new Error("task callback must be a function");
|
|
}
|
|
q.started = true;
|
|
if (!_isArray(data)) {
|
|
data = [data];
|
|
}
|
|
if(data.length === 0 && q.idle()) {
|
|
// call drain immediately if there are no tasks
|
|
return async.setImmediate(function() {
|
|
q.drain();
|
|
});
|
|
}
|
|
_arrayEach(data, function(task) {
|
|
var item = {
|
|
data: task,
|
|
callback: callback || noop
|
|
};
|
|
|
|
if (pos) {
|
|
q.tasks.unshift(item);
|
|
} else {
|
|
q.tasks.push(item);
|
|
}
|
|
|
|
if (q.tasks.length === q.concurrency) {
|
|
q.saturated();
|
|
}
|
|
});
|
|
async.setImmediate(q.process);
|
|
}
|
|
function _next(q, tasks) {
|
|
return function(){
|
|
workers -= 1;
|
|
|
|
var removed = false;
|
|
var args = arguments;
|
|
_arrayEach(tasks, function (task) {
|
|
_arrayEach(workersList, function (worker, index) {
|
|
if (worker === task && !removed) {
|
|
workersList.splice(index, 1);
|
|
removed = true;
|
|
}
|
|
});
|
|
|
|
task.callback.apply(task, args);
|
|
});
|
|
if (q.tasks.length + workers === 0) {
|
|
q.drain();
|
|
}
|
|
q.process();
|
|
};
|
|
}
|
|
|
|
var workers = 0;
|
|
var workersList = [];
|
|
var q = {
|
|
tasks: [],
|
|
concurrency: concurrency,
|
|
payload: payload,
|
|
saturated: noop,
|
|
empty: noop,
|
|
drain: noop,
|
|
started: false,
|
|
paused: false,
|
|
push: function (data, callback) {
|
|
_insert(q, data, false, callback);
|
|
},
|
|
kill: function () {
|
|
q.drain = noop;
|
|
q.tasks = [];
|
|
},
|
|
unshift: function (data, callback) {
|
|
_insert(q, data, true, callback);
|
|
},
|
|
process: function () {
|
|
while(!q.paused && workers < q.concurrency && q.tasks.length){
|
|
|
|
var tasks = q.payload ?
|
|
q.tasks.splice(0, q.payload) :
|
|
q.tasks.splice(0, q.tasks.length);
|
|
|
|
var data = _map(tasks, function (task) {
|
|
return task.data;
|
|
});
|
|
|
|
if (q.tasks.length === 0) {
|
|
q.empty();
|
|
}
|
|
workers += 1;
|
|
workersList.push(tasks[0]);
|
|
var cb = only_once(_next(q, tasks));
|
|
worker(data, cb);
|
|
}
|
|
},
|
|
length: function () {
|
|
return q.tasks.length;
|
|
},
|
|
running: function () {
|
|
return workers;
|
|
},
|
|
workersList: function () {
|
|
return workersList;
|
|
},
|
|
idle: function() {
|
|
return q.tasks.length + workers === 0;
|
|
},
|
|
pause: function () {
|
|
q.paused = true;
|
|
},
|
|
resume: function () {
|
|
if (q.paused === false) { return; }
|
|
q.paused = false;
|
|
var resumeCount = Math.min(q.concurrency, q.tasks.length);
|
|
// Need to call q.process once per concurrent
|
|
// worker to preserve full concurrency after pause
|
|
for (var w = 1; w <= resumeCount; w++) {
|
|
async.setImmediate(q.process);
|
|
}
|
|
}
|
|
};
|
|
return q;
|
|
}
|
|
|
|
async.queue = function (worker, concurrency) {
|
|
var q = _queue(function (items, cb) {
|
|
worker(items[0], cb);
|
|
}, concurrency, 1);
|
|
|
|
return q;
|
|
};
|
|
|
|
async.priorityQueue = function (worker, concurrency) {
|
|
|
|
function _compareTasks(a, b){
|
|
return a.priority - b.priority;
|
|
}
|
|
|
|
function _binarySearch(sequence, item, compare) {
|
|
var beg = -1,
|
|
end = sequence.length - 1;
|
|
while (beg < end) {
|
|
var mid = beg + ((end - beg + 1) >>> 1);
|
|
if (compare(item, sequence[mid]) >= 0) {
|
|
beg = mid;
|
|
} else {
|
|
end = mid - 1;
|
|
}
|
|
}
|
|
return beg;
|
|
}
|
|
|
|
function _insert(q, data, priority, callback) {
|
|
if (callback != null && typeof callback !== "function") {
|
|
throw new Error("task callback must be a function");
|
|
}
|
|
q.started = true;
|
|
if (!_isArray(data)) {
|
|
data = [data];
|
|
}
|
|
if(data.length === 0) {
|
|
// call drain immediately if there are no tasks
|
|
return async.setImmediate(function() {
|
|
q.drain();
|
|
});
|
|
}
|
|
_arrayEach(data, function(task) {
|
|
var item = {
|
|
data: task,
|
|
priority: priority,
|
|
callback: typeof callback === 'function' ? callback : noop
|
|
};
|
|
|
|
q.tasks.splice(_binarySearch(q.tasks, item, _compareTasks) + 1, 0, item);
|
|
|
|
if (q.tasks.length === q.concurrency) {
|
|
q.saturated();
|
|
}
|
|
async.setImmediate(q.process);
|
|
});
|
|
}
|
|
|
|
// Start with a normal queue
|
|
var q = async.queue(worker, concurrency);
|
|
|
|
// Override push to accept second parameter representing priority
|
|
q.push = function (data, priority, callback) {
|
|
_insert(q, data, priority, callback);
|
|
};
|
|
|
|
// Remove unshift function
|
|
delete q.unshift;
|
|
|
|
return q;
|
|
};
|
|
|
|
async.cargo = function (worker, payload) {
|
|
return _queue(worker, 1, payload);
|
|
};
|
|
|
|
function _console_fn(name) {
|
|
return _restParam(function (fn, args) {
|
|
fn.apply(null, args.concat([_restParam(function (err, args) {
|
|
if (typeof console === 'object') {
|
|
if (err) {
|
|
if (console.error) {
|
|
console.error(err);
|
|
}
|
|
}
|
|
else if (console[name]) {
|
|
_arrayEach(args, function (x) {
|
|
console[name](x);
|
|
});
|
|
}
|
|
}
|
|
})]));
|
|
});
|
|
}
|
|
async.log = _console_fn('log');
|
|
async.dir = _console_fn('dir');
|
|
/*async.info = _console_fn('info');
|
|
async.warn = _console_fn('warn');
|
|
async.error = _console_fn('error');*/
|
|
|
|
async.memoize = function (fn, hasher) {
|
|
var memo = {};
|
|
var queues = {};
|
|
var has = Object.prototype.hasOwnProperty;
|
|
hasher = hasher || identity;
|
|
var memoized = _restParam(function memoized(args) {
|
|
var callback = args.pop();
|
|
var key = hasher.apply(null, args);
|
|
if (has.call(memo, key)) {
|
|
async.setImmediate(function () {
|
|
callback.apply(null, memo[key]);
|
|
});
|
|
}
|
|
else if (has.call(queues, key)) {
|
|
queues[key].push(callback);
|
|
}
|
|
else {
|
|
queues[key] = [callback];
|
|
fn.apply(null, args.concat([_restParam(function (args) {
|
|
memo[key] = args;
|
|
var q = queues[key];
|
|
delete queues[key];
|
|
for (var i = 0, l = q.length; i < l; i++) {
|
|
q[i].apply(null, args);
|
|
}
|
|
})]));
|
|
}
|
|
});
|
|
memoized.memo = memo;
|
|
memoized.unmemoized = fn;
|
|
return memoized;
|
|
};
|
|
|
|
async.unmemoize = function (fn) {
|
|
return function () {
|
|
return (fn.unmemoized || fn).apply(null, arguments);
|
|
};
|
|
};
|
|
|
|
function _times(mapper) {
|
|
return function (count, iterator, callback) {
|
|
mapper(_range(count), iterator, callback);
|
|
};
|
|
}
|
|
|
|
async.times = _times(async.map);
|
|
async.timesSeries = _times(async.mapSeries);
|
|
async.timesLimit = function (count, limit, iterator, callback) {
|
|
return async.mapLimit(_range(count), limit, iterator, callback);
|
|
};
|
|
|
|
async.seq = function (/* functions... */) {
|
|
var fns = arguments;
|
|
return _restParam(function (args) {
|
|
var that = this;
|
|
|
|
var callback = args[args.length - 1];
|
|
if (typeof callback == 'function') {
|
|
args.pop();
|
|
} else {
|
|
callback = noop;
|
|
}
|
|
|
|
async.reduce(fns, args, function (newargs, fn, cb) {
|
|
fn.apply(that, newargs.concat([_restParam(function (err, nextargs) {
|
|
cb(err, nextargs);
|
|
})]));
|
|
},
|
|
function (err, results) {
|
|
callback.apply(that, [err].concat(results));
|
|
});
|
|
});
|
|
};
|
|
|
|
async.compose = function (/* functions... */) {
|
|
return async.seq.apply(null, Array.prototype.reverse.call(arguments));
|
|
};
|
|
|
|
|
|
function _applyEach(eachfn) {
|
|
return _restParam(function(fns, args) {
|
|
var go = _restParam(function(args) {
|
|
var that = this;
|
|
var callback = args.pop();
|
|
return eachfn(fns, function (fn, _, cb) {
|
|
fn.apply(that, args.concat([cb]));
|
|
},
|
|
callback);
|
|
});
|
|
if (args.length) {
|
|
return go.apply(this, args);
|
|
}
|
|
else {
|
|
return go;
|
|
}
|
|
});
|
|
}
|
|
|
|
async.applyEach = _applyEach(async.eachOf);
|
|
async.applyEachSeries = _applyEach(async.eachOfSeries);
|
|
|
|
|
|
async.forever = function (fn, callback) {
|
|
var done = only_once(callback || noop);
|
|
var task = ensureAsync(fn);
|
|
function next(err) {
|
|
if (err) {
|
|
return done(err);
|
|
}
|
|
task(next);
|
|
}
|
|
next();
|
|
};
|
|
|
|
function ensureAsync(fn) {
|
|
return _restParam(function (args) {
|
|
var callback = args.pop();
|
|
args.push(function () {
|
|
var innerArgs = arguments;
|
|
if (sync) {
|
|
async.setImmediate(function () {
|
|
callback.apply(null, innerArgs);
|
|
});
|
|
} else {
|
|
callback.apply(null, innerArgs);
|
|
}
|
|
});
|
|
var sync = true;
|
|
fn.apply(this, args);
|
|
sync = false;
|
|
});
|
|
}
|
|
|
|
async.ensureAsync = ensureAsync;
|
|
|
|
async.constant = _restParam(function(values) {
|
|
var args = [null].concat(values);
|
|
return function (callback) {
|
|
return callback.apply(this, args);
|
|
};
|
|
});
|
|
|
|
async.wrapSync =
|
|
async.asyncify = function asyncify(func) {
|
|
return _restParam(function (args) {
|
|
var callback = args.pop();
|
|
var result;
|
|
try {
|
|
result = func.apply(this, args);
|
|
} catch (e) {
|
|
return callback(e);
|
|
}
|
|
// if result is Promise object
|
|
if (_isObject(result) && typeof result.then === "function") {
|
|
result.then(function(value) {
|
|
callback(null, value);
|
|
})["catch"](function(err) {
|
|
callback(err.message ? err : new Error(err));
|
|
});
|
|
} else {
|
|
callback(null, result);
|
|
}
|
|
});
|
|
};
|
|
|
|
// Node.js
|
|
if (typeof module === 'object' && module.exports) {
|
|
module.exports = async;
|
|
}
|
|
// AMD / RequireJS
|
|
else if (typeof define === 'function' && define.amd) {
|
|
define([], function () {
|
|
return async;
|
|
});
|
|
}
|
|
// included directly via <script> tag
|
|
else {
|
|
root.async = async;
|
|
}
|
|
|
|
}());
|