| (function(global, factory) { |
| /*jshint -W030 */ |
| 'use strict'; |
| typeof exports === 'object' && typeof module !== 'undefined' |
| ? factory(exports) |
| : typeof define === 'function' && define.amd |
| ? define(['exports'], factory) |
| : global.async |
| ? factory((global.neo_async = global.neo_async || {})) |
| : factory((global.async = global.async || {})); |
| })(this, function(exports) { |
| 'use strict'; |
| |
| var noop = function noop() {}; |
| var throwError = function throwError() { |
| throw new Error('Callback was already called.'); |
| }; |
| |
| var DEFAULT_TIMES = 5; |
| var DEFAULT_INTERVAL = 0; |
| |
| var obj = 'object'; |
| var func = 'function'; |
| var isArray = Array.isArray; |
| var nativeKeys = Object.keys; |
| var nativePush = Array.prototype.push; |
| var iteratorSymbol = typeof Symbol === func && Symbol.iterator; |
| |
| var nextTick, asyncNextTick, asyncSetImmediate; |
| createImmediate(); |
| |
| /** |
| * @memberof async |
| * @namespace each |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(); |
| * }, num * 10); |
| * }; |
| * async.each(array, iterator, function(err, res) { |
| * console.log(res); // undefined |
| * console.log(order); // [1, 2, 3] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(); |
| * }, num * 10); |
| * }; |
| * async.each(array, iterator, function(err, res) { |
| * console.log(res); // undefined |
| * console.log(order); // [[1, 0], [2, 2], [3, 1]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(); |
| * }, num * 10); |
| * }; |
| * async.each(object, iterator, function(err, res) { |
| * console.log(res); // undefined |
| * console.log(order); // [1, 2, 3] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(); |
| * }, num * 10); |
| * }; |
| * async.each(object, iterator, function(err, res) { |
| * console.log(res); // undefined |
| * console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']] |
| * }); |
| * |
| * @example |
| * |
| * // break |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num !== 2); |
| * }, num * 10); |
| * }; |
| * async.each(array, iterator, function(err, res) { |
| * console.log(res); // undefined |
| * console.log(order); // [1, 2] |
| * }); |
| * |
| */ |
| var each = createEach(arrayEach, baseEach, symbolEach); |
| |
| /** |
| * @memberof async |
| * @namespace map |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.map(array, iterator, function(err, res) { |
| * console.log(res); // [1, 3, 2]; |
| * console.log(order); // [1, 2, 3] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.map(array, iterator, function(err, res) { |
| * console.log(res); // [1, 3, 2] |
| * console.log(order); // [[1, 0], [2, 2], [3, 1]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.map(object, iterator, function(err, res) { |
| * console.log(res); // [1, 3, 2] |
| * console.log(order); // [1, 2, 3] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.map(object, iterator, function(err, res) { |
| * console.log(res); // [1, 3, 2] |
| * console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']] |
| * }); |
| * |
| */ |
| var map = createMap(arrayEachIndex, baseEachIndex, symbolEachIndex, true); |
| |
| /** |
| * @memberof async |
| * @namespace mapValues |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.mapValues(array, iterator, function(err, res) { |
| * console.log(res); // { '0': 1, '1': 3, '2': 2 } |
| * console.log(order); // [1, 2, 3] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.mapValues(array, iterator, function(err, res) { |
| * console.log(res); // { '0': 1, '1': 3, '2': 2 } |
| * console.log(order); // [[1, 0], [2, 2], [3, 1]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.mapValues(object, iterator, function(err, res) { |
| * console.log(res); // { a: 1, b: 3, c: 2 } |
| * console.log(order); // [1, 2, 3] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.mapValues(object, iterator, function(err, res) { |
| * console.log(res); // { a: 1, b: 3, c: 2 } |
| * console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']] |
| * }); |
| * |
| */ |
| var mapValues = createMap(arrayEachIndex, baseEachKey, symbolEachKey, false); |
| |
| /** |
| * @memberof async |
| * @namespace filter |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.filter(array, iterator, function(err, res) { |
| * console.log(res); // [1, 3]; |
| * console.log(order); // [1, 2, 3] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.filter(array, iterator, function(err, res) { |
| * console.log(res); // [1, 3]; |
| * console.log(order); // [[1, 0], [2, 2], [3, 1]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.filter(object, iterator, function(err, res) { |
| * console.log(res); // [1, 3]; |
| * console.log(order); // [1, 2, 3] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.filter(object, iterator, function(err, res) { |
| * console.log(res); // [1, 3]; |
| * console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']] |
| * }); |
| * |
| */ |
| var filter = createFilter(arrayEachIndexValue, baseEachIndexValue, symbolEachIndexValue, true); |
| |
| /** |
| * @memberof async |
| * @namespace filterSeries |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.filterSeries(array, iterator, function(err, res) { |
| * console.log(res); // [1, 3]; |
| * console.log(order); // [1, 3, 2] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.filterSeries(array, iterator, function(err, res) { |
| * console.log(res); // [1, 3] |
| * console.log(order); // [[1, 0], [3, 1], [2, 2]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.filterSeries(object, iterator, function(err, res) { |
| * console.log(res); // [1, 3] |
| * console.log(order); // [1, 3, 2] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.filterSeries(object, iterator, function(err, res) { |
| * console.log(res); // [1, 3] |
| * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']] |
| * }); |
| * |
| */ |
| var filterSeries = createFilterSeries(true); |
| |
| /** |
| * @memberof async |
| * @namespace filterLimit |
| * @param {Array|Object} collection |
| * @param {number} limit - limit >= 1 |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.filterLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // [1, 5, 3] |
| * console.log(order); // [1, 3, 5, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.filterLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // [1, 5, 3] |
| * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.filterLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // [1, 5, 3] |
| * console.log(order); // [1, 3, 5, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.filterLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // [1, 5, 3] |
| * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']] |
| * }); |
| * |
| */ |
| var filterLimit = createFilterLimit(true); |
| |
| /** |
| * @memberof async |
| * @namespace reject |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.reject(array, iterator, function(err, res) { |
| * console.log(res); // [2]; |
| * console.log(order); // [1, 2, 3] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.reject(array, iterator, function(err, res) { |
| * console.log(res); // [2]; |
| * console.log(order); // [[1, 0], [2, 2], [3, 1]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.reject(object, iterator, function(err, res) { |
| * console.log(res); // [2]; |
| * console.log(order); // [1, 2, 3] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.reject(object, iterator, function(err, res) { |
| * console.log(res); // [2]; |
| * console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']] |
| * }); |
| * |
| */ |
| var reject = createFilter(arrayEachIndexValue, baseEachIndexValue, symbolEachIndexValue, false); |
| |
| /** |
| * @memberof async |
| * @namespace rejectSeries |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.rejectSeries(array, iterator, function(err, res) { |
| * console.log(res); // [2]; |
| * console.log(order); // [1, 3, 2] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.rejectSeries(object, iterator, function(err, res) { |
| * console.log(res); // [2]; |
| * console.log(order); // [1, 3, 2] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.rejectSeries(object, iterator, function(err, res) { |
| * console.log(res); // [2]; |
| * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']] |
| * }); |
| * |
| */ |
| var rejectSeries = createFilterSeries(false); |
| |
| /** |
| * @memberof async |
| * @namespace rejectLimit |
| * @param {Array|Object} collection |
| * @param {number} limit - limit >= 1 |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.rejectLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // [4, 2] |
| * console.log(order); // [1, 3, 5, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.rejectLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // [4, 2] |
| * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.rejectLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // [4, 2] |
| * console.log(order); // [1, 3, 5, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.rejectLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // [4, 2] |
| * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']] |
| * }); |
| * |
| */ |
| var rejectLimit = createFilterLimit(false); |
| |
| /** |
| * @memberof async |
| * @namespace detect |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.detect(array, iterator, function(err, res) { |
| * console.log(res); // 1 |
| * console.log(order); // [1] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.detect(array, iterator, function(err, res) { |
| * console.log(res); // 1 |
| * console.log(order); // [[1, 0]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.detect(object, iterator, function(err, res) { |
| * console.log(res); // 1 |
| * console.log(order); // [1] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.detect(object, iterator, function(err, res) { |
| * console.log(res); // 1 |
| * console.log(order); // [[1, 'a']] |
| * }); |
| * |
| */ |
| var detect = createDetect(arrayEachValue, baseEachValue, symbolEachValue, true); |
| |
| /** |
| * @memberof async |
| * @namespace detectSeries |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.detectSeries(array, iterator, function(err, res) { |
| * console.log(res); // 1 |
| * console.log(order); // [1] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.detectSeries(array, iterator, function(err, res) { |
| * console.log(res); // 1 |
| * console.log(order); // [[1, 0]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.detectSeries(object, iterator, function(err, res) { |
| * console.log(res); // 1 |
| * console.log(order); // [1] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.detectSeries(object, iterator, function(err, res) { |
| * console.log(res); // 1 |
| * console.log(order); // [[1, 'a']] |
| * }); |
| * |
| */ |
| var detectSeries = createDetectSeries(true); |
| |
| /** |
| * @memberof async |
| * @namespace detectLimit |
| * @param {Array|Object} collection |
| * @param {number} limit - limit >= 1 |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.detectLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // 1 |
| * console.log(order); // [1] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.detectLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // 1 |
| * console.log(order); // [[1, 0]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.detectLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // 1 |
| * console.log(order); // [1] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.detectLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // 1 |
| * console.log(order); // [[1, 'a']] |
| * }); |
| * |
| */ |
| var detectLimit = createDetectLimit(true); |
| |
| /** |
| * @memberof async |
| * @namespace every |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.every(array, iterator, function(err, res) { |
| * console.log(res); // false |
| * console.log(order); // [1, 2] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.every(array, iterator, function(err, res) { |
| * console.log(res); // false |
| * console.log(order); // [[1, 0], [2, 2]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.every(object, iterator, function(err, res) { |
| * console.log(res); // false |
| * console.log(order); // [1, 2] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.every(object, iterator, function(err, res) { |
| * console.log(res); // false |
| * console.log(order); // [[1, 'a'], [2, 'c']] |
| * }); |
| * |
| */ |
| var every = createEvery(arrayEachValue, baseEachValue, symbolEachValue); |
| |
| /** |
| * @memberof async |
| * @namespace everySeries |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.everySeries(array, iterator, function(err, res) { |
| * console.log(res); // false |
| * console.log(order); // [1, 3, 2] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.everySeries(array, iterator, function(err, res) { |
| * console.log(res); // false |
| * console.log(order); // [[1, 0], [3, 1], [2, 2]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.everySeries(object, iterator, function(err, res) { |
| * console.log(res); // false |
| * console.log(order); // [1, 3, 2] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.everySeries(object, iterator, function(err, res) { |
| * console.log(res); // false |
| * console.log(order); // [[1, 'a'], [3, 'b'] [2, 'c']] |
| * }); |
| * |
| */ |
| var everySeries = createEverySeries(); |
| |
| /** |
| * @memberof async |
| * @namespace everyLimit |
| * @param {Array|Object} collection |
| * @param {number} limit - limit >= 1 |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.everyLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // false |
| * console.log(order); // [1, 3, 5, 2] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.everyLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // false |
| * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.everyLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // false |
| * console.log(order); // [1, 3, 5, 2] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.everyLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // false |
| * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e']] |
| * }); |
| * |
| */ |
| var everyLimit = createEveryLimit(); |
| |
| /** |
| * @memberof async |
| * @namespace pick |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 3, 2, 4]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.pick(array, iterator, function(err, res) { |
| * console.log(res); // { '0': 1, '1': 3 } |
| * console.log(order); // [1, 2, 3, 4] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 3, 2, 4]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.pick(array, iterator, function(err, res) { |
| * console.log(res); // { '0': 1, '1': 3 } |
| * console.log(order); // [[0, 1], [2, 2], [3, 1], [4, 3]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2, d: 4 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.pick(object, iterator, function(err, res) { |
| * console.log(res); // { a: 1, b: 3 } |
| * console.log(order); // [1, 2, 3, 4] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2, d: 4 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.pick(object, iterator, function(err, res) { |
| * console.log(res); // { a: 1, b: 3 } |
| * console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b'], [4, 'd']] |
| * }); |
| * |
| */ |
| var pick = createPick(arrayEachIndexValue, baseEachKeyValue, symbolEachKeyValue, true); |
| |
| /** |
| * @memberof async |
| * @namespace pickSeries |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 3, 2, 4]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.pickSeries(array, iterator, function(err, res) { |
| * console.log(res); // { '0': 1, '1': 3 } |
| * console.log(order); // [1, 3, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 3, 2, 4]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.pickSeries(array, iterator, function(err, res) { |
| * console.log(res); // { '0': 1, '1': 3 } |
| * console.log(order); // [[0, 1], [3, 1], [2, 2], [4, 3]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2, d: 4 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.pickSeries(object, iterator, function(err, res) { |
| * console.log(res); // { a: 1, b: 3 } |
| * console.log(order); // [1, 3, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2, d: 4 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.pickSeries(object, iterator, function(err, res) { |
| * console.log(res); // { a: 1, b: 3 } |
| * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c'], [4, 'd']] |
| * }); |
| * |
| */ |
| var pickSeries = createPickSeries(true); |
| |
| /** |
| * @memberof async |
| * @namespace pickLimit |
| * @param {Array|Object} collection |
| * @param {number} limit - limit >= 1 |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.pickLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // { '0': 1, '1': 5, '2': 3 } |
| * console.log(order); // [1, 3, 5, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.pickLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // { '0': 1, '1': 5, '2': 3 } |
| * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.pickLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // { a: 1, b: 5, c: 3 } |
| * console.log(order); // [1, 3, 5, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.pickLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // { a: 1, b: 5, c: 3 } |
| * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']] |
| * }); |
| * |
| */ |
| var pickLimit = createPickLimit(true); |
| |
| /** |
| * @memberof async |
| * @namespace omit |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 3, 2, 4]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.omit(array, iterator, function(err, res) { |
| * console.log(res); // { '2': 2, '3': 4 } |
| * console.log(order); // [1, 2, 3, 4] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 3, 2, 4]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.omit(array, iterator, function(err, res) { |
| * console.log(res); // { '2': 2, '3': 4 } |
| * console.log(order); // [[0, 1], [2, 2], [3, 1], [4, 3]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2, d: 4 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.omit(object, iterator, function(err, res) { |
| * console.log(res); // { c: 2, d: 4 } |
| * console.log(order); // [1, 2, 3, 4] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2, d: 4 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.omit(object, iterator, function(err, res) { |
| * console.log(res); // { c: 2, d: 4 } |
| * console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b'], [4, 'd']] |
| * }); |
| * |
| */ |
| var omit = createPick(arrayEachIndexValue, baseEachKeyValue, symbolEachKeyValue, false); |
| |
| /** |
| * @memberof async |
| * @namespace omitSeries |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 3, 2, 4]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.omitSeries(array, iterator, function(err, res) { |
| * console.log(res); // { '2': 2, '3': 4 } |
| * console.log(order); // [1, 3, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 3, 2, 4]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.omitSeries(array, iterator, function(err, res) { |
| * console.log(res); // { '2': 2, '3': 4 } |
| * console.log(order); // [[0, 1], [3, 1], [2, 2], [4, 3]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2, d: 4 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.omitSeries(object, iterator, function(err, res) { |
| * console.log(res); // { c: 2, d: 4 } |
| * console.log(order); // [1, 3, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2, d: 4 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.omitSeries(object, iterator, function(err, res) { |
| * console.log(res); // { c: 2, d: 4 } |
| * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c'], [4, 'd']] |
| * }); |
| * |
| */ |
| var omitSeries = createPickSeries(false); |
| |
| /** |
| * @memberof async |
| * @namespace omitLimit |
| * @param {Array|Object} collection |
| * @param {number} limit - limit >= 1 |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.omitLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // { '3': 4, '4': 2 } |
| * console.log(order); // [1, 3, 5, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.omitLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // { '3': 4, '4': 2 } |
| * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.omitLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // { d: 4, e: 2 } |
| * console.log(order); // [1, 3, 5, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.omitLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // { d: 4, e: 2 } |
| * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']] |
| * }); |
| * |
| */ |
| var omitLimit = createPickLimit(false); |
| |
| /** |
| * @memberof async |
| * @namespace transform |
| * @param {Array|Object} collection |
| * @param {Array|Object|Function} [accumulator] |
| * @param {Function} [iterator] |
| * @param {Function} [callback] |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var collection = [1, 3, 2, 4]; |
| * var iterator = function(result, num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * result.push(num) |
| * done(); |
| * }, num * 10); |
| * }; |
| * async.transform(collection, iterator, function(err, res) { |
| * console.log(res); // [1, 2, 3, 4] |
| * console.log(order); // [1, 2, 3, 4] |
| * }); |
| * |
| * @example |
| * |
| * // array with index and accumulator |
| * var order = []; |
| * var collection = [1, 3, 2, 4]; |
| * var iterator = function(result, num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * result[index] = num; |
| * done(); |
| * }, num * 10); |
| * }; |
| * async.transform(collection, {}, iterator, function(err, res) { |
| * console.log(res); // { '0': 1, '1': 3, '2': 2, '3': 4 } |
| * console.log(order); // [[1, 0], [2, 2], [3, 1], [4, 3]] |
| * }); |
| * |
| * @example |
| * |
| * // object with accumulator |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2, d: 4 }; |
| * var iterator = function(result, num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * result.push(num); |
| * done(); |
| * }, num * 10); |
| * }; |
| * async.transform(collection, [], iterator, function(err, res) { |
| * console.log(res); // [1, 2, 3, 4] |
| * console.log(order); // [1, 2, 3, 4] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2, d: 4 }; |
| * var iterator = function(result, num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * result[key] = num; |
| * done(); |
| * }, num * 10); |
| * }; |
| * async.transform(collection, iterator, function(err, res) { |
| * console.log(res); // { a: 1, b: 3, c: 2, d: 4 } |
| * console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b'], [4, 'd']] |
| * }); |
| * |
| */ |
| var transform = createTransform(arrayEachResult, baseEachResult, symbolEachResult); |
| |
| /** |
| * @memberof async |
| * @namespace sortBy |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.sortBy(array, iterator, function(err, res) { |
| * console.log(res); // [1, 2, 3]; |
| * console.log(order); // [1, 2, 3] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.sortBy(array, iterator, function(err, res) { |
| * console.log(res); // [1, 2, 3] |
| * console.log(order); // [[1, 0], [2, 2], [3, 1]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.sortBy(object, iterator, function(err, res) { |
| * console.log(res); // [1, 2, 3] |
| * console.log(order); // [1, 2, 3] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.sortBy(object, iterator, function(err, res) { |
| * console.log(res); // [1, 2, 3] |
| * console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']] |
| * }); |
| * |
| */ |
| var sortBy = createSortBy(arrayEachIndexValue, baseEachIndexValue, symbolEachIndexValue); |
| |
| /** |
| * @memberof async |
| * @namespace concat |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, [num]); |
| * }, num * 10); |
| * }; |
| * async.concat(array, iterator, function(err, res) { |
| * console.log(res); // [1, 2, 3]; |
| * console.log(order); // [1, 2, 3] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, [num]); |
| * }, num * 10); |
| * }; |
| * async.concat(array, iterator, function(err, res) { |
| * console.log(res); // [1, 2, 3] |
| * console.log(order); // [[1, 0], [2, 2], [3, 1]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, [num]); |
| * }, num * 10); |
| * }; |
| * async.concat(object, iterator, function(err, res) { |
| * console.log(res); // [1, 2, 3] |
| * console.log(order); // [1, 2, 3] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, [num]); |
| * }, num * 10); |
| * }; |
| * async.concat(object, iterator, function(err, res) { |
| * console.log(res); // [1, 2, 3] |
| * console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']] |
| * }); |
| * |
| */ |
| var concat = createConcat(arrayEachIndex, baseEachIndex, symbolEachIndex); |
| |
| /** |
| * @memberof async |
| * @namespace groupBy |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [4.2, 6.4, 6.1]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, Math.floor(num)); |
| * }, num * 10); |
| * }; |
| * async.groupBy(array, iterator, function(err, res) { |
| * console.log(res); // { '4': [4.2], '6': [6.1, 6.4] } |
| * console.log(order); // [4.2, 6.1, 6.4] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [4.2, 6.4, 6.1]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, Math.floor(num)); |
| * }, num * 10); |
| * }; |
| * async.groupBy(array, iterator, function(err, res) { |
| * console.log(res); // { '4': [4.2], '6': [6.1, 6.4] } |
| * console.log(order); // [[4.2, 0], [6.1, 2], [6.4, 1]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 4.2, b: 6.4, c: 6.1 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, Math.floor(num)); |
| * }, num * 10); |
| * }; |
| * async.groupBy(object, iterator, function(err, res) { |
| * console.log(res); // { '4': [4.2], '6': [6.1, 6.4] } |
| * console.log(order); // [4.2, 6.1, 6.4] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 4.2, b: 6.4, c: 6.1 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, Math.floor(num)); |
| * }, num * 10); |
| * }; |
| * async.groupBy(object, iterator, function(err, res) { |
| * console.log(res); // { '4': [4.2], '6': [6.1, 6.4] } |
| * console.log(order); // [[4.2, 'a'], [6.1, 'c'], [6.4, 'b']] |
| * }); |
| * |
| */ |
| var groupBy = createGroupBy(arrayEachValue, baseEachValue, symbolEachValue); |
| |
| /** |
| * @memberof async |
| * @namespace parallel |
| * @param {Array|Object} tasks - functions |
| * @param {Function} callback |
| * @example |
| * |
| * var order = []; |
| * var tasks = [ |
| * function(done) { |
| * setTimeout(function() { |
| * order.push(1); |
| * done(null, 1); |
| * }, 10); |
| * }, |
| * function(done) { |
| * setTimeout(function() { |
| * order.push(2); |
| * done(null, 2); |
| * }, 30); |
| * }, |
| * function(done) { |
| * setTimeout(function() { |
| * order.push(3); |
| * done(null, 3); |
| * }, 40); |
| * }, |
| * function(done) { |
| * setTimeout(function() { |
| * order.push(4); |
| * done(null, 4); |
| * }, 20); |
| * } |
| * ]; |
| * async.parallel(tasks, function(err, res) { |
| * console.log(res); // [1, 2, 3, 4]; |
| * console.log(order); // [1, 4, 2, 3] |
| * }); |
| * |
| * @example |
| * |
| * var order = []; |
| * var tasks = { |
| * 'a': function(done) { |
| * setTimeout(function() { |
| * order.push(1); |
| * done(null, 1); |
| * }, 10); |
| * }, |
| * 'b': function(done) { |
| * setTimeout(function() { |
| * order.push(2); |
| * done(null, 2); |
| * }, 30); |
| * }, |
| * 'c': function(done) { |
| * setTimeout(function() { |
| * order.push(3); |
| * done(null, 3); |
| * }, 40); |
| * }, |
| * 'd': function(done) { |
| * setTimeout(function() { |
| * order.push(4); |
| * done(null, 4); |
| * }, 20); |
| * } |
| * }; |
| * async.parallel(tasks, function(err, res) { |
| * console.log(res); // { a: 1, b: 2, c: 3, d:4 } |
| * console.log(order); // [1, 4, 2, 3] |
| * }); |
| * |
| */ |
| var parallel = createParallel(arrayEachFunc, baseEachFunc); |
| |
| /** |
| * @memberof async |
| * @namespace applyEach |
| */ |
| var applyEach = createApplyEach(map); |
| |
| /** |
| * @memberof async |
| * @namespace applyEachSeries |
| */ |
| var applyEachSeries = createApplyEach(mapSeries); |
| |
| /** |
| * @memberof async |
| * @namespace log |
| */ |
| var log = createLogger('log'); |
| |
| /** |
| * @memberof async |
| * @namespace dir |
| */ |
| var dir = createLogger('dir'); |
| |
| /** |
| * @version 2.6.1 |
| * @namespace async |
| */ |
| var index = { |
| VERSION: '2.6.1', |
| |
| // Collections |
| each: each, |
| eachSeries: eachSeries, |
| eachLimit: eachLimit, |
| forEach: each, |
| forEachSeries: eachSeries, |
| forEachLimit: eachLimit, |
| eachOf: each, |
| eachOfSeries: eachSeries, |
| eachOfLimit: eachLimit, |
| forEachOf: each, |
| forEachOfSeries: eachSeries, |
| forEachOfLimit: eachLimit, |
| map: map, |
| mapSeries: mapSeries, |
| mapLimit: mapLimit, |
| mapValues: mapValues, |
| mapValuesSeries: mapValuesSeries, |
| mapValuesLimit: mapValuesLimit, |
| filter: filter, |
| filterSeries: filterSeries, |
| filterLimit: filterLimit, |
| select: filter, |
| selectSeries: filterSeries, |
| selectLimit: filterLimit, |
| reject: reject, |
| rejectSeries: rejectSeries, |
| rejectLimit: rejectLimit, |
| detect: detect, |
| detectSeries: detectSeries, |
| detectLimit: detectLimit, |
| find: detect, |
| findSeries: detectSeries, |
| findLimit: detectLimit, |
| pick: pick, |
| pickSeries: pickSeries, |
| pickLimit: pickLimit, |
| omit: omit, |
| omitSeries: omitSeries, |
| omitLimit: omitLimit, |
| reduce: reduce, |
| inject: reduce, |
| foldl: reduce, |
| reduceRight: reduceRight, |
| foldr: reduceRight, |
| transform: transform, |
| transformSeries: transformSeries, |
| transformLimit: transformLimit, |
| sortBy: sortBy, |
| sortBySeries: sortBySeries, |
| sortByLimit: sortByLimit, |
| some: some, |
| someSeries: someSeries, |
| someLimit: someLimit, |
| any: some, |
| anySeries: someSeries, |
| anyLimit: someLimit, |
| every: every, |
| everySeries: everySeries, |
| everyLimit: everyLimit, |
| all: every, |
| allSeries: everySeries, |
| allLimit: everyLimit, |
| concat: concat, |
| concatSeries: concatSeries, |
| concatLimit: concatLimit, |
| groupBy: groupBy, |
| groupBySeries: groupBySeries, |
| groupByLimit: groupByLimit, |
| |
| // Control Flow |
| parallel: parallel, |
| series: series, |
| parallelLimit: parallelLimit, |
| tryEach: tryEach, |
| waterfall: waterfall, |
| angelFall: angelFall, |
| angelfall: angelFall, |
| whilst: whilst, |
| doWhilst: doWhilst, |
| until: until, |
| doUntil: doUntil, |
| during: during, |
| doDuring: doDuring, |
| forever: forever, |
| compose: compose, |
| seq: seq, |
| applyEach: applyEach, |
| applyEachSeries: applyEachSeries, |
| queue: queue, |
| priorityQueue: priorityQueue, |
| cargo: cargo, |
| auto: auto, |
| autoInject: autoInject, |
| retry: retry, |
| retryable: retryable, |
| iterator: iterator, |
| times: times, |
| timesSeries: timesSeries, |
| timesLimit: timesLimit, |
| race: race, |
| |
| // Utils |
| apply: apply, |
| nextTick: asyncNextTick, |
| setImmediate: asyncSetImmediate, |
| memoize: memoize, |
| unmemoize: unmemoize, |
| ensureAsync: ensureAsync, |
| constant: constant, |
| asyncify: asyncify, |
| wrapSync: asyncify, |
| log: log, |
| dir: dir, |
| reflect: reflect, |
| reflectAll: reflectAll, |
| timeout: timeout, |
| createLogger: createLogger, |
| |
| // Mode |
| safe: safe, |
| fast: fast |
| }; |
| |
| exports['default'] = index; |
| baseEachSync( |
| index, |
| function(func, key) { |
| exports[key] = func; |
| }, |
| nativeKeys(index) |
| ); |
| |
| /** |
| * @private |
| */ |
| function createImmediate(safeMode) { |
| var delay = function delay(fn) { |
| var args = slice(arguments, 1); |
| setTimeout(function() { |
| fn.apply(null, args); |
| }); |
| }; |
| asyncSetImmediate = typeof setImmediate === func ? setImmediate : delay; |
| if (typeof process === obj && typeof process.nextTick === func) { |
| nextTick = /^v0.10/.test(process.version) ? asyncSetImmediate : process.nextTick; |
| asyncNextTick = /^v0/.test(process.version) ? asyncSetImmediate : process.nextTick; |
| } else { |
| asyncNextTick = nextTick = asyncSetImmediate; |
| } |
| if (safeMode === false) { |
| nextTick = function(cb) { |
| cb(); |
| }; |
| } |
| } |
| |
| /* sync functions based on lodash */ |
| |
| /** |
| * Converts `arguments` to an array. |
| * |
| * @private |
| * @param {Array} array = The array to slice. |
| */ |
| function createArray(array) { |
| var index = -1; |
| var size = array.length; |
| var result = Array(size); |
| |
| while (++index < size) { |
| result[index] = array[index]; |
| } |
| return result; |
| } |
| |
| /** |
| * Create an array from `start` |
| * |
| * @private |
| * @param {Array} array - The array to slice. |
| * @param {number} start - The start position. |
| */ |
| function slice(array, start) { |
| var end = array.length; |
| var index = -1; |
| var size = end - start; |
| if (size <= 0) { |
| return []; |
| } |
| var result = Array(size); |
| |
| while (++index < size) { |
| result[index] = array[index + start]; |
| } |
| return result; |
| } |
| |
| /** |
| * @private |
| * @param {Object} object |
| */ |
| function objectClone(object) { |
| var keys = nativeKeys(object); |
| var size = keys.length; |
| var index = -1; |
| var result = {}; |
| |
| while (++index < size) { |
| var key = keys[index]; |
| result[key] = object[key]; |
| } |
| return result; |
| } |
| |
| /** |
| * Create an array with all falsey values removed. |
| * |
| * @private |
| * @param {Array} array - The array to compact. |
| */ |
| function compact(array) { |
| var index = -1; |
| var size = array.length; |
| var result = []; |
| |
| while (++index < size) { |
| var value = array[index]; |
| if (value) { |
| result[result.length] = value; |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * Create an array of reverse sequence. |
| * |
| * @private |
| * @param {Array} array - The array to reverse. |
| */ |
| function reverse(array) { |
| var index = -1; |
| var size = array.length; |
| var result = Array(size); |
| var resIndex = size; |
| |
| while (++index < size) { |
| result[--resIndex] = array[index]; |
| } |
| return result; |
| } |
| |
| /** |
| * Checks if key exists in object property. |
| * |
| * @private |
| * @param {Object} object - The object to inspect. |
| * @param {string} key - The key to check. |
| */ |
| function has(object, key) { |
| return object.hasOwnProperty(key); |
| } |
| |
| /** |
| * Check if target exists in array. |
| * @private |
| * @param {Array} array |
| * @param {*} target |
| */ |
| function notInclude(array, target) { |
| var index = -1; |
| var size = array.length; |
| |
| while (++index < size) { |
| if (array[index] === target) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * @private |
| * @param {Array} array - The array to iterate over. |
| * @param {Function} iterator - The function invoked per iteration. |
| */ |
| function arrayEachSync(array, iterator) { |
| var index = -1; |
| var size = array.length; |
| |
| while (++index < size) { |
| iterator(array[index], index); |
| } |
| return array; |
| } |
| |
| /** |
| * @private |
| * @param {Object} object - The object to iterate over. |
| * @param {Function} iterator - The function invoked per iteration. |
| * @param {Array} keys |
| */ |
| function baseEachSync(object, iterator, keys) { |
| var index = -1; |
| var size = keys.length; |
| |
| while (++index < size) { |
| var key = keys[index]; |
| iterator(object[key], key); |
| } |
| return object; |
| } |
| |
| /** |
| * @private |
| * @param {number} n |
| * @param {Function} iterator |
| */ |
| function timesSync(n, iterator) { |
| var index = -1; |
| while (++index < n) { |
| iterator(index); |
| } |
| } |
| |
| /** |
| * @private |
| * @param {Array} array |
| * @param {number[]} criteria |
| */ |
| function sortByCriteria(array, criteria) { |
| var l = array.length; |
| var indices = Array(l); |
| var i; |
| for (i = 0; i < l; i++) { |
| indices[i] = i; |
| } |
| quickSort(criteria, 0, l - 1, indices); |
| var result = Array(l); |
| for (var n = 0; n < l; n++) { |
| i = indices[n]; |
| result[n] = i === undefined ? array[n] : array[i]; |
| } |
| return result; |
| } |
| |
| function partition(array, i, j, mid, indices) { |
| var l = i; |
| var r = j; |
| while (l <= r) { |
| i = l; |
| while (l < r && array[l] < mid) { |
| l++; |
| } |
| while (r >= i && array[r] >= mid) { |
| r--; |
| } |
| if (l > r) { |
| break; |
| } |
| swap(array, indices, l++, r--); |
| } |
| return l; |
| } |
| |
| function swap(array, indices, l, r) { |
| var n = array[l]; |
| array[l] = array[r]; |
| array[r] = n; |
| var i = indices[l]; |
| indices[l] = indices[r]; |
| indices[r] = i; |
| } |
| |
| function quickSort(array, i, j, indices) { |
| if (i === j) { |
| return; |
| } |
| var k = i; |
| while (++k <= j && array[i] === array[k]) { |
| var l = k - 1; |
| if (indices[l] > indices[k]) { |
| var index = indices[l]; |
| indices[l] = indices[k]; |
| indices[k] = index; |
| } |
| } |
| if (k > j) { |
| return; |
| } |
| var p = array[i] > array[k] ? i : k; |
| k = partition(array, i, j, array[p], indices); |
| quickSort(array, i, k - 1, indices); |
| quickSort(array, k, j, indices); |
| } |
| |
| /** |
| * @Private |
| */ |
| function makeConcatResult(array) { |
| var result = []; |
| arrayEachSync(array, function(value) { |
| if (value === noop) { |
| return; |
| } |
| if (isArray(value)) { |
| nativePush.apply(result, value); |
| } else { |
| result.push(value); |
| } |
| }); |
| return result; |
| } |
| |
| /* async functions */ |
| |
| /** |
| * @private |
| */ |
| function arrayEach(array, iterator, callback) { |
| var index = -1; |
| var size = array.length; |
| |
| if (iterator.length === 3) { |
| while (++index < size) { |
| iterator(array[index], index, onlyOnce(callback)); |
| } |
| } else { |
| while (++index < size) { |
| iterator(array[index], onlyOnce(callback)); |
| } |
| } |
| } |
| |
| /** |
| * @private |
| */ |
| function baseEach(object, iterator, callback, keys) { |
| var key; |
| var index = -1; |
| var size = keys.length; |
| |
| if (iterator.length === 3) { |
| while (++index < size) { |
| key = keys[index]; |
| iterator(object[key], key, onlyOnce(callback)); |
| } |
| } else { |
| while (++index < size) { |
| iterator(object[keys[index]], onlyOnce(callback)); |
| } |
| } |
| } |
| |
| /** |
| * @private |
| */ |
| function symbolEach(collection, iterator, callback) { |
| var iter = collection[iteratorSymbol](); |
| var index = 0; |
| var item; |
| if (iterator.length === 3) { |
| while ((item = iter.next()).done === false) { |
| iterator(item.value, index++, onlyOnce(callback)); |
| } |
| } else { |
| while ((item = iter.next()).done === false) { |
| index++; |
| iterator(item.value, onlyOnce(callback)); |
| } |
| } |
| return index; |
| } |
| |
| /** |
| * @private |
| */ |
| function arrayEachResult(array, result, iterator, callback) { |
| var index = -1; |
| var size = array.length; |
| |
| if (iterator.length === 4) { |
| while (++index < size) { |
| iterator(result, array[index], index, onlyOnce(callback)); |
| } |
| } else { |
| while (++index < size) { |
| iterator(result, array[index], onlyOnce(callback)); |
| } |
| } |
| } |
| |
| /** |
| * @private |
| */ |
| function baseEachResult(object, result, iterator, callback, keys) { |
| var key; |
| var index = -1; |
| var size = keys.length; |
| |
| if (iterator.length === 4) { |
| while (++index < size) { |
| key = keys[index]; |
| iterator(result, object[key], key, onlyOnce(callback)); |
| } |
| } else { |
| while (++index < size) { |
| iterator(result, object[keys[index]], onlyOnce(callback)); |
| } |
| } |
| } |
| |
| /** |
| * @private |
| */ |
| function symbolEachResult(collection, result, iterator, callback) { |
| var item; |
| var index = 0; |
| var iter = collection[iteratorSymbol](); |
| |
| if (iterator.length === 4) { |
| while ((item = iter.next()).done === false) { |
| iterator(result, item.value, index++, onlyOnce(callback)); |
| } |
| } else { |
| while ((item = iter.next()).done === false) { |
| index++; |
| iterator(result, item.value, onlyOnce(callback)); |
| } |
| } |
| return index; |
| } |
| |
| /** |
| * @private |
| */ |
| function arrayEachFunc(array, createCallback) { |
| var index = -1; |
| var size = array.length; |
| |
| while (++index < size) { |
| array[index](createCallback(index)); |
| } |
| } |
| |
| /** |
| * @private |
| */ |
| function baseEachFunc(object, createCallback, keys) { |
| var key; |
| var index = -1; |
| var size = keys.length; |
| |
| while (++index < size) { |
| key = keys[index]; |
| object[key](createCallback(key)); |
| } |
| } |
| |
| /** |
| * @private |
| */ |
| function arrayEachIndex(array, iterator, createCallback) { |
| var index = -1; |
| var size = array.length; |
| |
| if (iterator.length === 3) { |
| while (++index < size) { |
| iterator(array[index], index, createCallback(index)); |
| } |
| } else { |
| while (++index < size) { |
| iterator(array[index], createCallback(index)); |
| } |
| } |
| } |
| |
| /** |
| * @private |
| */ |
| function baseEachIndex(object, iterator, createCallback, keys) { |
| var key; |
| var index = -1; |
| var size = keys.length; |
| |
| if (iterator.length === 3) { |
| while (++index < size) { |
| key = keys[index]; |
| iterator(object[key], key, createCallback(index)); |
| } |
| } else { |
| while (++index < size) { |
| iterator(object[keys[index]], createCallback(index)); |
| } |
| } |
| } |
| |
| /** |
| * @private |
| */ |
| function symbolEachIndex(collection, iterator, createCallback) { |
| var item; |
| var index = 0; |
| var iter = collection[iteratorSymbol](); |
| |
| if (iterator.length === 3) { |
| while ((item = iter.next()).done === false) { |
| iterator(item.value, index, createCallback(index++)); |
| } |
| } else { |
| while ((item = iter.next()).done === false) { |
| iterator(item.value, createCallback(index++)); |
| } |
| } |
| return index; |
| } |
| |
| /** |
| * @private |
| */ |
| function baseEachKey(object, iterator, createCallback, keys) { |
| var key; |
| var index = -1; |
| var size = keys.length; |
| |
| if (iterator.length === 3) { |
| while (++index < size) { |
| key = keys[index]; |
| iterator(object[key], key, createCallback(key)); |
| } |
| } else { |
| while (++index < size) { |
| key = keys[index]; |
| iterator(object[key], createCallback(key)); |
| } |
| } |
| } |
| |
| /** |
| * @private |
| */ |
| function symbolEachKey(collection, iterator, createCallback) { |
| var item; |
| var index = 0; |
| var iter = collection[iteratorSymbol](); |
| |
| if (iterator.length === 3) { |
| while ((item = iter.next()).done === false) { |
| iterator(item.value, index, createCallback(index++)); |
| } |
| } else { |
| while ((item = iter.next()).done === false) { |
| iterator(item.value, createCallback(index++)); |
| } |
| } |
| return index; |
| } |
| |
| /** |
| * @private |
| */ |
| function arrayEachValue(array, iterator, createCallback) { |
| var value; |
| var index = -1; |
| var size = array.length; |
| |
| if (iterator.length === 3) { |
| while (++index < size) { |
| value = array[index]; |
| iterator(value, index, createCallback(value)); |
| } |
| } else { |
| while (++index < size) { |
| value = array[index]; |
| iterator(value, createCallback(value)); |
| } |
| } |
| } |
| |
| /** |
| * @private |
| */ |
| function baseEachValue(object, iterator, createCallback, keys) { |
| var key, value; |
| var index = -1; |
| var size = keys.length; |
| |
| if (iterator.length === 3) { |
| while (++index < size) { |
| key = keys[index]; |
| value = object[key]; |
| iterator(value, key, createCallback(value)); |
| } |
| } else { |
| while (++index < size) { |
| value = object[keys[index]]; |
| iterator(value, createCallback(value)); |
| } |
| } |
| } |
| |
| /** |
| * @private |
| */ |
| function symbolEachValue(collection, iterator, createCallback) { |
| var value, item; |
| var index = 0; |
| var iter = collection[iteratorSymbol](); |
| |
| if (iterator.length === 3) { |
| while ((item = iter.next()).done === false) { |
| value = item.value; |
| iterator(value, index++, createCallback(value)); |
| } |
| } else { |
| while ((item = iter.next()).done === false) { |
| index++; |
| value = item.value; |
| iterator(value, createCallback(value)); |
| } |
| } |
| return index; |
| } |
| |
| /** |
| * @private |
| */ |
| function arrayEachIndexValue(array, iterator, createCallback) { |
| var value; |
| var index = -1; |
| var size = array.length; |
| |
| if (iterator.length === 3) { |
| while (++index < size) { |
| value = array[index]; |
| iterator(value, index, createCallback(index, value)); |
| } |
| } else { |
| while (++index < size) { |
| value = array[index]; |
| iterator(value, createCallback(index, value)); |
| } |
| } |
| } |
| |
| /** |
| * @private |
| */ |
| function baseEachIndexValue(object, iterator, createCallback, keys) { |
| var key, value; |
| var index = -1; |
| var size = keys.length; |
| |
| if (iterator.length === 3) { |
| while (++index < size) { |
| key = keys[index]; |
| value = object[key]; |
| iterator(value, key, createCallback(index, value)); |
| } |
| } else { |
| while (++index < size) { |
| value = object[keys[index]]; |
| iterator(value, createCallback(index, value)); |
| } |
| } |
| } |
| |
| /** |
| * @private |
| */ |
| function symbolEachIndexValue(collection, iterator, createCallback) { |
| var value, item; |
| var index = 0; |
| var iter = collection[iteratorSymbol](); |
| |
| if (iterator.length === 3) { |
| while ((item = iter.next()).done === false) { |
| value = item.value; |
| iterator(value, index, createCallback(index++, value)); |
| } |
| } else { |
| while ((item = iter.next()).done === false) { |
| value = item.value; |
| iterator(value, createCallback(index++, value)); |
| } |
| } |
| return index; |
| } |
| |
| /** |
| * @private |
| */ |
| function baseEachKeyValue(object, iterator, createCallback, keys) { |
| var key, value; |
| var index = -1; |
| var size = keys.length; |
| |
| if (iterator.length === 3) { |
| while (++index < size) { |
| key = keys[index]; |
| value = object[key]; |
| iterator(value, key, createCallback(key, value)); |
| } |
| } else { |
| while (++index < size) { |
| key = keys[index]; |
| value = object[key]; |
| iterator(value, createCallback(key, value)); |
| } |
| } |
| } |
| |
| /** |
| * @private |
| */ |
| function symbolEachKeyValue(collection, iterator, createCallback) { |
| var value, item; |
| var index = 0; |
| var iter = collection[iteratorSymbol](); |
| |
| if (iterator.length === 3) { |
| while ((item = iter.next()).done === false) { |
| value = item.value; |
| iterator(value, index, createCallback(index++, value)); |
| } |
| } else { |
| while ((item = iter.next()).done === false) { |
| value = item.value; |
| iterator(value, createCallback(index++, value)); |
| } |
| } |
| return index; |
| } |
| |
| /** |
| * @private |
| * @param {Function} func |
| */ |
| function onlyOnce(func) { |
| return function(err, res) { |
| var fn = func; |
| func = throwError; |
| fn(err, res); |
| }; |
| } |
| |
| /** |
| * @private |
| * @param {Function} func |
| */ |
| function once(func) { |
| return function(err, res) { |
| var fn = func; |
| func = noop; |
| fn(err, res); |
| }; |
| } |
| |
| /** |
| * @private |
| * @param {Function} arrayEach |
| * @param {Function} baseEach |
| */ |
| function createEach(arrayEach, baseEach, symbolEach) { |
| return function each(collection, iterator, callback) { |
| callback = once(callback || noop); |
| var size, keys; |
| var completed = 0; |
| if (isArray(collection)) { |
| size = collection.length; |
| arrayEach(collection, iterator, done); |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| size = symbolEach(collection, iterator, done); |
| size && size === completed && callback(null); |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| size = keys.length; |
| baseEach(collection, iterator, done, keys); |
| } |
| if (!size) { |
| callback(null); |
| } |
| |
| function done(err, bool) { |
| if (err) { |
| callback = once(callback); |
| callback(err); |
| } else if (++completed === size) { |
| callback(null); |
| } else if (bool === false) { |
| callback = once(callback); |
| callback(null); |
| } |
| } |
| }; |
| } |
| |
| /** |
| * @private |
| * @param {Function} arrayEach |
| * @param {Function} baseEach |
| * @param {Function} symbolEach |
| */ |
| function createMap(arrayEach, baseEach, symbolEach, useArray) { |
| var init, clone; |
| if (useArray) { |
| init = Array; |
| clone = createArray; |
| } else { |
| init = function() { |
| return {}; |
| }; |
| clone = objectClone; |
| } |
| |
| return function(collection, iterator, callback) { |
| callback = callback || noop; |
| var size, keys, result; |
| var completed = 0; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| result = init(size); |
| arrayEach(collection, iterator, createCallback); |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| // TODO: size could be changed |
| result = init(0); |
| size = symbolEach(collection, iterator, createCallback); |
| size && size === completed && callback(null, result); |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| size = keys.length; |
| result = init(size); |
| baseEach(collection, iterator, createCallback, keys); |
| } |
| if (!size) { |
| callback(null, init()); |
| } |
| |
| function createCallback(key) { |
| return function done(err, res) { |
| if (key === null) { |
| throwError(); |
| } |
| if (err) { |
| key = null; |
| callback = once(callback); |
| callback(err, clone(result)); |
| return; |
| } |
| result[key] = res; |
| key = null; |
| if (++completed === size) { |
| callback(null, result); |
| } |
| }; |
| } |
| }; |
| } |
| |
| /** |
| * @private |
| * @param {Function} arrayEach |
| * @param {Function} baseEach |
| * @param {Function} symbolEach |
| * @param {boolean} bool |
| */ |
| function createFilter(arrayEach, baseEach, symbolEach, bool) { |
| return function(collection, iterator, callback) { |
| callback = callback || noop; |
| var size, keys, result; |
| var completed = 0; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| result = Array(size); |
| arrayEach(collection, iterator, createCallback); |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| result = []; |
| size = symbolEach(collection, iterator, createCallback); |
| size && size === completed && callback(null, compact(result)); |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| size = keys.length; |
| result = Array(size); |
| baseEach(collection, iterator, createCallback, keys); |
| } |
| if (!size) { |
| return callback(null, []); |
| } |
| |
| function createCallback(index, value) { |
| return function done(err, res) { |
| if (index === null) { |
| throwError(); |
| } |
| if (err) { |
| index = null; |
| callback = once(callback); |
| callback(err); |
| return; |
| } |
| if (!!res === bool) { |
| result[index] = value; |
| } |
| index = null; |
| if (++completed === size) { |
| callback(null, compact(result)); |
| } |
| }; |
| } |
| }; |
| } |
| |
| /** |
| * @private |
| * @param {boolean} bool |
| */ |
| function createFilterSeries(bool) { |
| return function(collection, iterator, callback) { |
| callback = onlyOnce(callback || noop); |
| var size, key, value, keys, iter, item, iterate; |
| var sync = false; |
| var completed = 0; |
| var result = []; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator; |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| size = Infinity; |
| iter = collection[iteratorSymbol](); |
| iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator; |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| size = keys.length; |
| iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator; |
| } |
| if (!size) { |
| return callback(null, []); |
| } |
| iterate(); |
| |
| function arrayIterator() { |
| value = collection[completed]; |
| iterator(value, done); |
| } |
| |
| function arrayIteratorWithIndex() { |
| value = collection[completed]; |
| iterator(value, completed, done); |
| } |
| |
| function symbolIterator() { |
| item = iter.next(); |
| value = item.value; |
| item.done ? callback(null, result) : iterator(value, done); |
| } |
| |
| function symbolIteratorWithKey() { |
| item = iter.next(); |
| value = item.value; |
| item.done ? callback(null, result) : iterator(value, completed, done); |
| } |
| |
| function objectIterator() { |
| key = keys[completed]; |
| value = collection[key]; |
| iterator(value, done); |
| } |
| |
| function objectIteratorWithKey() { |
| key = keys[completed]; |
| value = collection[key]; |
| iterator(value, key, done); |
| } |
| |
| function done(err, res) { |
| if (err) { |
| callback(err); |
| return; |
| } |
| if (!!res === bool) { |
| result[result.length] = value; |
| } |
| if (++completed === size) { |
| iterate = throwError; |
| callback(null, result); |
| } else if (sync) { |
| nextTick(iterate); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| } |
| }; |
| } |
| |
| /** |
| * @private |
| * @param {boolean} bool |
| */ |
| function createFilterLimit(bool) { |
| return function(collection, limit, iterator, callback) { |
| callback = callback || noop; |
| var size, index, key, value, keys, iter, item, iterate, result; |
| var sync = false; |
| var started = 0; |
| var completed = 0; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator; |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| size = Infinity; |
| result = []; |
| iter = collection[iteratorSymbol](); |
| iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator; |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| size = keys.length; |
| iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator; |
| } |
| if (!size || isNaN(limit) || limit < 1) { |
| return callback(null, []); |
| } |
| result = result || Array(size); |
| timesSync(limit > size ? size : limit, iterate); |
| |
| function arrayIterator() { |
| index = started++; |
| if (index < size) { |
| value = collection[index]; |
| iterator(value, createCallback(value, index)); |
| } |
| } |
| |
| function arrayIteratorWithIndex() { |
| index = started++; |
| if (index < size) { |
| value = collection[index]; |
| iterator(value, index, createCallback(value, index)); |
| } |
| } |
| |
| function symbolIterator() { |
| item = iter.next(); |
| if (item.done === false) { |
| value = item.value; |
| iterator(value, createCallback(value, started++)); |
| } else if (completed === started && iterator !== noop) { |
| iterator = noop; |
| callback(null, compact(result)); |
| } |
| } |
| |
| function symbolIteratorWithKey() { |
| item = iter.next(); |
| if (item.done === false) { |
| value = item.value; |
| iterator(value, started, createCallback(value, started++)); |
| } else if (completed === started && iterator !== noop) { |
| iterator = noop; |
| callback(null, compact(result)); |
| } |
| } |
| |
| function objectIterator() { |
| index = started++; |
| if (index < size) { |
| value = collection[keys[index]]; |
| iterator(value, createCallback(value, index)); |
| } |
| } |
| |
| function objectIteratorWithKey() { |
| index = started++; |
| if (index < size) { |
| key = keys[index]; |
| value = collection[key]; |
| iterator(value, key, createCallback(value, index)); |
| } |
| } |
| |
| function createCallback(value, index) { |
| return function(err, res) { |
| if (index === null) { |
| throwError(); |
| } |
| if (err) { |
| index = null; |
| iterate = noop; |
| callback = once(callback); |
| callback(err); |
| return; |
| } |
| if (!!res === bool) { |
| result[index] = value; |
| } |
| index = null; |
| if (++completed === size) { |
| callback = onlyOnce(callback); |
| callback(null, compact(result)); |
| } else if (sync) { |
| nextTick(iterate); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| }; |
| } |
| }; |
| } |
| |
| /** |
| * @memberof async |
| * @namespace eachSeries |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(); |
| * }, num * 10); |
| * }; |
| * async.eachSeries(array, iterator, function(err, res) { |
| * console.log(res); // undefined |
| * console.log(order); // [1, 3, 2] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(); |
| * }, num * 10); |
| * }; |
| * async.eachSeries(array, iterator, function(err, res) { |
| * console.log(res); // undefined |
| * console.log(order); // [[1, 0], [3, 1], [2, 2]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(); |
| * }, num * 10); |
| * }; |
| * async.eachSeries(object, iterator, function(err, res) { |
| * console.log(res); // undefined |
| * console.log(order); // [1, 3, 2] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(); |
| * }, num * 10); |
| * }; |
| * async.eachSeries(object, iterator, function(err, res) { |
| * console.log(res); // undefined |
| * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'b']] |
| * }); |
| * |
| * @example |
| * |
| * // break |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num !== 3); |
| * }, num * 10); |
| * }; |
| * async.eachSeries(array, iterator, function(err, res) { |
| * console.log(res); // undefined |
| * console.log(order); // [1, 3] |
| * }); |
| */ |
| function eachSeries(collection, iterator, callback) { |
| callback = onlyOnce(callback || noop); |
| var size, key, keys, iter, item, iterate; |
| var sync = false; |
| var completed = 0; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator; |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| size = Infinity; |
| iter = collection[iteratorSymbol](); |
| iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator; |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| size = keys.length; |
| iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator; |
| } |
| if (!size) { |
| return callback(null); |
| } |
| iterate(); |
| |
| function arrayIterator() { |
| iterator(collection[completed], done); |
| } |
| |
| function arrayIteratorWithIndex() { |
| iterator(collection[completed], completed, done); |
| } |
| |
| function symbolIterator() { |
| item = iter.next(); |
| item.done ? callback(null) : iterator(item.value, done); |
| } |
| |
| function symbolIteratorWithKey() { |
| item = iter.next(); |
| item.done ? callback(null) : iterator(item.value, completed, done); |
| } |
| |
| function objectIterator() { |
| iterator(collection[keys[completed]], done); |
| } |
| |
| function objectIteratorWithKey() { |
| key = keys[completed]; |
| iterator(collection[key], key, done); |
| } |
| |
| function done(err, bool) { |
| if (err) { |
| callback(err); |
| } else if (++completed === size || bool === false) { |
| iterate = throwError; |
| callback(null); |
| } else if (sync) { |
| nextTick(iterate); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace eachLimit |
| * @param {Array|Object} collection |
| * @param {number} limit - limit >= 1 |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(); |
| * }, num * 10); |
| * }; |
| * async.eachLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // undefined |
| * console.log(order); // [1, 3, 5, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(); |
| * }, num * 10); |
| * }; |
| * async.eachLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // undefined |
| * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(); |
| * }, num * 10); |
| * }; |
| * async.eachLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // undefined |
| * console.log(order); // [1, 3, 5, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(); |
| * }, num * 10); |
| * }; |
| * async.eachLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // undefined |
| * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']] |
| * }); |
| * |
| * @example |
| * |
| * // break |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num !== 5); |
| * }, num * 10); |
| * }; |
| * async.eachLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // undefined |
| * console.log(order); // [1, 3, 5] |
| * }); |
| * |
| */ |
| function eachLimit(collection, limit, iterator, callback) { |
| callback = callback || noop; |
| var size, index, key, keys, iter, item, iterate; |
| var sync = false; |
| var started = 0; |
| var completed = 0; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator; |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| size = Infinity; |
| iter = collection[iteratorSymbol](); |
| iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator; |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| size = keys.length; |
| iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator; |
| } else { |
| return callback(null); |
| } |
| if (!size || isNaN(limit) || limit < 1) { |
| return callback(null); |
| } |
| timesSync(limit > size ? size : limit, iterate); |
| |
| function arrayIterator() { |
| if (started < size) { |
| iterator(collection[started++], done); |
| } |
| } |
| |
| function arrayIteratorWithIndex() { |
| index = started++; |
| if (index < size) { |
| iterator(collection[index], index, done); |
| } |
| } |
| |
| function symbolIterator() { |
| item = iter.next(); |
| if (item.done === false) { |
| started++; |
| iterator(item.value, done); |
| } else if (completed === started && iterator !== noop) { |
| iterator = noop; |
| callback(null); |
| } |
| } |
| |
| function symbolIteratorWithKey() { |
| item = iter.next(); |
| if (item.done === false) { |
| iterator(item.value, started++, done); |
| } else if (completed === started && iterator !== noop) { |
| iterator = noop; |
| callback(null); |
| } |
| } |
| |
| function objectIterator() { |
| if (started < size) { |
| iterator(collection[keys[started++]], done); |
| } |
| } |
| |
| function objectIteratorWithKey() { |
| index = started++; |
| if (index < size) { |
| key = keys[index]; |
| iterator(collection[key], key, done); |
| } |
| } |
| |
| function done(err, bool) { |
| if (err || bool === false) { |
| iterate = noop; |
| callback = once(callback); |
| callback(err); |
| } else if (++completed === size) { |
| iterator = noop; |
| iterate = throwError; |
| callback = onlyOnce(callback); |
| callback(null); |
| } else if (sync) { |
| nextTick(iterate); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace mapSeries |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.mapSeries(array, iterator, function(err, res) { |
| * console.log(res); // [1, 3, 2]; |
| * console.log(order); // [1, 3, 2] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.mapSeries(array, iterator, function(err, res) { |
| * console.log(res); // [1, 3, 2] |
| * console.log(order); // [[1, 0], [3, 1], [2, 2]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.mapSeries(object, iterator, function(err, res) { |
| * console.log(res); // [1, 3, 2] |
| * console.log(order); // [1, 3, 2] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.mapSeries(object, iterator, function(err, res) { |
| * console.log(res); // [1, 3, 2] |
| * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']] |
| * }); |
| * |
| */ |
| function mapSeries(collection, iterator, callback) { |
| callback = callback || noop; |
| var size, key, keys, iter, item, result, iterate; |
| var sync = false; |
| var completed = 0; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator; |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| size = Infinity; |
| result = []; |
| iter = collection[iteratorSymbol](); |
| iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator; |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| size = keys.length; |
| iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator; |
| } |
| if (!size) { |
| return callback(null, []); |
| } |
| result = result || Array(size); |
| iterate(); |
| |
| function arrayIterator() { |
| iterator(collection[completed], done); |
| } |
| |
| function arrayIteratorWithIndex() { |
| iterator(collection[completed], completed, done); |
| } |
| |
| function symbolIterator() { |
| item = iter.next(); |
| item.done ? callback(null, result) : iterator(item.value, done); |
| } |
| |
| function symbolIteratorWithKey() { |
| item = iter.next(); |
| item.done ? callback(null, result) : iterator(item.value, completed, done); |
| } |
| |
| function objectIterator() { |
| iterator(collection[keys[completed]], done); |
| } |
| |
| function objectIteratorWithKey() { |
| key = keys[completed]; |
| iterator(collection[key], key, done); |
| } |
| |
| function done(err, res) { |
| if (err) { |
| iterate = throwError; |
| callback = onlyOnce(callback); |
| callback(err, createArray(result)); |
| return; |
| } |
| result[completed] = res; |
| if (++completed === size) { |
| iterate = throwError; |
| callback(null, result); |
| callback = throwError; |
| } else if (sync) { |
| nextTick(iterate); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace mapLimit |
| * @param {Array|Object} collection |
| * @param {number} limit - limit >= 1 |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.mapLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // [1, 5, 3, 4, 2] |
| * console.log(order); // [1, 3, 5, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.mapLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // [1, 5, 3, 4, 2] |
| * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.mapLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // [1, 5, 3, 4, 2] |
| * console.log(order); // [1, 3, 5, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.mapLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // [1, 5, 3, 4, 2] |
| * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']] |
| * }); |
| * |
| */ |
| function mapLimit(collection, limit, iterator, callback) { |
| callback = callback || noop; |
| var size, index, key, keys, iter, item, result, iterate; |
| var sync = false; |
| var started = 0; |
| var completed = 0; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator; |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| size = Infinity; |
| result = []; |
| iter = collection[iteratorSymbol](); |
| iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator; |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| size = keys.length; |
| iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator; |
| } |
| if (!size || isNaN(limit) || limit < 1) { |
| return callback(null, []); |
| } |
| result = result || Array(size); |
| timesSync(limit > size ? size : limit, iterate); |
| |
| function arrayIterator() { |
| index = started++; |
| if (index < size) { |
| iterator(collection[index], createCallback(index)); |
| } |
| } |
| |
| function arrayIteratorWithIndex() { |
| index = started++; |
| if (index < size) { |
| iterator(collection[index], index, createCallback(index)); |
| } |
| } |
| |
| function symbolIterator() { |
| item = iter.next(); |
| if (item.done === false) { |
| iterator(item.value, createCallback(started++)); |
| } else if (completed === started && iterator !== noop) { |
| iterator = noop; |
| callback(null, result); |
| } |
| } |
| |
| function symbolIteratorWithKey() { |
| item = iter.next(); |
| if (item.done === false) { |
| iterator(item.value, started, createCallback(started++)); |
| } else if (completed === started && iterator !== noop) { |
| iterator = noop; |
| callback(null, result); |
| } |
| } |
| |
| function objectIterator() { |
| index = started++; |
| if (index < size) { |
| iterator(collection[keys[index]], createCallback(index)); |
| } |
| } |
| |
| function objectIteratorWithKey() { |
| index = started++; |
| if (index < size) { |
| key = keys[index]; |
| iterator(collection[key], key, createCallback(index)); |
| } |
| } |
| |
| function createCallback(index) { |
| return function(err, res) { |
| if (index === null) { |
| throwError(); |
| } |
| if (err) { |
| index = null; |
| iterate = noop; |
| callback = once(callback); |
| callback(err, createArray(result)); |
| return; |
| } |
| result[index] = res; |
| index = null; |
| if (++completed === size) { |
| iterate = throwError; |
| callback(null, result); |
| callback = throwError; |
| } else if (sync) { |
| nextTick(iterate); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| }; |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace mapValuesSeries |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.mapValuesSeries(array, iterator, function(err, res) { |
| * console.log(res); // { '0': 1, '1': 3, '2': 2 } |
| * console.log(order); // [1, 3, 2] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.mapValuesSeries(array, iterator, function(err, res) { |
| * console.log(res); // { '0': 1, '1': 3, '2': 2 } |
| * console.log(order); // [[1, 0], [3, 1], [2, 2]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.mapValuesSeries(object, iterator, function(err, res) { |
| * console.log(res); // { a: 1, b: 3, c: 2 } |
| * console.log(order); // [1, 3, 2] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.mapValuesSeries(object, iterator, function(err, res) { |
| * console.log(res); // { a: 1, b: 3, c: 2 } |
| * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']] |
| * }); |
| * |
| */ |
| function mapValuesSeries(collection, iterator, callback) { |
| callback = callback || noop; |
| var size, key, keys, iter, item, iterate; |
| var sync = false; |
| var result = {}; |
| var completed = 0; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator; |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| size = Infinity; |
| iter = collection[iteratorSymbol](); |
| iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator; |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| size = keys.length; |
| iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator; |
| } |
| if (!size) { |
| return callback(null, result); |
| } |
| iterate(); |
| |
| function arrayIterator() { |
| key = completed; |
| iterator(collection[completed], done); |
| } |
| |
| function arrayIteratorWithIndex() { |
| key = completed; |
| iterator(collection[completed], completed, done); |
| } |
| |
| function symbolIterator() { |
| key = completed; |
| item = iter.next(); |
| item.done ? callback(null, result) : iterator(item.value, done); |
| } |
| |
| function symbolIteratorWithKey() { |
| key = completed; |
| item = iter.next(); |
| item.done ? callback(null, result) : iterator(item.value, completed, done); |
| } |
| |
| function objectIterator() { |
| key = keys[completed]; |
| iterator(collection[key], done); |
| } |
| |
| function objectIteratorWithKey() { |
| key = keys[completed]; |
| iterator(collection[key], key, done); |
| } |
| |
| function done(err, res) { |
| if (err) { |
| iterate = throwError; |
| callback = onlyOnce(callback); |
| callback(err, objectClone(result)); |
| return; |
| } |
| result[key] = res; |
| if (++completed === size) { |
| iterate = throwError; |
| callback(null, result); |
| callback = throwError; |
| } else if (sync) { |
| nextTick(iterate); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace mapValuesLimit |
| * @param {Array|Object} collection |
| * @param {number} limit - limit >= 1 |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.mapValuesLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // { '0': 1, '1': 5, '2': 3, '3': 4, '4': 2 } |
| * console.log(order); // [1, 3, 5, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.mapValuesLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // { '0': 1, '1': 5, '2': 3, '3': 4, '4': 2 } |
| * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.mapValuesLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // { a: 1, b: 5, c: 3, d: 4, e: 2 } |
| * console.log(order); // [1, 3, 5, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.mapValuesLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // { a: 1, b: 5, c: 3, d: 4, e: 2 } |
| * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']] |
| * }); |
| * |
| */ |
| function mapValuesLimit(collection, limit, iterator, callback) { |
| callback = callback || noop; |
| var size, index, key, keys, iter, item, iterate; |
| var sync = false; |
| var result = {}; |
| var started = 0; |
| var completed = 0; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator; |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| size = Infinity; |
| iter = collection[iteratorSymbol](); |
| iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator; |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| size = keys.length; |
| iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator; |
| } |
| if (!size || isNaN(limit) || limit < 1) { |
| return callback(null, result); |
| } |
| timesSync(limit > size ? size : limit, iterate); |
| |
| function arrayIterator() { |
| index = started++; |
| if (index < size) { |
| iterator(collection[index], createCallback(index)); |
| } |
| } |
| |
| function arrayIteratorWithIndex() { |
| index = started++; |
| if (index < size) { |
| iterator(collection[index], index, createCallback(index)); |
| } |
| } |
| |
| function symbolIterator() { |
| item = iter.next(); |
| if (item.done === false) { |
| iterator(item.value, createCallback(started++)); |
| } else if (completed === started && iterator !== noop) { |
| iterator = noop; |
| callback(null, result); |
| } |
| } |
| |
| function symbolIteratorWithKey() { |
| item = iter.next(); |
| if (item.done === false) { |
| iterator(item.value, started, createCallback(started++)); |
| } else if (completed === started && iterator !== noop) { |
| iterator = noop; |
| callback(null, result); |
| } |
| } |
| |
| function objectIterator() { |
| index = started++; |
| if (index < size) { |
| key = keys[index]; |
| iterator(collection[key], createCallback(key)); |
| } |
| } |
| |
| function objectIteratorWithKey() { |
| index = started++; |
| if (index < size) { |
| key = keys[index]; |
| iterator(collection[key], key, createCallback(key)); |
| } |
| } |
| |
| function createCallback(key) { |
| return function(err, res) { |
| if (key === null) { |
| throwError(); |
| } |
| if (err) { |
| key = null; |
| iterate = noop; |
| callback = once(callback); |
| callback(err, objectClone(result)); |
| return; |
| } |
| result[key] = res; |
| key = null; |
| if (++completed === size) { |
| callback(null, result); |
| } else if (sync) { |
| nextTick(iterate); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| }; |
| } |
| } |
| |
| /** |
| * @private |
| * @param {Function} arrayEach |
| * @param {Function} baseEach |
| * @param {Function} symbolEach |
| * @param {boolean} bool |
| */ |
| function createDetect(arrayEach, baseEach, symbolEach, bool) { |
| return function(collection, iterator, callback) { |
| callback = callback || noop; |
| var size, keys; |
| var completed = 0; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| arrayEach(collection, iterator, createCallback); |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| size = symbolEach(collection, iterator, createCallback); |
| size && size === completed && callback(null); |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| size = keys.length; |
| baseEach(collection, iterator, createCallback, keys); |
| } |
| if (!size) { |
| callback(null); |
| } |
| |
| function createCallback(value) { |
| var called = false; |
| return function done(err, res) { |
| if (called) { |
| throwError(); |
| } |
| called = true; |
| if (err) { |
| callback = once(callback); |
| callback(err); |
| } else if (!!res === bool) { |
| callback = once(callback); |
| callback(null, value); |
| } else if (++completed === size) { |
| callback(null); |
| } |
| }; |
| } |
| }; |
| } |
| |
| /** |
| * @private |
| * @param {boolean} bool |
| */ |
| function createDetectSeries(bool) { |
| return function(collection, iterator, callback) { |
| callback = onlyOnce(callback || noop); |
| var size, key, value, keys, iter, item, iterate; |
| var sync = false; |
| var completed = 0; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator; |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| size = Infinity; |
| iter = collection[iteratorSymbol](); |
| iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator; |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| size = keys.length; |
| iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator; |
| } |
| if (!size) { |
| return callback(null); |
| } |
| iterate(); |
| |
| function arrayIterator() { |
| value = collection[completed]; |
| iterator(value, done); |
| } |
| |
| function arrayIteratorWithIndex() { |
| value = collection[completed]; |
| iterator(value, completed, done); |
| } |
| |
| function symbolIterator() { |
| item = iter.next(); |
| value = item.value; |
| item.done ? callback(null) : iterator(value, done); |
| } |
| |
| function symbolIteratorWithKey() { |
| item = iter.next(); |
| value = item.value; |
| item.done ? callback(null) : iterator(value, completed, done); |
| } |
| |
| function objectIterator() { |
| value = collection[keys[completed]]; |
| iterator(value, done); |
| } |
| |
| function objectIteratorWithKey() { |
| key = keys[completed]; |
| value = collection[key]; |
| iterator(value, key, done); |
| } |
| |
| function done(err, res) { |
| if (err) { |
| callback(err); |
| } else if (!!res === bool) { |
| iterate = throwError; |
| callback(null, value); |
| } else if (++completed === size) { |
| iterate = throwError; |
| callback(null); |
| } else if (sync) { |
| nextTick(iterate); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| } |
| }; |
| } |
| |
| /** |
| * @private |
| * @param {boolean} bool |
| */ |
| function createDetectLimit(bool) { |
| return function(collection, limit, iterator, callback) { |
| callback = callback || noop; |
| var size, index, key, value, keys, iter, item, iterate; |
| var sync = false; |
| var started = 0; |
| var completed = 0; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator; |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| size = Infinity; |
| iter = collection[iteratorSymbol](); |
| iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator; |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| size = keys.length; |
| iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator; |
| } |
| if (!size || isNaN(limit) || limit < 1) { |
| return callback(null); |
| } |
| timesSync(limit > size ? size : limit, iterate); |
| |
| function arrayIterator() { |
| index = started++; |
| if (index < size) { |
| value = collection[index]; |
| iterator(value, createCallback(value)); |
| } |
| } |
| |
| function arrayIteratorWithIndex() { |
| index = started++; |
| if (index < size) { |
| value = collection[index]; |
| iterator(value, index, createCallback(value)); |
| } |
| } |
| |
| function symbolIterator() { |
| item = iter.next(); |
| if (item.done === false) { |
| started++; |
| value = item.value; |
| iterator(value, createCallback(value)); |
| } else if (completed === started && iterator !== noop) { |
| iterator = noop; |
| callback(null); |
| } |
| } |
| |
| function symbolIteratorWithKey() { |
| item = iter.next(); |
| if (item.done === false) { |
| value = item.value; |
| iterator(value, started++, createCallback(value)); |
| } else if (completed === started && iterator !== noop) { |
| iterator = noop; |
| callback(null); |
| } |
| } |
| |
| function objectIterator() { |
| index = started++; |
| if (index < size) { |
| value = collection[keys[index]]; |
| iterator(value, createCallback(value)); |
| } |
| } |
| |
| function objectIteratorWithKey() { |
| if (started < size) { |
| key = keys[started++]; |
| value = collection[key]; |
| iterator(value, key, createCallback(value)); |
| } |
| } |
| |
| function createCallback(value) { |
| var called = false; |
| return function(err, res) { |
| if (called) { |
| throwError(); |
| } |
| called = true; |
| if (err) { |
| iterate = noop; |
| callback = once(callback); |
| callback(err); |
| } else if (!!res === bool) { |
| iterate = noop; |
| callback = once(callback); |
| callback(null, value); |
| } else if (++completed === size) { |
| callback(null); |
| } else if (sync) { |
| nextTick(iterate); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| }; |
| } |
| }; |
| } |
| |
| /** |
| * @private |
| * @param {Function} arrayEach |
| * @param {Function} baseEach |
| * @param {Function} symbolEach |
| * @param {boolean} bool |
| */ |
| function createPick(arrayEach, baseEach, symbolEach, bool) { |
| return function(collection, iterator, callback) { |
| callback = callback || noop; |
| var size, keys; |
| var completed = 0; |
| var result = {}; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| arrayEach(collection, iterator, createCallback); |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| size = symbolEach(collection, iterator, createCallback); |
| size && size === completed && callback(null, result); |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| size = keys.length; |
| baseEach(collection, iterator, createCallback, keys); |
| } |
| if (!size) { |
| return callback(null, {}); |
| } |
| |
| function createCallback(key, value) { |
| return function done(err, res) { |
| if (key === null) { |
| throwError(); |
| } |
| if (err) { |
| key = null; |
| callback = once(callback); |
| callback(err, objectClone(result)); |
| return; |
| } |
| if (!!res === bool) { |
| result[key] = value; |
| } |
| key = null; |
| if (++completed === size) { |
| callback(null, result); |
| } |
| }; |
| } |
| }; |
| } |
| |
| /** |
| * @private |
| * @param {boolean} bool |
| */ |
| function createPickSeries(bool) { |
| return function(collection, iterator, callback) { |
| callback = onlyOnce(callback || noop); |
| var size, key, value, keys, iter, item, iterate; |
| var sync = false; |
| var result = {}; |
| var completed = 0; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator; |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| size = Infinity; |
| iter = collection[iteratorSymbol](); |
| iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator; |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| size = keys.length; |
| iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator; |
| } |
| if (!size) { |
| return callback(null, {}); |
| } |
| iterate(); |
| |
| function arrayIterator() { |
| key = completed; |
| value = collection[completed]; |
| iterator(value, done); |
| } |
| |
| function arrayIteratorWithIndex() { |
| key = completed; |
| value = collection[completed]; |
| iterator(value, completed, done); |
| } |
| |
| function symbolIterator() { |
| key = completed; |
| item = iter.next(); |
| value = item.value; |
| item.done ? callback(null, result) : iterator(value, done); |
| } |
| |
| function symbolIteratorWithKey() { |
| key = completed; |
| item = iter.next(); |
| value = item.value; |
| item.done ? callback(null, result) : iterator(value, key, done); |
| } |
| |
| function objectIterator() { |
| key = keys[completed]; |
| value = collection[key]; |
| iterator(value, done); |
| } |
| |
| function objectIteratorWithKey() { |
| key = keys[completed]; |
| value = collection[key]; |
| iterator(value, key, done); |
| } |
| |
| function done(err, res) { |
| if (err) { |
| callback(err, result); |
| return; |
| } |
| if (!!res === bool) { |
| result[key] = value; |
| } |
| if (++completed === size) { |
| iterate = throwError; |
| callback(null, result); |
| } else if (sync) { |
| nextTick(iterate); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| } |
| }; |
| } |
| |
| /** |
| * @private |
| * @param {boolean} bool |
| */ |
| function createPickLimit(bool) { |
| return function(collection, limit, iterator, callback) { |
| callback = callback || noop; |
| var size, index, key, value, keys, iter, item, iterate; |
| var sync = false; |
| var result = {}; |
| var started = 0; |
| var completed = 0; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator; |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| size = Infinity; |
| iter = collection[iteratorSymbol](); |
| iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator; |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| size = keys.length; |
| iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator; |
| } |
| if (!size || isNaN(limit) || limit < 1) { |
| return callback(null, {}); |
| } |
| timesSync(limit > size ? size : limit, iterate); |
| |
| function arrayIterator() { |
| index = started++; |
| if (index < size) { |
| value = collection[index]; |
| iterator(value, createCallback(value, index)); |
| } |
| } |
| |
| function arrayIteratorWithIndex() { |
| index = started++; |
| if (index < size) { |
| value = collection[index]; |
| iterator(value, index, createCallback(value, index)); |
| } |
| } |
| |
| function symbolIterator() { |
| item = iter.next(); |
| if (item.done === false) { |
| value = item.value; |
| iterator(value, createCallback(value, started++)); |
| } else if (completed === started && iterator !== noop) { |
| iterator = noop; |
| callback(null, result); |
| } |
| } |
| |
| function symbolIteratorWithKey() { |
| item = iter.next(); |
| if (item.done === false) { |
| value = item.value; |
| iterator(value, started, createCallback(value, started++)); |
| } else if (completed === started && iterator !== noop) { |
| iterator = noop; |
| callback(null, result); |
| } |
| } |
| |
| function objectIterator() { |
| if (started < size) { |
| key = keys[started++]; |
| value = collection[key]; |
| iterator(value, createCallback(value, key)); |
| } |
| } |
| |
| function objectIteratorWithKey() { |
| if (started < size) { |
| key = keys[started++]; |
| value = collection[key]; |
| iterator(value, key, createCallback(value, key)); |
| } |
| } |
| |
| function createCallback(value, key) { |
| return function(err, res) { |
| if (key === null) { |
| throwError(); |
| } |
| if (err) { |
| key = null; |
| iterate = noop; |
| callback = once(callback); |
| callback(err, objectClone(result)); |
| return; |
| } |
| if (!!res === bool) { |
| result[key] = value; |
| } |
| key = null; |
| if (++completed === size) { |
| iterate = throwError; |
| callback = onlyOnce(callback); |
| callback(null, result); |
| } else if (sync) { |
| nextTick(iterate); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| }; |
| } |
| }; |
| } |
| |
| /** |
| * @memberof async |
| * @namespace reduce |
| * @param {Array|Object} collection |
| * @param {*} result |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var collection = [1, 3, 2, 4]; |
| * var iterator = function(result, num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, result + num); |
| * }, num * 10); |
| * }; |
| * async.reduce(collection, 0, iterator, function(err, res) { |
| * console.log(res); // 10 |
| * console.log(order); // [1, 3, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var collection = [1, 3, 2, 4]; |
| * var iterator = function(result, num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, result + num); |
| * }, num * 10); |
| * }; |
| * async.reduce(collection, '', iterator, function(err, res) { |
| * console.log(res); // '1324' |
| * console.log(order); // [[1, 0], [3, 1], [2, 2], [4, 3]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2, d: 4 }; |
| * var iterator = function(result, num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, result + num); |
| * }, num * 10); |
| * }; |
| * async.reduce(collection, '', iterator, function(err, res) { |
| * console.log(res); // '1324' |
| * console.log(order); // [1, 3, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2, d: 4 }; |
| * var iterator = function(result, num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, result + num); |
| * }, num * 10); |
| * }; |
| * async.reduce(collection, 0, iterator, function(err, res) { |
| * console.log(res); // 10 |
| * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'b'], [4, 'd']] |
| * }); |
| * |
| */ |
| function reduce(collection, result, iterator, callback) { |
| callback = onlyOnce(callback || noop); |
| var size, key, keys, iter, item, iterate; |
| var sync = false; |
| var completed = 0; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator; |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| size = Infinity; |
| iter = collection[iteratorSymbol](); |
| iterate = iterator.length === 4 ? symbolIteratorWithKey : symbolIterator; |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| size = keys.length; |
| iterate = iterator.length === 4 ? objectIteratorWithKey : objectIterator; |
| } |
| if (!size) { |
| return callback(null, result); |
| } |
| iterate(result); |
| |
| function arrayIterator(result) { |
| iterator(result, collection[completed], done); |
| } |
| |
| function arrayIteratorWithIndex(result) { |
| iterator(result, collection[completed], completed, done); |
| } |
| |
| function symbolIterator(result) { |
| item = iter.next(); |
| item.done ? callback(null, result) : iterator(result, item.value, done); |
| } |
| |
| function symbolIteratorWithKey(result) { |
| item = iter.next(); |
| item.done ? callback(null, result) : iterator(result, item.value, completed, done); |
| } |
| |
| function objectIterator(result) { |
| iterator(result, collection[keys[completed]], done); |
| } |
| |
| function objectIteratorWithKey(result) { |
| key = keys[completed]; |
| iterator(result, collection[key], key, done); |
| } |
| |
| function done(err, result) { |
| if (err) { |
| callback(err, result); |
| } else if (++completed === size) { |
| iterator = throwError; |
| callback(null, result); |
| } else if (sync) { |
| nextTick(function() { |
| iterate(result); |
| }); |
| } else { |
| sync = true; |
| iterate(result); |
| } |
| sync = false; |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace reduceRight |
| * @param {Array|Object} collection |
| * @param {*} result |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var collection = [1, 3, 2, 4]; |
| * var iterator = function(result, num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, result + num); |
| * }, num * 10); |
| * }; |
| * async.reduceRight(collection, 0, iterator, function(err, res) { |
| * console.log(res); // 10 |
| * console.log(order); // [4, 2, 3, 1] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var collection = [1, 3, 2, 4]; |
| * var iterator = function(result, num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, result + num); |
| * }, num * 10); |
| * }; |
| * async.reduceRight(collection, '', iterator, function(err, res) { |
| * console.log(res); // '4231' |
| * console.log(order); // [[4, 3], [2, 2], [3, 1], [1, 0]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2, d: 4 }; |
| * var iterator = function(result, num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, result + num); |
| * }, num * 10); |
| * }; |
| * async.reduceRight(collection, '', iterator, function(err, res) { |
| * console.log(res); // '4231' |
| * console.log(order); // [4, 2, 3, 1] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2, d: 4 }; |
| * var iterator = function(result, num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, result + num); |
| * }, num * 10); |
| * }; |
| * async.reduceRight(collection, 0, iterator, function(err, res) { |
| * console.log(res); // 10 |
| * console.log(order); // [[4, 3], [2, 2], [3, 1], [1, 0]] |
| * }); |
| * |
| */ |
| function reduceRight(collection, result, iterator, callback) { |
| callback = onlyOnce(callback || noop); |
| var resIndex, index, key, keys, iter, item, col, iterate; |
| var sync = false; |
| |
| if (isArray(collection)) { |
| resIndex = collection.length; |
| iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator; |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| col = []; |
| iter = collection[iteratorSymbol](); |
| index = -1; |
| while ((item = iter.next()).done === false) { |
| col[++index] = item.value; |
| } |
| collection = col; |
| resIndex = col.length; |
| iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator; |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| resIndex = keys.length; |
| iterate = iterator.length === 4 ? objectIteratorWithKey : objectIterator; |
| } |
| if (!resIndex) { |
| return callback(null, result); |
| } |
| iterate(result); |
| |
| function arrayIterator(result) { |
| iterator(result, collection[--resIndex], done); |
| } |
| |
| function arrayIteratorWithIndex(result) { |
| iterator(result, collection[--resIndex], resIndex, done); |
| } |
| |
| function objectIterator(result) { |
| iterator(result, collection[keys[--resIndex]], done); |
| } |
| |
| function objectIteratorWithKey(result) { |
| key = keys[--resIndex]; |
| iterator(result, collection[key], key, done); |
| } |
| |
| function done(err, result) { |
| if (err) { |
| callback(err, result); |
| } else if (resIndex === 0) { |
| iterate = throwError; |
| callback(null, result); |
| } else if (sync) { |
| nextTick(function() { |
| iterate(result); |
| }); |
| } else { |
| sync = true; |
| iterate(result); |
| } |
| sync = false; |
| } |
| } |
| |
| /** |
| * @private |
| * @param {Function} arrayEach |
| * @param {Function} baseEach |
| * @param {Function} symbolEach |
| */ |
| function createTransform(arrayEach, baseEach, symbolEach) { |
| return function transform(collection, accumulator, iterator, callback) { |
| if (arguments.length === 3) { |
| callback = iterator; |
| iterator = accumulator; |
| accumulator = undefined; |
| } |
| callback = callback || noop; |
| var size, keys, result; |
| var completed = 0; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| result = accumulator !== undefined ? accumulator : []; |
| arrayEach(collection, result, iterator, done); |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| result = accumulator !== undefined ? accumulator : {}; |
| size = symbolEach(collection, result, iterator, done); |
| size && size === completed && callback(null, result); |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| size = keys.length; |
| result = accumulator !== undefined ? accumulator : {}; |
| baseEach(collection, result, iterator, done, keys); |
| } |
| if (!size) { |
| callback(null, accumulator !== undefined ? accumulator : result || {}); |
| } |
| |
| function done(err, bool) { |
| if (err) { |
| callback = once(callback); |
| callback(err, isArray(result) ? createArray(result) : objectClone(result)); |
| } else if (++completed === size) { |
| callback(null, result); |
| } else if (bool === false) { |
| callback = once(callback); |
| callback(null, isArray(result) ? createArray(result) : objectClone(result)); |
| } |
| } |
| }; |
| } |
| |
| /** |
| * @memberof async |
| * @namespace transformSeries |
| * @param {Array|Object} collection |
| * @param {Array|Object|Function} [accumulator] |
| * @param {Function} [iterator] |
| * @param {Function} [callback] |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var collection = [1, 3, 2, 4]; |
| * var iterator = function(result, num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * result.push(num) |
| * done(); |
| * }, num * 10); |
| * }; |
| * async.transformSeries(collection, iterator, function(err, res) { |
| * console.log(res); // [1, 3, 2, 4] |
| * console.log(order); // [1, 3, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // array with index and accumulator |
| * var order = []; |
| * var collection = [1, 3, 2, 4]; |
| * var iterator = function(result, num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * result[index] = num; |
| * done(); |
| * }, num * 10); |
| * }; |
| * async.transformSeries(collection, {}, iterator, function(err, res) { |
| * console.log(res); // { '0': 1, '1': 3, '2': 2, '3': 4 } |
| * console.log(order); // [[1, 0], [3, 1], [2, 2], [4, 3]] |
| * }); |
| * |
| * @example |
| * |
| * // object with accumulator |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2, d: 4 }; |
| * var iterator = function(result, num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * result.push(num); |
| * done(); |
| * }, num * 10); |
| * }; |
| * async.transformSeries(collection, [], iterator, function(err, res) { |
| * console.log(res); // [1, 3, 2, 4] |
| * console.log(order); // [1, 3, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2, d: 4 }; |
| * var iterator = function(result, num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * result[key] = num; |
| * done(); |
| * }, num * 10); |
| * }; |
| * async.transformSeries(collection, iterator, function(err, res) { |
| * console.log(res); // { a: 1, b: 3, c: 2, d: 4 } |
| * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'b'], [4, 'd']] |
| * }); |
| * |
| */ |
| function transformSeries(collection, accumulator, iterator, callback) { |
| if (arguments.length === 3) { |
| callback = iterator; |
| iterator = accumulator; |
| accumulator = undefined; |
| } |
| callback = onlyOnce(callback || noop); |
| var size, key, keys, iter, item, iterate, result; |
| var sync = false; |
| var completed = 0; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| result = accumulator !== undefined ? accumulator : []; |
| iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator; |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| size = Infinity; |
| iter = collection[iteratorSymbol](); |
| result = accumulator !== undefined ? accumulator : {}; |
| iterate = iterator.length === 4 ? symbolIteratorWithKey : symbolIterator; |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| size = keys.length; |
| result = accumulator !== undefined ? accumulator : {}; |
| iterate = iterator.length === 4 ? objectIteratorWithKey : objectIterator; |
| } |
| if (!size) { |
| return callback(null, accumulator !== undefined ? accumulator : result || {}); |
| } |
| iterate(); |
| |
| function arrayIterator() { |
| iterator(result, collection[completed], done); |
| } |
| |
| function arrayIteratorWithIndex() { |
| iterator(result, collection[completed], completed, done); |
| } |
| |
| function symbolIterator() { |
| item = iter.next(); |
| item.done ? callback(null, result) : iterator(result, item.value, done); |
| } |
| |
| function symbolIteratorWithKey() { |
| item = iter.next(); |
| item.done ? callback(null, result) : iterator(result, item.value, completed, done); |
| } |
| |
| function objectIterator() { |
| iterator(result, collection[keys[completed]], done); |
| } |
| |
| function objectIteratorWithKey() { |
| key = keys[completed]; |
| iterator(result, collection[key], key, done); |
| } |
| |
| function done(err, bool) { |
| if (err) { |
| callback(err, result); |
| } else if (++completed === size || bool === false) { |
| iterate = throwError; |
| callback(null, result); |
| } else if (sync) { |
| nextTick(iterate); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace transformLimit |
| * @param {Array|Object} collection |
| * @param {number} limit - limit >= 1 |
| * @param {Array|Object|Function} [accumulator] |
| * @param {Function} [iterator] |
| * @param {Function} [callback] |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(result, num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * result.push(num); |
| * done(); |
| * }, num * 10); |
| * }; |
| * async.transformLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // [1, 3, 5, 2, 4] |
| * console.log(order); // [1, 3, 5, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // array with index and accumulator |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(result, num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * result[index] = key; |
| * done(); |
| * }, num * 10); |
| * }; |
| * async.transformLimit(array, 2, {}, iterator, function(err, res) { |
| * console.log(res); // { '0': 1, '1': 5, '2': 3, '3': 4, '4': 2 } |
| * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]] |
| * }); |
| * |
| * @example |
| * |
| * // object with accumulator |
| * var order = []; |
| * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * var iterator = function(result, num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * result.push(num); |
| * done(); |
| * }, num * 10); |
| * }; |
| * async.transformLimit(object, 2, [], iterator, function(err, res) { |
| * console.log(res); // [1, 3, 5, 2, 4] |
| * console.log(order); // [1, 3, 5, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * var iterator = function(result, num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * result[key] = num; |
| * done(); |
| * }, num * 10); |
| * }; |
| * async.transformLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']] |
| * }); |
| * |
| */ |
| function transformLimit(collection, limit, accumulator, iterator, callback) { |
| if (arguments.length === 4) { |
| callback = iterator; |
| iterator = accumulator; |
| accumulator = undefined; |
| } |
| callback = callback || noop; |
| var size, index, key, keys, iter, item, iterate, result; |
| var sync = false; |
| var started = 0; |
| var completed = 0; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| result = accumulator !== undefined ? accumulator : []; |
| iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator; |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| size = Infinity; |
| iter = collection[iteratorSymbol](); |
| result = accumulator !== undefined ? accumulator : {}; |
| iterate = iterator.length === 4 ? symbolIteratorWithKey : symbolIterator; |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| size = keys.length; |
| result = accumulator !== undefined ? accumulator : {}; |
| iterate = iterator.length === 4 ? objectIteratorWithKey : objectIterator; |
| } |
| if (!size || isNaN(limit) || limit < 1) { |
| return callback(null, accumulator !== undefined ? accumulator : result || {}); |
| } |
| timesSync(limit > size ? size : limit, iterate); |
| |
| function arrayIterator() { |
| index = started++; |
| if (index < size) { |
| iterator(result, collection[index], onlyOnce(done)); |
| } |
| } |
| |
| function arrayIteratorWithIndex() { |
| index = started++; |
| if (index < size) { |
| iterator(result, collection[index], index, onlyOnce(done)); |
| } |
| } |
| |
| function symbolIterator() { |
| item = iter.next(); |
| if (item.done === false) { |
| started++; |
| iterator(result, item.value, onlyOnce(done)); |
| } else if (completed === started && iterator !== noop) { |
| iterator = noop; |
| callback(null, result); |
| } |
| } |
| |
| function symbolIteratorWithKey() { |
| item = iter.next(); |
| if (item.done === false) { |
| iterator(result, item.value, started++, onlyOnce(done)); |
| } else if (completed === started && iterator !== noop) { |
| iterator = noop; |
| callback(null, result); |
| } |
| } |
| |
| function objectIterator() { |
| index = started++; |
| if (index < size) { |
| iterator(result, collection[keys[index]], onlyOnce(done)); |
| } |
| } |
| |
| function objectIteratorWithKey() { |
| index = started++; |
| if (index < size) { |
| key = keys[index]; |
| iterator(result, collection[key], key, onlyOnce(done)); |
| } |
| } |
| |
| function done(err, bool) { |
| if (err || bool === false) { |
| iterate = noop; |
| callback(err || null, isArray(result) ? createArray(result) : objectClone(result)); |
| callback = noop; |
| } else if (++completed === size) { |
| iterator = noop; |
| callback(null, result); |
| } else if (sync) { |
| nextTick(iterate); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| } |
| } |
| |
| /** |
| * @private |
| * @param {function} arrayEach |
| * @param {function} baseEach |
| * @param {function} symbolEach |
| */ |
| function createSortBy(arrayEach, baseEach, symbolEach) { |
| return function sortBy(collection, iterator, callback) { |
| callback = callback || noop; |
| var size, array, criteria; |
| var completed = 0; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| array = Array(size); |
| criteria = Array(size); |
| arrayEach(collection, iterator, createCallback); |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| array = []; |
| criteria = []; |
| size = symbolEach(collection, iterator, createCallback); |
| size && size === completed && callback(null, sortByCriteria(array, criteria)); |
| } else if (typeof collection === obj) { |
| var keys = nativeKeys(collection); |
| size = keys.length; |
| array = Array(size); |
| criteria = Array(size); |
| baseEach(collection, iterator, createCallback, keys); |
| } |
| if (!size) { |
| callback(null, []); |
| } |
| |
| function createCallback(index, value) { |
| var called = false; |
| array[index] = value; |
| return function done(err, criterion) { |
| if (called) { |
| throwError(); |
| } |
| called = true; |
| criteria[index] = criterion; |
| if (err) { |
| callback = once(callback); |
| callback(err); |
| } else if (++completed === size) { |
| callback(null, sortByCriteria(array, criteria)); |
| } |
| }; |
| } |
| }; |
| } |
| |
| /** |
| * @memberof async |
| * @namespace sortBySeries |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.sortBySeries(array, iterator, function(err, res) { |
| * console.log(res); // [1, 2, 3]; |
| * console.log(order); // [1, 3, 2] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.sortBySeries(array, iterator, function(err, res) { |
| * console.log(res); // [1, 2, 3] |
| * console.log(order); // [[1, 0], [3, 1], [2, 2]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.sortBySeries(object, iterator, function(err, res) { |
| * console.log(res); // [1, 2, 3] |
| * console.log(order); // [1, 3, 2] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.sortBySeries(object, iterator, function(err, res) { |
| * console.log(res); // [1, 2, 3] |
| * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']] |
| * }); |
| * |
| */ |
| function sortBySeries(collection, iterator, callback) { |
| callback = onlyOnce(callback || noop); |
| var size, key, value, keys, iter, item, array, criteria, iterate; |
| var sync = false; |
| var completed = 0; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| array = collection; |
| criteria = Array(size); |
| iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator; |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| size = Infinity; |
| array = []; |
| criteria = []; |
| iter = collection[iteratorSymbol](); |
| iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator; |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| size = keys.length; |
| array = Array(size); |
| criteria = Array(size); |
| iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator; |
| } |
| if (!size) { |
| return callback(null, []); |
| } |
| iterate(); |
| |
| function arrayIterator() { |
| value = collection[completed]; |
| iterator(value, done); |
| } |
| |
| function arrayIteratorWithIndex() { |
| value = collection[completed]; |
| iterator(value, completed, done); |
| } |
| |
| function symbolIterator() { |
| item = iter.next(); |
| if (item.done) { |
| return callback(null, sortByCriteria(array, criteria)); |
| } |
| value = item.value; |
| array[completed] = value; |
| iterator(value, done); |
| } |
| |
| function symbolIteratorWithKey() { |
| item = iter.next(); |
| if (item.done) { |
| return callback(null, sortByCriteria(array, criteria)); |
| } |
| value = item.value; |
| array[completed] = value; |
| iterator(value, completed, done); |
| } |
| |
| function objectIterator() { |
| value = collection[keys[completed]]; |
| array[completed] = value; |
| iterator(value, done); |
| } |
| |
| function objectIteratorWithKey() { |
| key = keys[completed]; |
| value = collection[key]; |
| array[completed] = value; |
| iterator(value, key, done); |
| } |
| |
| function done(err, criterion) { |
| criteria[completed] = criterion; |
| if (err) { |
| callback(err); |
| } else if (++completed === size) { |
| iterate = throwError; |
| callback(null, sortByCriteria(array, criteria)); |
| } else if (sync) { |
| nextTick(iterate); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace sortByLimit |
| * @param {Array|Object} collection |
| * @param {number} limit - limit >= 1 |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.sortByLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // [1, 2, 3, 4, 5] |
| * console.log(order); // [1, 3, 5, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.sortByLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // [1, 2, 3, 4, 5] |
| * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.sortByLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // [1, 2, 3, 4, 5] |
| * console.log(order); // [1, 3, 5, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.sortByLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // [1, 2, 3, 4, 5] |
| * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']] |
| * }); |
| * |
| */ |
| function sortByLimit(collection, limit, iterator, callback) { |
| callback = callback || noop; |
| var size, index, key, value, array, keys, iter, item, criteria, iterate; |
| var sync = false; |
| var started = 0; |
| var completed = 0; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| array = collection; |
| iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator; |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| size = Infinity; |
| iter = collection[iteratorSymbol](); |
| array = []; |
| criteria = []; |
| iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator; |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| size = keys.length; |
| array = Array(size); |
| iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator; |
| } |
| if (!size || isNaN(limit) || limit < 1) { |
| return callback(null, []); |
| } |
| criteria = criteria || Array(size); |
| timesSync(limit > size ? size : limit, iterate); |
| |
| function arrayIterator() { |
| if (started < size) { |
| value = collection[started]; |
| iterator(value, createCallback(value, started++)); |
| } |
| } |
| |
| function arrayIteratorWithIndex() { |
| index = started++; |
| if (index < size) { |
| value = collection[index]; |
| iterator(value, index, createCallback(value, index)); |
| } |
| } |
| |
| function symbolIterator() { |
| item = iter.next(); |
| if (item.done === false) { |
| value = item.value; |
| array[started] = value; |
| iterator(value, createCallback(value, started++)); |
| } else if (completed === started && iterator !== noop) { |
| iterator = noop; |
| callback(null, sortByCriteria(array, criteria)); |
| } |
| } |
| |
| function symbolIteratorWithKey() { |
| item = iter.next(); |
| if (item.done === false) { |
| value = item.value; |
| array[started] = value; |
| iterator(value, started, createCallback(value, started++)); |
| } else if (completed === started && iterator !== noop) { |
| iterator = noop; |
| callback(null, sortByCriteria(array, criteria)); |
| } |
| } |
| |
| function objectIterator() { |
| if (started < size) { |
| value = collection[keys[started]]; |
| array[started] = value; |
| iterator(value, createCallback(value, started++)); |
| } |
| } |
| |
| function objectIteratorWithKey() { |
| if (started < size) { |
| key = keys[started]; |
| value = collection[key]; |
| array[started] = value; |
| iterator(value, key, createCallback(value, started++)); |
| } |
| } |
| |
| function createCallback(value, index) { |
| var called = false; |
| return function(err, criterion) { |
| if (called) { |
| throwError(); |
| } |
| called = true; |
| criteria[index] = criterion; |
| if (err) { |
| iterate = noop; |
| callback(err); |
| callback = noop; |
| } else if (++completed === size) { |
| callback(null, sortByCriteria(array, criteria)); |
| } else if (sync) { |
| nextTick(iterate); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| }; |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace some |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.some(array, iterator, function(err, res) { |
| * console.log(res); // true |
| * console.log(order); // [1] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.some(array, iterator, function(err, res) { |
| * console.log(res); // true |
| * console.log(order); // [[1, 0]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.some(object, iterator, function(err, res) { |
| * console.log(res); // true |
| * console.log(order); // [1] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.some(object, iterator, function(err, res) { |
| * console.log(res); // true |
| * console.log(order); // [[1, 'a']] |
| * }); |
| * |
| */ |
| function some(collection, iterator, callback) { |
| callback = callback || noop; |
| detect(collection, iterator, done); |
| |
| function done(err, res) { |
| if (err) { |
| return callback(err); |
| } |
| callback(null, !!res); |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace someSeries |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.someSeries(array, iterator, function(err, res) { |
| * console.log(res); // true |
| * console.log(order); // [1] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.someSeries(array, iterator, function(err, res) { |
| * console.log(res); // true |
| * console.log(order); // [[1, 0]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.someSeries(object, iterator, function(err, res) { |
| * console.log(res); // true |
| * console.log(order); // [1] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.someSeries(object, iterator, function(err, res) { |
| * console.log(res); // true |
| * console.log(order); // [[1, 'a']] |
| * }); |
| * |
| */ |
| function someSeries(collection, iterator, callback) { |
| callback = callback || noop; |
| detectSeries(collection, iterator, done); |
| |
| function done(err, res) { |
| if (err) { |
| return callback(err); |
| } |
| callback(null, !!res); |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace someLimit |
| * @param {Array|Object} collection |
| * @param {number} limit - limit >= 1 |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.someLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // true |
| * console.log(order); // [1] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.someLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // true |
| * console.log(order); // [[1, 0]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.someLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // true |
| * console.log(order); // [1] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num % 2); |
| * }, num * 10); |
| * }; |
| * async.someLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // true |
| * console.log(order); // [[1, 'a']] |
| * }); |
| * |
| */ |
| function someLimit(collection, limit, iterator, callback) { |
| callback = callback || noop; |
| detectLimit(collection, limit, iterator, done); |
| |
| function done(err, res) { |
| if (err) { |
| return callback(err); |
| } |
| callback(null, !!res); |
| } |
| } |
| |
| /** |
| * @private |
| * @param {Function} arrayEach |
| * @param {Function} baseEach |
| * @param {Function} symbolEach |
| */ |
| function createEvery(arrayEach, baseEach, symbolEach) { |
| var deny = createDetect(arrayEach, baseEach, symbolEach, false); |
| |
| return function every(collection, iterator, callback) { |
| callback = callback || noop; |
| deny(collection, iterator, done); |
| |
| function done(err, res) { |
| if (err) { |
| return callback(err); |
| } |
| callback(null, !res); |
| } |
| }; |
| } |
| |
| /** |
| * @private |
| */ |
| function createEverySeries() { |
| var denySeries = createDetectSeries(false); |
| |
| return function everySeries(collection, iterator, callback) { |
| callback = callback || noop; |
| denySeries(collection, iterator, done); |
| |
| function done(err, res) { |
| if (err) { |
| return callback(err); |
| } |
| callback(null, !res); |
| } |
| }; |
| } |
| |
| /** |
| * @private |
| */ |
| function createEveryLimit() { |
| var denyLimit = createDetectLimit(false); |
| |
| return function everyLimit(collection, limit, iterator, callback) { |
| callback = callback || noop; |
| denyLimit(collection, limit, iterator, done); |
| |
| function done(err, res) { |
| if (err) { |
| return callback(err); |
| } |
| callback(null, !res); |
| } |
| }; |
| } |
| |
| /** |
| * @private |
| * @param {Function} arrayEach |
| * @param {Function} baseEach |
| * @param {Function} symbolEach |
| */ |
| function createConcat(arrayEach, baseEach, symbolEach) { |
| return function concat(collection, iterator, callback) { |
| callback = callback || noop; |
| var size, result; |
| var completed = 0; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| result = Array(size); |
| arrayEach(collection, iterator, createCallback); |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| result = []; |
| size = symbolEach(collection, iterator, createCallback); |
| size && size === completed && callback(null, result); |
| } else if (typeof collection === obj) { |
| var keys = nativeKeys(collection); |
| size = keys.length; |
| result = Array(size); |
| baseEach(collection, iterator, createCallback, keys); |
| } |
| if (!size) { |
| callback(null, []); |
| } |
| |
| function createCallback(index) { |
| return function done(err, res) { |
| if (index === null) { |
| throwError(); |
| } |
| if (err) { |
| index = null; |
| callback = once(callback); |
| arrayEachSync(result, function(array, index) { |
| if (array === undefined) { |
| result[index] = noop; |
| } |
| }); |
| callback(err, makeConcatResult(result)); |
| return; |
| } |
| switch (arguments.length) { |
| case 0: |
| case 1: |
| result[index] = noop; |
| break; |
| case 2: |
| result[index] = res; |
| break; |
| default: |
| result[index] = slice(arguments, 1); |
| break; |
| } |
| index = null; |
| if (++completed === size) { |
| callback(null, makeConcatResult(result)); |
| } |
| }; |
| } |
| }; |
| } |
| |
| /** |
| * @memberof async |
| * @namespace concatSeries |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, [num]); |
| * }, num * 10); |
| * }; |
| * async.concatSeries(array, iterator, function(err, res) { |
| * console.log(res); // [1, 3, 2]; |
| * console.log(order); // [1, 3, 2] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 3, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, [num]); |
| * }, num * 10); |
| * }; |
| * async.concatSeries(array, iterator, function(err, res) { |
| * console.log(res); // [1, 3, 2] |
| * console.log(order); // [[1, 0], [3, 1], [2, 2]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, [num]); |
| * }, num * 10); |
| * }; |
| * async.concatSeries(object, iterator, function(err, res) { |
| * console.log(res); // [1, 3, 2] |
| * console.log(order); // [1, 3, 2] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 3, c: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, [num]); |
| * }, num * 10); |
| * }; |
| * async.concatSeries(object, iterator, function(err, res) { |
| * console.log(res); // [1, 3, 2] |
| * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']] |
| * }); |
| * |
| */ |
| function concatSeries(collection, iterator, callback) { |
| callback = onlyOnce(callback || noop); |
| var size, key, keys, iter, item, iterate; |
| var sync = false; |
| var result = []; |
| var completed = 0; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator; |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| size = Infinity; |
| iter = collection[iteratorSymbol](); |
| iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator; |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| size = keys.length; |
| iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator; |
| } |
| if (!size) { |
| return callback(null, result); |
| } |
| iterate(); |
| |
| function arrayIterator() { |
| iterator(collection[completed], done); |
| } |
| |
| function arrayIteratorWithIndex() { |
| iterator(collection[completed], completed, done); |
| } |
| |
| function symbolIterator() { |
| item = iter.next(); |
| item.done ? callback(null, result) : iterator(item.value, done); |
| } |
| |
| function symbolIteratorWithKey() { |
| item = iter.next(); |
| item.done ? callback(null, result) : iterator(item.value, completed, done); |
| } |
| |
| function objectIterator() { |
| iterator(collection[keys[completed]], done); |
| } |
| |
| function objectIteratorWithKey() { |
| key = keys[completed]; |
| iterator(collection[key], key, done); |
| } |
| |
| function done(err, array) { |
| if (isArray(array)) { |
| nativePush.apply(result, array); |
| } else if (arguments.length >= 2) { |
| nativePush.apply(result, slice(arguments, 1)); |
| } |
| if (err) { |
| callback(err, result); |
| } else if (++completed === size) { |
| iterate = throwError; |
| callback(null, result); |
| } else if (sync) { |
| nextTick(iterate); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace concatLimit |
| * @param {Array|Object} collection |
| * @param {number} limit - limit >= 1 |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, [num]); |
| * }, num * 10); |
| * }; |
| * async.concatLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // [1, 3, 5, 2, 4] |
| * console.log(order); // [1, 3, 5, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1, 5, 3, 4, 2]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, [num]); |
| * }, num * 10); |
| * }; |
| * async.cocnatLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // [1, 3, 5, 2, 4] |
| * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, [num]); |
| * }, num * 10); |
| * }; |
| * async.concatLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // [1, 3, 5, 2, 4] |
| * console.log(order); // [1, 3, 5, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, num); |
| * }, num * 10); |
| * }; |
| * async.cocnatLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // [1, 3, 5, 2, 4] |
| * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']] |
| * }); |
| * |
| */ |
| function concatLimit(collection, limit, iterator, callback) { |
| callback = callback || noop; |
| var size, key, iter, item, iterate, result; |
| var sync = false; |
| var started = 0; |
| var completed = 0; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator; |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| size = Infinity; |
| result = []; |
| iter = collection[iteratorSymbol](); |
| iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator; |
| } else if (typeof collection === obj) { |
| var keys = nativeKeys(collection); |
| size = keys.length; |
| iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator; |
| } |
| if (!size || isNaN(limit) || limit < 1) { |
| return callback(null, []); |
| } |
| result = result || Array(size); |
| timesSync(limit > size ? size : limit, iterate); |
| |
| function arrayIterator() { |
| if (started < size) { |
| iterator(collection[started], createCallback(started++)); |
| } |
| } |
| |
| function arrayIteratorWithIndex() { |
| if (started < size) { |
| iterator(collection[started], started, createCallback(started++)); |
| } |
| } |
| |
| function symbolIterator() { |
| item = iter.next(); |
| if (item.done === false) { |
| iterator(item.value, createCallback(started++)); |
| } else if (completed === started && iterator !== noop) { |
| iterator = noop; |
| callback(null, makeConcatResult(result)); |
| } |
| } |
| |
| function symbolIteratorWithKey() { |
| item = iter.next(); |
| if (item.done === false) { |
| iterator(item.value, started, createCallback(started++)); |
| } else if (completed === started && iterator !== noop) { |
| iterator = noop; |
| callback(null, makeConcatResult(result)); |
| } |
| } |
| |
| function objectIterator() { |
| if (started < size) { |
| iterator(collection[keys[started]], createCallback(started++)); |
| } |
| } |
| |
| function objectIteratorWithKey() { |
| if (started < size) { |
| key = keys[started]; |
| iterator(collection[key], key, createCallback(started++)); |
| } |
| } |
| |
| function createCallback(index) { |
| return function(err, res) { |
| if (index === null) { |
| throwError(); |
| } |
| if (err) { |
| index = null; |
| iterate = noop; |
| callback = once(callback); |
| arrayEachSync(result, function(array, index) { |
| if (array === undefined) { |
| result[index] = noop; |
| } |
| }); |
| callback(err, makeConcatResult(result)); |
| return; |
| } |
| switch (arguments.length) { |
| case 0: |
| case 1: |
| result[index] = noop; |
| break; |
| case 2: |
| result[index] = res; |
| break; |
| default: |
| result[index] = slice(arguments, 1); |
| break; |
| } |
| index = null; |
| if (++completed === size) { |
| iterate = throwError; |
| callback(null, makeConcatResult(result)); |
| callback = throwError; |
| } else if (sync) { |
| nextTick(iterate); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| }; |
| } |
| } |
| |
| /** |
| * @private |
| * @param {Function} arrayEach |
| * @param {Function} baseEach |
| * @param {Function} symbolEach |
| */ |
| function createGroupBy(arrayEach, baseEach, symbolEach) { |
| return function groupBy(collection, iterator, callback) { |
| callback = callback || noop; |
| var size; |
| var completed = 0; |
| var result = {}; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| arrayEach(collection, iterator, createCallback); |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| size = symbolEach(collection, iterator, createCallback); |
| size && size === completed && callback(null, result); |
| } else if (typeof collection === obj) { |
| var keys = nativeKeys(collection); |
| size = keys.length; |
| baseEach(collection, iterator, createCallback, keys); |
| } |
| if (!size) { |
| callback(null, {}); |
| } |
| |
| function createCallback(value) { |
| var called = false; |
| return function done(err, key) { |
| if (called) { |
| throwError(); |
| } |
| called = true; |
| if (err) { |
| callback = once(callback); |
| callback(err, objectClone(result)); |
| return; |
| } |
| var array = result[key]; |
| if (!array) { |
| result[key] = [value]; |
| } else { |
| array.push(value); |
| } |
| if (++completed === size) { |
| callback(null, result); |
| } |
| }; |
| } |
| }; |
| } |
| |
| /** |
| * @memberof async |
| * @namespace groupBySeries |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [4.2, 6.4, 6.1]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, Math.floor(num)); |
| * }, num * 10); |
| * }; |
| * async.groupBySeries(array, iterator, function(err, res) { |
| * console.log(res); // { '4': [4.2], '6': [6.4, 6.1] } |
| * console.log(order); // [4.2, 6.4, 6.1] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [4.2, 6.4, 6.1]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, Math.floor(num)); |
| * }, num * 10); |
| * }; |
| * async.groupBySeries(array, iterator, function(err, res) { |
| * console.log(res); // { '4': [4.2], '6': [6.4, 6.1] } |
| * console.log(order); // [[4.2, 0], [6.4, 1], [6.1, 2]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 4.2, b: 6.4, c: 6.1 }; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, Math.floor(num)); |
| * }, num * 10); |
| * }; |
| * async.groupBySeries(object, iterator, function(err, res) { |
| * console.log(res); // { '4': [4.2], '6': [6.4, 6.1] } |
| * console.log(order); // [4.2, 6.4, 6.1] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 4.2, b: 6.4, c: 6.1 }; |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, Math.floor(num)); |
| * }, num * 10); |
| * }; |
| * async.groupBySeries(object, iterator, function(err, res) { |
| * console.log(res); // { '4': [4.2], '6': [6.4, 6.1] } |
| * console.log(order); // [[4.2, 'a'], [6.4, 'b'], [6.1, 'c']] |
| * }); |
| * |
| */ |
| function groupBySeries(collection, iterator, callback) { |
| callback = onlyOnce(callback || noop); |
| var size, key, value, keys, iter, item, iterate; |
| var sync = false; |
| var completed = 0; |
| var result = {}; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator; |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| size = Infinity; |
| iter = collection[iteratorSymbol](); |
| iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator; |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| size = keys.length; |
| iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator; |
| } |
| if (!size) { |
| return callback(null, result); |
| } |
| iterate(); |
| |
| function arrayIterator() { |
| value = collection[completed]; |
| iterator(value, done); |
| } |
| |
| function arrayIteratorWithIndex() { |
| value = collection[completed]; |
| iterator(value, completed, done); |
| } |
| |
| function symbolIterator() { |
| item = iter.next(); |
| value = item.value; |
| item.done ? callback(null, result) : iterator(value, done); |
| } |
| |
| function symbolIteratorWithKey() { |
| item = iter.next(); |
| value = item.value; |
| item.done ? callback(null, result) : iterator(value, completed, done); |
| } |
| |
| function objectIterator() { |
| value = collection[keys[completed]]; |
| iterator(value, done); |
| } |
| |
| function objectIteratorWithKey() { |
| key = keys[completed]; |
| value = collection[key]; |
| iterator(value, key, done); |
| } |
| |
| function done(err, key) { |
| if (err) { |
| iterate = throwError; |
| callback = onlyOnce(callback); |
| callback(err, objectClone(result)); |
| return; |
| } |
| var array = result[key]; |
| if (!array) { |
| result[key] = [value]; |
| } else { |
| array.push(value); |
| } |
| if (++completed === size) { |
| iterate = throwError; |
| callback(null, result); |
| } else if (sync) { |
| nextTick(iterate); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace groupByLimit |
| * @param {Array|Object} collection |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var order = []; |
| * var array = [1.1, 5.9, 3.2, 3.9, 2.1]; |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, Math.floor(num)); |
| * }, num * 10); |
| * }; |
| * async.groupByLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // { '1': [1.1], '3': [3.2, 3.9], '5': [5.9], '2': [2.1] } |
| * console.log(order); // [1.1, 3.2, 5.9, 2.1, 3.9] |
| * }); |
| * |
| * @example |
| * |
| * // array with index |
| * var order = []; |
| * var array = [1.1, 5.9, 3.2, 3.9, 2.1]; |
| * var iterator = function(num, index, done) { |
| * setTimeout(function() { |
| * order.push([num, index]); |
| * done(null, Math.floor(num)); |
| * }, num * 10); |
| * }; |
| * async.groupByLimit(array, 2, iterator, function(err, res) { |
| * console.log(res); // { '1': [1.1], '3': [3.2, 3.9], '5': [5.9], '2': [2.1] } |
| * console.log(order); // [[1.1, 0], [3.2, 2], [5.9, 1], [2.1, 4], [3.9, 3]] |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var order = []; |
| * var object = { a: 1.1, b: 5.9, c: 3.2, d: 3.9, e: 2.1 } |
| * var iterator = function(num, done) { |
| * setTimeout(function() { |
| * order.push(num); |
| * done(null, Math.floor(num)); |
| * }, num * 10); |
| * }; |
| * async.groupByLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // { '1': [1.1], '3': [3.2, 3.9], '5': [5.9], '2': [2.1] } |
| * console.log(order); // [1.1, 3.2, 5.9, 2.1, 3.9] |
| * }); |
| * |
| * @example |
| * |
| * // object with key |
| * var order = []; |
| * var object = { a: 1.1, b: 5.9, c: 3.2, d: 3.9, e: 2.1 } |
| * var iterator = function(num, key, done) { |
| * setTimeout(function() { |
| * order.push([num, key]); |
| * done(null, Math.floor(num)); |
| * }, num * 10); |
| * }; |
| * async.groupByLimit(object, 2, iterator, function(err, res) { |
| * console.log(res); // { '1': [1.1], '3': [3.2, 3.9], '5': [5.9], '2': [2.1] } |
| * console.log(order); // [[1.1, 'a'], [3.2, 'c'], [5.9, 'b'], [2.1, 'e'], [3.9, 'd']] |
| * }); |
| * |
| */ |
| function groupByLimit(collection, limit, iterator, callback) { |
| callback = callback || noop; |
| var size, index, key, value, keys, iter, item, iterate; |
| var sync = false; |
| var started = 0; |
| var completed = 0; |
| var result = {}; |
| |
| if (isArray(collection)) { |
| size = collection.length; |
| iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator; |
| } else if (!collection) { |
| } else if (iteratorSymbol && collection[iteratorSymbol]) { |
| size = Infinity; |
| iter = collection[iteratorSymbol](); |
| iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator; |
| } else if (typeof collection === obj) { |
| keys = nativeKeys(collection); |
| size = keys.length; |
| iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator; |
| } |
| if (!size || isNaN(limit) || limit < 1) { |
| return callback(null, result); |
| } |
| timesSync(limit > size ? size : limit, iterate); |
| |
| function arrayIterator() { |
| if (started < size) { |
| value = collection[started++]; |
| iterator(value, createCallback(value)); |
| } |
| } |
| |
| function arrayIteratorWithIndex() { |
| index = started++; |
| if (index < size) { |
| value = collection[index]; |
| iterator(value, index, createCallback(value)); |
| } |
| } |
| |
| function symbolIterator() { |
| item = iter.next(); |
| if (item.done === false) { |
| started++; |
| value = item.value; |
| iterator(value, createCallback(value)); |
| } else if (completed === started && iterator !== noop) { |
| iterator = noop; |
| callback(null, result); |
| } |
| } |
| |
| function symbolIteratorWithKey() { |
| item = iter.next(); |
| if (item.done === false) { |
| value = item.value; |
| iterator(value, started++, createCallback(value)); |
| } else if (completed === started && iterator !== noop) { |
| iterator = noop; |
| callback(null, result); |
| } |
| } |
| |
| function objectIterator() { |
| if (started < size) { |
| value = collection[keys[started++]]; |
| iterator(value, createCallback(value)); |
| } |
| } |
| |
| function objectIteratorWithKey() { |
| if (started < size) { |
| key = keys[started++]; |
| value = collection[key]; |
| iterator(value, key, createCallback(value)); |
| } |
| } |
| |
| function createCallback(value) { |
| var called = false; |
| return function(err, key) { |
| if (called) { |
| throwError(); |
| } |
| called = true; |
| if (err) { |
| iterate = noop; |
| callback = once(callback); |
| callback(err, objectClone(result)); |
| return; |
| } |
| var array = result[key]; |
| if (!array) { |
| result[key] = [value]; |
| } else { |
| array.push(value); |
| } |
| if (++completed === size) { |
| callback(null, result); |
| } else if (sync) { |
| nextTick(iterate); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| }; |
| } |
| } |
| |
| /** |
| * @private |
| * @param {Function} arrayEach |
| * @param {Function} baseEach |
| */ |
| function createParallel(arrayEach, baseEach) { |
| return function parallel(tasks, callback) { |
| callback = callback || noop; |
| var size, keys, result; |
| var completed = 0; |
| |
| if (isArray(tasks)) { |
| size = tasks.length; |
| result = Array(size); |
| arrayEach(tasks, createCallback); |
| } else if (tasks && typeof tasks === obj) { |
| keys = nativeKeys(tasks); |
| size = keys.length; |
| result = {}; |
| baseEach(tasks, createCallback, keys); |
| } |
| if (!size) { |
| callback(null, result); |
| } |
| |
| function createCallback(key) { |
| return function(err, res) { |
| if (key === null) { |
| throwError(); |
| } |
| if (err) { |
| key = null; |
| callback = once(callback); |
| callback(err, result); |
| return; |
| } |
| result[key] = arguments.length <= 2 ? res : slice(arguments, 1); |
| key = null; |
| if (++completed === size) { |
| callback(null, result); |
| } |
| }; |
| } |
| }; |
| } |
| |
| /** |
| * @memberof async |
| * @namespace series |
| * @param {Array|Object} tasks - functions |
| * @param {Function} callback |
| * @example |
| * |
| * var order = []; |
| * var tasks = [ |
| * function(done) { |
| * setTimeout(function() { |
| * order.push(1); |
| * done(null, 1); |
| * }, 10); |
| * }, |
| * function(done) { |
| * setTimeout(function() { |
| * order.push(2); |
| * done(null, 2); |
| * }, 30); |
| * }, |
| * function(done) { |
| * setTimeout(function() { |
| * order.push(3); |
| * done(null, 3); |
| * }, 40); |
| * }, |
| * function(done) { |
| * setTimeout(function() { |
| * order.push(4); |
| * done(null, 4); |
| * }, 20); |
| * } |
| * ]; |
| * async.series(tasks, function(err, res) { |
| * console.log(res); // [1, 2, 3, 4]; |
| * console.log(order); // [1, 2, 3, 4] |
| * }); |
| * |
| * @example |
| * |
| * var order = []; |
| * var tasks = { |
| * 'a': function(done) { |
| * setTimeout(function() { |
| * order.push(1); |
| * done(null, 1); |
| * }, 10); |
| * }, |
| * 'b': function(done) { |
| * setTimeout(function() { |
| * order.push(2); |
| * done(null, 2); |
| * }, 30); |
| * }, |
| * 'c': function(done) { |
| * setTimeout(function() { |
| * order.push(3); |
| * done(null, 3); |
| * }, 40); |
| * }, |
| * 'd': function(done) { |
| * setTimeout(function() { |
| * order.push(4); |
| * done(null, 4); |
| * }, 20); |
| * } |
| * }; |
| * async.series(tasks, function(err, res) { |
| * console.log(res); // { a: 1, b: 2, c: 3, d:4 } |
| * console.log(order); // [1, 4, 2, 3] |
| * }); |
| * |
| */ |
| function series(tasks, callback) { |
| callback = callback || noop; |
| var size, key, keys, result, iterate; |
| var sync = false; |
| var completed = 0; |
| |
| if (isArray(tasks)) { |
| size = tasks.length; |
| result = Array(size); |
| iterate = arrayIterator; |
| } else if (tasks && typeof tasks === obj) { |
| keys = nativeKeys(tasks); |
| size = keys.length; |
| result = {}; |
| iterate = objectIterator; |
| } else { |
| return callback(null); |
| } |
| if (!size) { |
| return callback(null, result); |
| } |
| iterate(); |
| |
| function arrayIterator() { |
| key = completed; |
| tasks[completed](done); |
| } |
| |
| function objectIterator() { |
| key = keys[completed]; |
| tasks[key](done); |
| } |
| |
| function done(err, res) { |
| if (err) { |
| iterate = throwError; |
| callback = onlyOnce(callback); |
| callback(err, result); |
| return; |
| } |
| result[key] = arguments.length <= 2 ? res : slice(arguments, 1); |
| if (++completed === size) { |
| iterate = throwError; |
| callback(null, result); |
| } else if (sync) { |
| nextTick(iterate); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace parallelLimit |
| * @param {Array|Object} tasks - functions |
| * @param {number} limit - limit >= 1 |
| * @param {Function} callback |
| * @example |
| * |
| * var order = []; |
| * var tasks = [ |
| * function(done) { |
| * setTimeout(function() { |
| * order.push(1); |
| * done(null, 1); |
| * }, 10); |
| * }, |
| * function(done) { |
| * setTimeout(function() { |
| * order.push(2); |
| * done(null, 2); |
| * }, 50); |
| * }, |
| * function(done) { |
| * setTimeout(function() { |
| * order.push(3); |
| * done(null, 3); |
| * }, 30); |
| * }, |
| * function(done) { |
| * setTimeout(function() { |
| * order.push(4); |
| * done(null, 4); |
| * }, 40); |
| * } |
| * ]; |
| * async.parallelLimit(tasks, 2, function(err, res) { |
| * console.log(res); // [1, 2, 3, 4]; |
| * console.log(order); // [1, 3, 2, 4] |
| * }); |
| * |
| * @example |
| * |
| * var order = []; |
| * var tasks = { |
| * 'a': function(done) { |
| * setTimeout(function() { |
| * order.push(1); |
| * done(null, 1); |
| * }, 10); |
| * }, |
| * 'b': function(done) { |
| * setTimeout(function() { |
| * order.push(2); |
| * done(null, 2); |
| * }, 50); |
| * }, |
| * 'c': function(done) { |
| * setTimeout(function() { |
| * order.push(3); |
| * done(null, 3); |
| * }, 20); |
| * }, |
| * 'd': function(done) { |
| * setTimeout(function() { |
| * order.push(4); |
| * done(null, 4); |
| * }, 40); |
| * } |
| * }; |
| * async.parallelLimit(tasks, 2, function(err, res) { |
| * console.log(res); // { a: 1, b: 2, c: 3, d:4 } |
| * console.log(order); // [1, 3, 2, 4] |
| * }); |
| * |
| */ |
| function parallelLimit(tasks, limit, callback) { |
| callback = callback || noop; |
| var size, index, key, keys, result, iterate; |
| var sync = false; |
| var started = 0; |
| var completed = 0; |
| |
| if (isArray(tasks)) { |
| size = tasks.length; |
| result = Array(size); |
| iterate = arrayIterator; |
| } else if (tasks && typeof tasks === obj) { |
| keys = nativeKeys(tasks); |
| size = keys.length; |
| result = {}; |
| iterate = objectIterator; |
| } |
| if (!size || isNaN(limit) || limit < 1) { |
| return callback(null, result); |
| } |
| timesSync(limit > size ? size : limit, iterate); |
| |
| function arrayIterator() { |
| index = started++; |
| if (index < size) { |
| tasks[index](createCallback(index)); |
| } |
| } |
| |
| function objectIterator() { |
| if (started < size) { |
| key = keys[started++]; |
| tasks[key](createCallback(key)); |
| } |
| } |
| |
| function createCallback(key) { |
| return function(err, res) { |
| if (key === null) { |
| throwError(); |
| } |
| if (err) { |
| key = null; |
| iterate = noop; |
| callback = once(callback); |
| callback(err, result); |
| return; |
| } |
| result[key] = arguments.length <= 2 ? res : slice(arguments, 1); |
| key = null; |
| if (++completed === size) { |
| callback(null, result); |
| } else if (sync) { |
| nextTick(iterate); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| }; |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace tryEach |
| * @param {Array|Object} tasks - functions |
| * @param {Function} callback |
| * @example |
| * |
| * var tasks = [ |
| * function(done) { |
| * setTimeout(function() { |
| * done(new Error('error')); |
| * }, 10); |
| * }, |
| * function(done) { |
| * setTimeout(function() { |
| * done(null, 2); |
| * }, 10); |
| * } |
| * ]; |
| * async.tryEach(tasks, function(err, res) { |
| * console.log(res); // 2 |
| * }); |
| * |
| * @example |
| * |
| * var tasks = [ |
| * function(done) { |
| * setTimeout(function() { |
| * done(new Error('error1')); |
| * }, 10); |
| * }, |
| * function(done) { |
| * setTimeout(function() { |
| * done(new Error('error2'); |
| * }, 10); |
| * } |
| * ]; |
| * async.tryEach(tasks, function(err, res) { |
| * console.log(err); // error2 |
| * console.log(res); // undefined |
| * }); |
| * |
| */ |
| function tryEach(tasks, callback) { |
| callback = callback || noop; |
| var size, keys, iterate; |
| var sync = false; |
| var completed = 0; |
| |
| if (isArray(tasks)) { |
| size = tasks.length; |
| iterate = arrayIterator; |
| } else if (tasks && typeof tasks === obj) { |
| keys = nativeKeys(tasks); |
| size = keys.length; |
| iterate = objectIterator; |
| } |
| if (!size) { |
| return callback(null); |
| } |
| iterate(); |
| |
| function arrayIterator() { |
| tasks[completed](done); |
| } |
| |
| function objectIterator() { |
| tasks[keys[completed]](done); |
| } |
| |
| function done(err, res) { |
| if (!err) { |
| if (arguments.length <= 2) { |
| callback(null, res); |
| } else { |
| callback(null, slice(arguments, 1)); |
| } |
| } else if (++completed === size) { |
| callback(err); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| } |
| } |
| |
| /** |
| * check for waterfall tasks |
| * @private |
| * @param {Array} tasks |
| * @param {Function} callback |
| * @return {boolean} |
| */ |
| function checkWaterfallTasks(tasks, callback) { |
| if (!isArray(tasks)) { |
| callback(new Error('First argument to waterfall must be an array of functions')); |
| return false; |
| } |
| if (tasks.length === 0) { |
| callback(null); |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * check for waterfall tasks |
| * @private |
| * @param {function} func |
| * @param {Array|Object} args - arguments |
| * @return {function} next |
| */ |
| function waterfallIterator(func, args, next) { |
| switch (args.length) { |
| case 0: |
| case 1: |
| return func(next); |
| case 2: |
| return func(args[1], next); |
| case 3: |
| return func(args[1], args[2], next); |
| case 4: |
| return func(args[1], args[2], args[3], next); |
| case 5: |
| return func(args[1], args[2], args[3], args[4], next); |
| case 6: |
| return func(args[1], args[2], args[3], args[4], args[5], next); |
| default: |
| args = slice(args, 1); |
| args.push(next); |
| return func.apply(null, args); |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace waterfall |
| * @param {Array} tasks - functions |
| * @param {Function} callback |
| * @example |
| * |
| * var order = []; |
| * var tasks = [ |
| * function(next) { |
| * setTimeout(function() { |
| * order.push(1); |
| * next(null, 1); |
| * }, 10); |
| * }, |
| * function(arg1, next) { |
| * setTimeout(function() { |
| * order.push(2); |
| * next(null, 1, 2); |
| * }, 30); |
| * }, |
| * function(arg1, arg2, next) { |
| * setTimeout(function() { |
| * order.push(3); |
| * next(null, 3); |
| * }, 20); |
| * }, |
| * function(arg1, next) { |
| * setTimeout(function() { |
| * order.push(4); |
| * next(null, 1, 2, 3, 4); |
| * }, 40); |
| * } |
| * ]; |
| * async.waterfall(tasks, function(err, arg1, arg2, arg3, arg4) { |
| * console.log(arg1, arg2, arg3, arg4); // 1 2 3 4 |
| * }); |
| * |
| */ |
| function waterfall(tasks, callback) { |
| callback = callback || noop; |
| if (!checkWaterfallTasks(tasks, callback)) { |
| return; |
| } |
| var func, args, done, sync; |
| var completed = 0; |
| var size = tasks.length; |
| waterfallIterator(tasks[0], [], createCallback(0)); |
| |
| function iterate() { |
| waterfallIterator(func, args, createCallback(func)); |
| } |
| |
| function createCallback(index) { |
| return function next(err, res) { |
| if (index === undefined) { |
| callback = noop; |
| throwError(); |
| } |
| index = undefined; |
| if (err) { |
| done = callback; |
| callback = throwError; |
| done(err); |
| return; |
| } |
| if (++completed === size) { |
| done = callback; |
| callback = throwError; |
| if (arguments.length <= 2) { |
| done(err, res); |
| } else { |
| done.apply(null, createArray(arguments)); |
| } |
| return; |
| } |
| if (sync) { |
| args = arguments; |
| func = tasks[completed] || throwError; |
| nextTick(iterate); |
| } else { |
| sync = true; |
| waterfallIterator(tasks[completed] || throwError, arguments, createCallback(completed)); |
| } |
| sync = false; |
| }; |
| } |
| } |
| |
| /** |
| * `angelFall` is like `waterfall` and inject callback to last argument of next task. |
| * |
| * @memberof async |
| * @namespace angelFall |
| * @param {Array} tasks - functions |
| * @param {Function} callback |
| * @example |
| * |
| * var order = []; |
| * var tasks = [ |
| * function(next) { |
| * setTimeout(function() { |
| * order.push(1); |
| * next(null, 1); |
| * }, 10); |
| * }, |
| * function(arg1, empty, next) { |
| * setTimeout(function() { |
| * order.push(2); |
| * next(null, 1, 2); |
| * }, 30); |
| * }, |
| * function(next) { |
| * setTimeout(function() { |
| * order.push(3); |
| * next(null, 3); |
| * }, 20); |
| * }, |
| * function(arg1, empty1, empty2, empty3, next) { |
| * setTimeout(function() { |
| * order.push(4); |
| * next(null, 1, 2, 3, 4); |
| * }, 40); |
| * } |
| * ]; |
| * async.angelFall(tasks, function(err, arg1, arg2, arg3, arg4) { |
| * console.log(arg1, arg2, arg3, arg4); // 1 2 3 4 |
| * }); |
| * |
| */ |
| function angelFall(tasks, callback) { |
| callback = callback || noop; |
| if (!checkWaterfallTasks(tasks, callback)) { |
| return; |
| } |
| var completed = 0; |
| var sync = false; |
| var size = tasks.length; |
| var func = tasks[completed]; |
| var args = []; |
| var iterate = function() { |
| switch (func.length) { |
| case 0: |
| try { |
| next(null, func()); |
| } catch (e) { |
| next(e); |
| } |
| return; |
| case 1: |
| return func(next); |
| case 2: |
| return func(args[1], next); |
| case 3: |
| return func(args[1], args[2], next); |
| case 4: |
| return func(args[1], args[2], args[3], next); |
| case 5: |
| return func(args[1], args[2], args[3], args[4], next); |
| default: |
| args = slice(args, 1); |
| args[func.length - 1] = next; |
| return func.apply(null, args); |
| } |
| }; |
| iterate(); |
| |
| function next(err, res) { |
| if (err) { |
| iterate = throwError; |
| callback = onlyOnce(callback); |
| callback(err); |
| return; |
| } |
| if (++completed === size) { |
| iterate = throwError; |
| var done = callback; |
| callback = throwError; |
| if (arguments.length === 2) { |
| done(err, res); |
| } else { |
| done.apply(null, createArray(arguments)); |
| } |
| return; |
| } |
| func = tasks[completed]; |
| args = arguments; |
| if (sync) { |
| nextTick(iterate); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace whilst |
| * @param {Function} test |
| * @param {Function} iterator |
| * @param {Function} callback |
| */ |
| function whilst(test, iterator, callback) { |
| callback = callback || noop; |
| var sync = false; |
| if (test()) { |
| iterate(); |
| } else { |
| callback(null); |
| } |
| |
| function iterate() { |
| if (sync) { |
| nextTick(next); |
| } else { |
| sync = true; |
| iterator(done); |
| } |
| sync = false; |
| } |
| |
| function next() { |
| iterator(done); |
| } |
| |
| function done(err, arg) { |
| if (err) { |
| return callback(err); |
| } |
| if (arguments.length <= 2) { |
| if (test(arg)) { |
| iterate(); |
| } else { |
| callback(null, arg); |
| } |
| return; |
| } |
| arg = slice(arguments, 1); |
| if (test.apply(null, arg)) { |
| iterate(); |
| } else { |
| callback.apply(null, [null].concat(arg)); |
| } |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace doWhilst |
| * @param {Function} iterator |
| * @param {Function} test |
| * @param {Function} callback |
| */ |
| function doWhilst(iterator, test, callback) { |
| callback = callback || noop; |
| var sync = false; |
| next(); |
| |
| function iterate() { |
| if (sync) { |
| nextTick(next); |
| } else { |
| sync = true; |
| iterator(done); |
| } |
| sync = false; |
| } |
| |
| function next() { |
| iterator(done); |
| } |
| |
| function done(err, arg) { |
| if (err) { |
| return callback(err); |
| } |
| if (arguments.length <= 2) { |
| if (test(arg)) { |
| iterate(); |
| } else { |
| callback(null, arg); |
| } |
| return; |
| } |
| arg = slice(arguments, 1); |
| if (test.apply(null, arg)) { |
| iterate(); |
| } else { |
| callback.apply(null, [null].concat(arg)); |
| } |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace until |
| * @param {Function} test |
| * @param {Function} iterator |
| * @param {Function} callback |
| */ |
| function until(test, iterator, callback) { |
| callback = callback || noop; |
| var sync = false; |
| if (!test()) { |
| iterate(); |
| } else { |
| callback(null); |
| } |
| |
| function iterate() { |
| if (sync) { |
| nextTick(next); |
| } else { |
| sync = true; |
| iterator(done); |
| } |
| sync = false; |
| } |
| |
| function next() { |
| iterator(done); |
| } |
| |
| function done(err, arg) { |
| if (err) { |
| return callback(err); |
| } |
| if (arguments.length <= 2) { |
| if (!test(arg)) { |
| iterate(); |
| } else { |
| callback(null, arg); |
| } |
| return; |
| } |
| arg = slice(arguments, 1); |
| if (!test.apply(null, arg)) { |
| iterate(); |
| } else { |
| callback.apply(null, [null].concat(arg)); |
| } |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace doUntil |
| * @param {Function} iterator |
| * @param {Function} test |
| * @param {Function} callback |
| */ |
| function doUntil(iterator, test, callback) { |
| callback = callback || noop; |
| var sync = false; |
| next(); |
| |
| function iterate() { |
| if (sync) { |
| nextTick(next); |
| } else { |
| sync = true; |
| iterator(done); |
| } |
| sync = false; |
| } |
| |
| function next() { |
| iterator(done); |
| } |
| |
| function done(err, arg) { |
| if (err) { |
| return callback(err); |
| } |
| if (arguments.length <= 2) { |
| if (!test(arg)) { |
| iterate(); |
| } else { |
| callback(null, arg); |
| } |
| return; |
| } |
| arg = slice(arguments, 1); |
| if (!test.apply(null, arg)) { |
| iterate(); |
| } else { |
| callback.apply(null, [null].concat(arg)); |
| } |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace during |
| * @param {Function} test |
| * @param {Function} iterator |
| * @param {Function} callback |
| */ |
| function during(test, iterator, callback) { |
| callback = callback || noop; |
| _test(); |
| |
| function _test() { |
| test(iterate); |
| } |
| |
| function iterate(err, truth) { |
| if (err) { |
| return callback(err); |
| } |
| if (truth) { |
| iterator(done); |
| } else { |
| callback(null); |
| } |
| } |
| |
| function done(err) { |
| if (err) { |
| return callback(err); |
| } |
| _test(); |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace doDuring |
| * @param {Function} test |
| * @param {Function} iterator |
| * @param {Function} callback |
| */ |
| function doDuring(iterator, test, callback) { |
| callback = callback || noop; |
| iterate(null, true); |
| |
| function iterate(err, truth) { |
| if (err) { |
| return callback(err); |
| } |
| if (truth) { |
| iterator(done); |
| } else { |
| callback(null); |
| } |
| } |
| |
| function done(err, res) { |
| if (err) { |
| return callback(err); |
| } |
| switch (arguments.length) { |
| case 0: |
| case 1: |
| test(iterate); |
| break; |
| case 2: |
| test(res, iterate); |
| break; |
| default: |
| var args = slice(arguments, 1); |
| args.push(iterate); |
| test.apply(null, args); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace forever |
| */ |
| function forever(iterator, callback) { |
| var sync = false; |
| iterate(); |
| |
| function iterate() { |
| iterator(next); |
| } |
| |
| function next(err) { |
| if (err) { |
| if (callback) { |
| return callback(err); |
| } |
| throw err; |
| } |
| if (sync) { |
| nextTick(iterate); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace compose |
| */ |
| function compose() { |
| return seq.apply(null, reverse(arguments)); |
| } |
| |
| /** |
| * @memberof async |
| * @namespace seq |
| */ |
| function seq(/* functions... */) { |
| var fns = createArray(arguments); |
| |
| return function() { |
| var self = this; |
| var args = createArray(arguments); |
| var callback = args[args.length - 1]; |
| if (typeof callback === func) { |
| args.pop(); |
| } else { |
| callback = noop; |
| } |
| reduce(fns, args, iterator, done); |
| |
| function iterator(newargs, fn, callback) { |
| var func = function(err) { |
| var nextargs = slice(arguments, 1); |
| callback(err, nextargs); |
| }; |
| newargs.push(func); |
| fn.apply(self, newargs); |
| } |
| |
| function done(err, res) { |
| res = isArray(res) ? res : [res]; |
| res.unshift(err); |
| callback.apply(self, res); |
| } |
| }; |
| } |
| |
| function createApplyEach(func) { |
| return function applyEach(fns /* arguments */) { |
| var go = function() { |
| var self = this; |
| var args = createArray(arguments); |
| var callback = args.pop() || noop; |
| return func(fns, iterator, callback); |
| |
| function iterator(fn, done) { |
| fn.apply(self, args.concat([done])); |
| } |
| }; |
| if (arguments.length > 1) { |
| var args = slice(arguments, 1); |
| return go.apply(this, args); |
| } else { |
| return go; |
| } |
| }; |
| } |
| |
| /** |
| * @see https://github.com/caolan/async/blob/master/lib/internal/DoublyLinkedList.js |
| */ |
| function DLL() { |
| this.head = null; |
| this.tail = null; |
| this.length = 0; |
| } |
| |
| DLL.prototype._removeLink = function(node) { |
| var prev = node.prev; |
| var next = node.next; |
| if (prev) { |
| prev.next = next; |
| } else { |
| this.head = next; |
| } |
| if (next) { |
| next.prev = prev; |
| } else { |
| this.tail = prev; |
| } |
| node.prev = null; |
| node.next = null; |
| this.length--; |
| return node; |
| }; |
| |
| DLL.prototype.empty = DLL; |
| |
| DLL.prototype._setInitial = function(node) { |
| this.length = 1; |
| this.head = this.tail = node; |
| }; |
| |
| DLL.prototype.insertBefore = function(node, newNode) { |
| newNode.prev = node.prev; |
| newNode.next = node; |
| if (node.prev) { |
| node.prev.next = newNode; |
| } else { |
| this.head = newNode; |
| } |
| node.prev = newNode; |
| this.length++; |
| }; |
| |
| DLL.prototype.unshift = function(node) { |
| if (this.head) { |
| this.insertBefore(this.head, node); |
| } else { |
| this._setInitial(node); |
| } |
| }; |
| |
| DLL.prototype.push = function(node) { |
| var tail = this.tail; |
| if (tail) { |
| node.prev = tail; |
| node.next = tail.next; |
| this.tail = node; |
| tail.next = node; |
| this.length++; |
| } else { |
| this._setInitial(node); |
| } |
| }; |
| |
| DLL.prototype.shift = function() { |
| return this.head && this._removeLink(this.head); |
| }; |
| |
| DLL.prototype.splice = function(end) { |
| var task; |
| var tasks = []; |
| while (end-- && (task = this.shift())) { |
| tasks.push(task); |
| } |
| return tasks; |
| }; |
| |
| DLL.prototype.remove = function(test) { |
| var node = this.head; |
| while (node) { |
| if (test(node)) { |
| this._removeLink(node); |
| } |
| node = node.next; |
| } |
| return this; |
| }; |
| |
| /** |
| * @private |
| */ |
| function baseQueue(isQueue, worker, concurrency, payload) { |
| if (concurrency === undefined) { |
| concurrency = 1; |
| } else if (isNaN(concurrency) || concurrency < 1) { |
| throw new Error('Concurrency must not be zero'); |
| } |
| |
| var workers = 0; |
| var workersList = []; |
| var _callback, _unshift; |
| |
| var q = { |
| _tasks: new DLL(), |
| concurrency: concurrency, |
| payload: payload, |
| saturated: noop, |
| unsaturated: noop, |
| buffer: concurrency / 4, |
| empty: noop, |
| drain: noop, |
| error: noop, |
| started: false, |
| paused: false, |
| push: push, |
| kill: kill, |
| unshift: unshift, |
| remove: remove, |
| process: isQueue ? runQueue : runCargo, |
| length: getLength, |
| running: running, |
| workersList: getWorkersList, |
| idle: idle, |
| pause: pause, |
| resume: resume, |
| _worker: worker |
| }; |
| return q; |
| |
| function push(tasks, callback) { |
| _insert(tasks, callback); |
| } |
| |
| function unshift(tasks, callback) { |
| _insert(tasks, callback, true); |
| } |
| |
| function _exec(task) { |
| var item = { |
| data: task, |
| callback: _callback |
| }; |
| if (_unshift) { |
| q._tasks.unshift(item); |
| } else { |
| q._tasks.push(item); |
| } |
| nextTick(q.process); |
| } |
| |
| function _insert(tasks, callback, unshift) { |
| if (callback == null) { |
| callback = noop; |
| } else if (typeof callback !== 'function') { |
| throw new Error('task callback must be a function'); |
| } |
| q.started = true; |
| var _tasks = isArray(tasks) ? tasks : [tasks]; |
| |
| if (tasks === undefined || !_tasks.length) { |
| if (q.idle()) { |
| nextTick(q.drain); |
| } |
| return; |
| } |
| |
| _unshift = unshift; |
| _callback = callback; |
| arrayEachSync(_tasks, _exec); |
| } |
| |
| function kill() { |
| q.drain = noop; |
| q._tasks.empty(); |
| } |
| |
| function _next(q, tasks) { |
| var called = false; |
| return function done(err, res) { |
| if (called) { |
| throwError(); |
| } |
| called = true; |
| |
| workers--; |
| var task; |
| var index = -1; |
| var size = workersList.length; |
| var taskIndex = -1; |
| var taskSize = tasks.length; |
| var useApply = arguments.length > 2; |
| var args = useApply && createArray(arguments); |
| while (++taskIndex < taskSize) { |
| task = tasks[taskIndex]; |
| while (++index < size) { |
| if (workersList[index] === task) { |
| if (index === 0) { |
| workersList.shift(); |
| } else { |
| workersList.splice(index, 1); |
| } |
| index = size; |
| size--; |
| } |
| } |
| index = -1; |
| if (useApply) { |
| task.callback.apply(task, args); |
| } else { |
| task.callback(err, res); |
| } |
| if (err) { |
| q.error(err, task.data); |
| } |
| } |
| |
| if (workers <= q.concurrency - q.buffer) { |
| q.unsaturated(); |
| } |
| |
| if (q._tasks.length + workers === 0) { |
| q.drain(); |
| } |
| q.process(); |
| }; |
| } |
| |
| function runQueue() { |
| while (!q.paused && workers < q.concurrency && q._tasks.length) { |
| var task = q._tasks.shift(); |
| workers++; |
| workersList.push(task); |
| if (q._tasks.length === 0) { |
| q.empty(); |
| } |
| if (workers === q.concurrency) { |
| q.saturated(); |
| } |
| var done = _next(q, [task]); |
| worker(task.data, done); |
| } |
| } |
| |
| function runCargo() { |
| while (!q.paused && workers < q.concurrency && q._tasks.length) { |
| var tasks = q._tasks.splice(q.payload || q._tasks.length); |
| var index = -1; |
| var size = tasks.length; |
| var data = Array(size); |
| while (++index < size) { |
| data[index] = tasks[index].data; |
| } |
| workers++; |
| nativePush.apply(workersList, tasks); |
| if (q._tasks.length === 0) { |
| q.empty(); |
| } |
| if (workers === q.concurrency) { |
| q.saturated(); |
| } |
| var done = _next(q, tasks); |
| worker(data, done); |
| } |
| } |
| |
| function getLength() { |
| return q._tasks.length; |
| } |
| |
| function running() { |
| return workers; |
| } |
| |
| function getWorkersList() { |
| return workersList; |
| } |
| |
| function idle() { |
| return q.length() + workers === 0; |
| } |
| |
| function pause() { |
| q.paused = true; |
| } |
| |
| function _resume() { |
| nextTick(q.process); |
| } |
| |
| function resume() { |
| if (q.paused === false) { |
| return; |
| } |
| q.paused = false; |
| var count = q.concurrency < q._tasks.length ? q.concurrency : q._tasks.length; |
| timesSync(count, _resume); |
| } |
| |
| /** |
| * @param {Function} test |
| */ |
| function remove(test) { |
| q._tasks.remove(test); |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace queue |
| */ |
| function queue(worker, concurrency) { |
| return baseQueue(true, worker, concurrency); |
| } |
| |
| /** |
| * @memberof async |
| * @namespace priorityQueue |
| */ |
| function priorityQueue(worker, concurrency) { |
| var q = baseQueue(true, worker, concurrency); |
| q.push = push; |
| delete q.unshift; |
| return q; |
| |
| function push(tasks, priority, callback) { |
| q.started = true; |
| priority = priority || 0; |
| var _tasks = isArray(tasks) ? tasks : [tasks]; |
| var taskSize = _tasks.length; |
| |
| if (tasks === undefined || taskSize === 0) { |
| if (q.idle()) { |
| nextTick(q.drain); |
| } |
| return; |
| } |
| |
| callback = typeof callback === func ? callback : noop; |
| var nextNode = q._tasks.head; |
| while (nextNode && priority >= nextNode.priority) { |
| nextNode = nextNode.next; |
| } |
| while (taskSize--) { |
| var item = { |
| data: _tasks[taskSize], |
| priority: priority, |
| callback: callback |
| }; |
| if (nextNode) { |
| q._tasks.insertBefore(nextNode, item); |
| } else { |
| q._tasks.push(item); |
| } |
| nextTick(q.process); |
| } |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace cargo |
| */ |
| function cargo(worker, payload) { |
| return baseQueue(false, worker, 1, payload); |
| } |
| |
| /** |
| * @memberof async |
| * @namespace auto |
| * @param {Object} tasks |
| * @param {number} [concurrency] |
| * @param {Function} [callback] |
| */ |
| function auto(tasks, concurrency, callback) { |
| if (typeof concurrency === func) { |
| callback = concurrency; |
| concurrency = null; |
| } |
| var keys = nativeKeys(tasks); |
| var rest = keys.length; |
| var results = {}; |
| if (rest === 0) { |
| return callback(null, results); |
| } |
| var runningTasks = 0; |
| var readyTasks = []; |
| var listeners = Object.create(null); |
| callback = onlyOnce(callback || noop); |
| concurrency = concurrency || rest; |
| |
| baseEachSync(tasks, iterator, keys); |
| proceedQueue(); |
| |
| function iterator(task, key) { |
| // no dependencies |
| var _task, _taskSize; |
| if (!isArray(task)) { |
| _task = task; |
| _taskSize = 0; |
| readyTasks.push([_task, _taskSize, done]); |
| return; |
| } |
| var dependencySize = task.length - 1; |
| _task = task[dependencySize]; |
| _taskSize = dependencySize; |
| if (dependencySize === 0) { |
| readyTasks.push([_task, _taskSize, done]); |
| return; |
| } |
| // dependencies |
| var index = -1; |
| while (++index < dependencySize) { |
| var dependencyName = task[index]; |
| if (notInclude(keys, dependencyName)) { |
| var msg = |
| 'async.auto task `' + |
| key + |
| '` has non-existent dependency `' + |
| dependencyName + |
| '` in ' + |
| task.join(', '); |
| throw new Error(msg); |
| } |
| var taskListeners = listeners[dependencyName]; |
| if (!taskListeners) { |
| taskListeners = listeners[dependencyName] = []; |
| } |
| taskListeners.push(taskListener); |
| } |
| |
| function done(err, arg) { |
| if (key === null) { |
| throwError(); |
| } |
| arg = arguments.length <= 2 ? arg : slice(arguments, 1); |
| if (err) { |
| rest = 0; |
| runningTasks = 0; |
| readyTasks.length = 0; |
| var safeResults = objectClone(results); |
| safeResults[key] = arg; |
| key = null; |
| var _callback = callback; |
| callback = noop; |
| _callback(err, safeResults); |
| return; |
| } |
| runningTasks--; |
| rest--; |
| results[key] = arg; |
| taskComplete(key); |
| key = null; |
| } |
| |
| function taskListener() { |
| if (--dependencySize === 0) { |
| readyTasks.push([_task, _taskSize, done]); |
| } |
| } |
| } |
| |
| function proceedQueue() { |
| if (readyTasks.length === 0 && runningTasks === 0) { |
| if (rest !== 0) { |
| throw new Error('async.auto task has cyclic dependencies'); |
| } |
| return callback(null, results); |
| } |
| while (readyTasks.length && runningTasks < concurrency && callback !== noop) { |
| runningTasks++; |
| var array = readyTasks.shift(); |
| if (array[1] === 0) { |
| array[0](array[2]); |
| } else { |
| array[0](results, array[2]); |
| } |
| } |
| } |
| |
| function taskComplete(key) { |
| var taskListeners = listeners[key] || []; |
| arrayEachSync(taskListeners, function(task) { |
| task(); |
| }); |
| proceedQueue(); |
| } |
| } |
| |
| var FN_ARGS = /^(function)?\s*[^\(]*\(\s*([^\)]*)\)/m; |
| var FN_ARG_SPLIT = /,/; |
| var FN_ARG = /(=.+)?(\s*)$/; |
| var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm; |
| |
| /** |
| * parse function arguments for `autoInject` |
| * |
| * @private |
| */ |
| function parseParams(func) { |
| func = func.toString().replace(STRIP_COMMENTS, ''); |
| func = func.match(FN_ARGS)[2].replace(' ', ''); |
| func = func ? func.split(FN_ARG_SPLIT) : []; |
| func = func.map(function(arg) { |
| return arg.replace(FN_ARG, '').trim(); |
| }); |
| return func; |
| } |
| |
| /** |
| * @memberof async |
| * @namespace autoInject |
| * @param {Object} tasks |
| * @param {number} [concurrency] |
| * @param {Function} [callback] |
| */ |
| function autoInject(tasks, concurrency, callback) { |
| var newTasks = {}; |
| baseEachSync(tasks, iterator, nativeKeys(tasks)); |
| auto(newTasks, concurrency, callback); |
| |
| function iterator(task, key) { |
| var params; |
| var taskLength = task.length; |
| |
| if (isArray(task)) { |
| if (taskLength === 0) { |
| throw new Error('autoInject task functions require explicit parameters.'); |
| } |
| params = createArray(task); |
| taskLength = params.length - 1; |
| task = params[taskLength]; |
| if (taskLength === 0) { |
| newTasks[key] = task; |
| return; |
| } |
| } else if (taskLength === 1) { |
| newTasks[key] = task; |
| return; |
| } else { |
| params = parseParams(task); |
| if (taskLength === 0 && params.length === 0) { |
| throw new Error('autoInject task functions require explicit parameters.'); |
| } |
| taskLength = params.length - 1; |
| } |
| params[taskLength] = newTask; |
| newTasks[key] = params; |
| |
| function newTask(results, done) { |
| switch (taskLength) { |
| case 1: |
| task(results[params[0]], done); |
| break; |
| case 2: |
| task(results[params[0]], results[params[1]], done); |
| break; |
| case 3: |
| task(results[params[0]], results[params[1]], results[params[2]], done); |
| break; |
| default: |
| var i = -1; |
| while (++i < taskLength) { |
| params[i] = results[params[i]]; |
| } |
| params[i] = done; |
| task.apply(null, params); |
| break; |
| } |
| } |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace retry |
| * @param {integer|Object|Function} opts |
| * @param {Function} [task] |
| * @param {Function} [callback] |
| */ |
| function retry(opts, task, callback) { |
| var times, intervalFunc, errorFilter; |
| var count = 0; |
| if (arguments.length < 3 && typeof opts === func) { |
| callback = task || noop; |
| task = opts; |
| opts = null; |
| times = DEFAULT_TIMES; |
| } else { |
| callback = callback || noop; |
| switch (typeof opts) { |
| case 'object': |
| if (typeof opts.errorFilter === func) { |
| errorFilter = opts.errorFilter; |
| } |
| var interval = opts.interval; |
| switch (typeof interval) { |
| case func: |
| intervalFunc = interval; |
| break; |
| case 'string': |
| case 'number': |
| interval = +interval; |
| intervalFunc = interval |
| ? function() { |
| return interval; |
| } |
| : function() { |
| return DEFAULT_INTERVAL; |
| }; |
| break; |
| } |
| times = +opts.times || DEFAULT_TIMES; |
| break; |
| case 'number': |
| times = opts || DEFAULT_TIMES; |
| break; |
| case 'string': |
| times = +opts || DEFAULT_TIMES; |
| break; |
| default: |
| throw new Error('Invalid arguments for async.retry'); |
| } |
| } |
| if (typeof task !== 'function') { |
| throw new Error('Invalid arguments for async.retry'); |
| } |
| |
| if (intervalFunc) { |
| task(intervalCallback); |
| } else { |
| task(simpleCallback); |
| } |
| |
| function simpleIterator() { |
| task(simpleCallback); |
| } |
| |
| function simpleCallback(err, res) { |
| if (++count === times || !err || (errorFilter && !errorFilter(err))) { |
| if (arguments.length <= 2) { |
| return callback(err, res); |
| } |
| var args = createArray(arguments); |
| return callback.apply(null, args); |
| } |
| simpleIterator(); |
| } |
| |
| function intervalIterator() { |
| task(intervalCallback); |
| } |
| |
| function intervalCallback(err, res) { |
| if (++count === times || !err || (errorFilter && !errorFilter(err))) { |
| if (arguments.length <= 2) { |
| return callback(err, res); |
| } |
| var args = createArray(arguments); |
| return callback.apply(null, args); |
| } |
| setTimeout(intervalIterator, intervalFunc(count)); |
| } |
| } |
| |
| function retryable(opts, task) { |
| if (!task) { |
| task = opts; |
| opts = null; |
| } |
| return done; |
| |
| function done() { |
| var taskFn; |
| var args = createArray(arguments); |
| var lastIndex = args.length - 1; |
| var callback = args[lastIndex]; |
| switch (task.length) { |
| case 1: |
| taskFn = task1; |
| break; |
| case 2: |
| taskFn = task2; |
| break; |
| case 3: |
| taskFn = task3; |
| break; |
| default: |
| taskFn = task4; |
| } |
| if (opts) { |
| retry(opts, taskFn, callback); |
| } else { |
| retry(taskFn, callback); |
| } |
| |
| function task1(done) { |
| task(done); |
| } |
| |
| function task2(done) { |
| task(args[0], done); |
| } |
| |
| function task3(done) { |
| task(args[0], args[1], done); |
| } |
| |
| function task4(callback) { |
| args[lastIndex] = callback; |
| task.apply(null, args); |
| } |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace iterator |
| */ |
| function iterator(tasks) { |
| var size = 0; |
| var keys = []; |
| if (isArray(tasks)) { |
| size = tasks.length; |
| } else { |
| keys = nativeKeys(tasks); |
| size = keys.length; |
| } |
| return makeCallback(0); |
| |
| function makeCallback(index) { |
| var fn = function() { |
| if (size) { |
| var key = keys[index] || index; |
| tasks[key].apply(null, createArray(arguments)); |
| } |
| return fn.next(); |
| }; |
| fn.next = function() { |
| return index < size - 1 ? makeCallback(index + 1) : null; |
| }; |
| return fn; |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace apply |
| */ |
| function apply(func) { |
| switch (arguments.length) { |
| case 0: |
| case 1: |
| return func; |
| case 2: |
| return func.bind(null, arguments[1]); |
| case 3: |
| return func.bind(null, arguments[1], arguments[2]); |
| case 4: |
| return func.bind(null, arguments[1], arguments[2], arguments[3]); |
| case 5: |
| return func.bind(null, arguments[1], arguments[2], arguments[3], arguments[4]); |
| default: |
| var size = arguments.length; |
| var index = 0; |
| var args = Array(size); |
| args[index] = null; |
| while (++index < size) { |
| args[index] = arguments[index]; |
| } |
| return func.bind.apply(func, args); |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace timeout |
| * @param {Function} func |
| * @param {number} millisec |
| * @param {*} info |
| */ |
| function timeout(func, millisec, info) { |
| var callback, timer; |
| return wrappedFunc; |
| |
| function wrappedFunc() { |
| timer = setTimeout(timeoutCallback, millisec); |
| var args = createArray(arguments); |
| var lastIndex = args.length - 1; |
| callback = args[lastIndex]; |
| args[lastIndex] = injectedCallback; |
| simpleApply(func, args); |
| } |
| |
| function timeoutCallback() { |
| var name = func.name || 'anonymous'; |
| var err = new Error('Callback function "' + name + '" timed out.'); |
| err.code = 'ETIMEDOUT'; |
| if (info) { |
| err.info = info; |
| } |
| timer = null; |
| callback(err); |
| } |
| |
| function injectedCallback() { |
| if (timer !== null) { |
| simpleApply(callback, createArray(arguments)); |
| clearTimeout(timer); |
| } |
| } |
| |
| function simpleApply(func, args) { |
| switch (args.length) { |
| case 0: |
| func(); |
| break; |
| case 1: |
| func(args[0]); |
| break; |
| case 2: |
| func(args[0], args[1]); |
| break; |
| default: |
| func.apply(null, args); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace times |
| * @param {number} n - n >= 1 |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * var iterator = function(n, done) { |
| * done(null, n); |
| * }; |
| * async.times(4, iterator, function(err, res) { |
| * console.log(res); // [0, 1, 2, 3]; |
| * }); |
| * |
| */ |
| function times(n, iterator, callback) { |
| callback = callback || noop; |
| n = +n; |
| if (isNaN(n) || n < 1) { |
| return callback(null, []); |
| } |
| var result = Array(n); |
| timesSync(n, iterate); |
| |
| function iterate(num) { |
| iterator(num, createCallback(num)); |
| } |
| |
| function createCallback(index) { |
| return function(err, res) { |
| if (index === null) { |
| throwError(); |
| } |
| result[index] = res; |
| index = null; |
| if (err) { |
| callback(err); |
| callback = noop; |
| } else if (--n === 0) { |
| callback(null, result); |
| } |
| }; |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace timesSeries |
| * @param {number} n - n >= 1 |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * var iterator = function(n, done) { |
| * done(null, n); |
| * }; |
| * async.timesSeries(4, iterator, function(err, res) { |
| * console.log(res); // [0, 1, 2, 3]; |
| * }); |
| * |
| */ |
| function timesSeries(n, iterator, callback) { |
| callback = callback || noop; |
| n = +n; |
| if (isNaN(n) || n < 1) { |
| return callback(null, []); |
| } |
| var result = Array(n); |
| var sync = false; |
| var completed = 0; |
| iterate(); |
| |
| function iterate() { |
| iterator(completed, done); |
| } |
| |
| function done(err, res) { |
| result[completed] = res; |
| if (err) { |
| callback(err); |
| callback = throwError; |
| } else if (++completed >= n) { |
| callback(null, result); |
| callback = throwError; |
| } else if (sync) { |
| nextTick(iterate); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace timesLimit |
| * @param {number} n - n >= 1 |
| * @param {number} limit - n >= 1 |
| * @param {Function} iterator |
| * @param {Function} callback |
| * @example |
| * |
| * var iterator = function(n, done) { |
| * done(null, n); |
| * }; |
| * async.timesLimit(4, 2, iterator, function(err, res) { |
| * console.log(res); // [0, 1, 2, 3]; |
| * }); |
| * |
| */ |
| function timesLimit(n, limit, iterator, callback) { |
| callback = callback || noop; |
| n = +n; |
| if (isNaN(n) || n < 1 || isNaN(limit) || limit < 1) { |
| return callback(null, []); |
| } |
| var result = Array(n); |
| var sync = false; |
| var started = 0; |
| var completed = 0; |
| timesSync(limit > n ? n : limit, iterate); |
| |
| function iterate() { |
| var index = started++; |
| if (index < n) { |
| iterator(index, createCallback(index)); |
| } |
| } |
| |
| function createCallback(index) { |
| return function(err, res) { |
| if (index === null) { |
| throwError(); |
| } |
| result[index] = res; |
| index = null; |
| if (err) { |
| callback(err); |
| callback = noop; |
| } else if (++completed >= n) { |
| callback(null, result); |
| callback = throwError; |
| } else if (sync) { |
| nextTick(iterate); |
| } else { |
| sync = true; |
| iterate(); |
| } |
| sync = false; |
| }; |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace race |
| * @param {Array|Object} tasks - functions |
| * @param {Function} callback |
| * @example |
| * |
| * // array |
| * var called = 0; |
| * var tasks = [ |
| * function(done) { |
| * setTimeout(function() { |
| * called++; |
| * done(null, '1'); |
| * }, 30); |
| * }, |
| * function(done) { |
| * setTimeout(function() { |
| * called++; |
| * done(null, '2'); |
| * }, 20); |
| * }, |
| * function(done) { |
| * setTimeout(function() { |
| * called++; |
| * done(null, '3'); |
| * }, 10); |
| * } |
| * ]; |
| * async.race(tasks, function(err, res) { |
| * console.log(res); // '3' |
| * console.log(called); // 1 |
| * setTimeout(function() { |
| * console.log(called); // 3 |
| * }, 50); |
| * }); |
| * |
| * @example |
| * |
| * // object |
| * var called = 0; |
| * var tasks = { |
| * 'test1': function(done) { |
| * setTimeout(function() { |
| * called++; |
| * done(null, '1'); |
| * }, 30); |
| * }, |
| * 'test2': function(done) { |
| * setTimeout(function() { |
| * called++; |
| * done(null, '2'); |
| * }, 20); |
| * }, |
| * 'test3': function(done) { |
| * setTimeout(function() { |
| * called++; |
| * done(null, '3'); |
| * }, 10); |
| * } |
| * }; |
| * async.race(tasks, function(err, res) { |
| * console.log(res); // '3' |
| * console.log(called); // 1 |
| * setTimeout(function() { |
| * console.log(called); // 3 |
| * done(); |
| * }, 50); |
| * }); |
| * |
| */ |
| function race(tasks, callback) { |
| callback = once(callback || noop); |
| var size, keys; |
| var index = -1; |
| if (isArray(tasks)) { |
| size = tasks.length; |
| while (++index < size) { |
| tasks[index](callback); |
| } |
| } else if (tasks && typeof tasks === obj) { |
| keys = nativeKeys(tasks); |
| size = keys.length; |
| while (++index < size) { |
| tasks[keys[index]](callback); |
| } |
| } else { |
| return callback(new TypeError('First argument to race must be a collection of functions')); |
| } |
| if (!size) { |
| callback(null); |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace memoize |
| */ |
| function memoize(fn, hasher) { |
| hasher = |
| hasher || |
| function(hash) { |
| return hash; |
| }; |
| |
| var memo = {}; |
| var queues = {}; |
| var memoized = function() { |
| var args = createArray(arguments); |
| var callback = args.pop(); |
| var key = hasher.apply(null, args); |
| if (has(memo, key)) { |
| nextTick(function() { |
| callback.apply(null, memo[key]); |
| }); |
| return; |
| } |
| if (has(queues, key)) { |
| return queues[key].push(callback); |
| } |
| |
| queues[key] = [callback]; |
| args.push(done); |
| fn.apply(null, args); |
| |
| function done(err) { |
| var args = createArray(arguments); |
| if (!err) { |
| memo[key] = args; |
| } |
| var q = queues[key]; |
| delete queues[key]; |
| |
| var i = -1; |
| var size = q.length; |
| while (++i < size) { |
| q[i].apply(null, args); |
| } |
| } |
| }; |
| memoized.memo = memo; |
| memoized.unmemoized = fn; |
| return memoized; |
| } |
| |
| /** |
| * @memberof async |
| * @namespace unmemoize |
| */ |
| function unmemoize(fn) { |
| return function() { |
| return (fn.unmemoized || fn).apply(null, arguments); |
| }; |
| } |
| |
| /** |
| * @memberof async |
| * @namespace ensureAsync |
| */ |
| function ensureAsync(fn) { |
| return function(/* ...args, callback */) { |
| var args = createArray(arguments); |
| var lastIndex = args.length - 1; |
| var callback = args[lastIndex]; |
| var sync = true; |
| args[lastIndex] = done; |
| fn.apply(this, args); |
| sync = false; |
| |
| function done() { |
| var innerArgs = createArray(arguments); |
| if (sync) { |
| nextTick(function() { |
| callback.apply(null, innerArgs); |
| }); |
| } else { |
| callback.apply(null, innerArgs); |
| } |
| } |
| }; |
| } |
| |
| /** |
| * @memberof async |
| * @namespace constant |
| */ |
| function constant(/* values... */) { |
| var args = [null].concat(createArray(arguments)); |
| return function(callback) { |
| callback = arguments[arguments.length - 1]; |
| callback.apply(this, args); |
| }; |
| } |
| |
| function asyncify(fn) { |
| return function(/* args..., callback */) { |
| var args = createArray(arguments); |
| var callback = args.pop(); |
| var result; |
| try { |
| result = fn.apply(this, args); |
| } catch (e) { |
| return callback(e); |
| } |
| if (result && typeof result.then === func) { |
| result.then( |
| function(value) { |
| invokeCallback(callback, null, value); |
| }, |
| function(err) { |
| invokeCallback(callback, err && err.message ? err : new Error(err)); |
| } |
| ); |
| } else { |
| callback(null, result); |
| } |
| }; |
| } |
| |
| function invokeCallback(callback, err, value) { |
| try { |
| callback(err, value); |
| } catch (e) { |
| nextTick(rethrow, e); |
| } |
| } |
| |
| function rethrow(error) { |
| throw error; |
| } |
| |
| /** |
| * @memberof async |
| * @namespace reflect |
| * @param {Function} func |
| * @return {Function} |
| */ |
| function reflect(func) { |
| return function(/* args..., callback */) { |
| var callback; |
| switch (arguments.length) { |
| case 1: |
| callback = arguments[0]; |
| return func(done); |
| case 2: |
| callback = arguments[1]; |
| return func(arguments[0], done); |
| default: |
| var args = createArray(arguments); |
| var lastIndex = args.length - 1; |
| callback = args[lastIndex]; |
| args[lastIndex] = done; |
| func.apply(this, args); |
| } |
| |
| function done(err, res) { |
| if (err) { |
| return callback(null, { |
| error: err |
| }); |
| } |
| if (arguments.length > 2) { |
| res = slice(arguments, 1); |
| } |
| callback(null, { |
| value: res |
| }); |
| } |
| }; |
| } |
| |
| /** |
| * @memberof async |
| * @namespace reflectAll |
| * @param {Array[]|Object} tasks |
| * @return {Function} |
| */ |
| function reflectAll(tasks) { |
| var newTasks, keys; |
| if (isArray(tasks)) { |
| newTasks = Array(tasks.length); |
| arrayEachSync(tasks, iterate); |
| } else if (tasks && typeof tasks === obj) { |
| keys = nativeKeys(tasks); |
| newTasks = {}; |
| baseEachSync(tasks, iterate, keys); |
| } |
| return newTasks; |
| |
| function iterate(func, key) { |
| newTasks[key] = reflect(func); |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace createLogger |
| */ |
| function createLogger(name) { |
| return function(fn) { |
| var args = slice(arguments, 1); |
| args.push(done); |
| fn.apply(null, args); |
| }; |
| |
| function done(err) { |
| if (typeof console === obj) { |
| if (err) { |
| if (console.error) { |
| console.error(err); |
| } |
| return; |
| } |
| if (console[name]) { |
| var args = slice(arguments, 1); |
| arrayEachSync(args, function(arg) { |
| console[name](arg); |
| }); |
| } |
| } |
| } |
| } |
| |
| /** |
| * @memberof async |
| * @namespace safe |
| */ |
| function safe() { |
| createImmediate(); |
| return exports; |
| } |
| |
| /** |
| * @memberof async |
| * @namespace fast |
| */ |
| function fast() { |
| createImmediate(false); |
| return exports; |
| } |
| }); |