| (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; | |
| } | |
| }); |