8889841cforEachOfSeries.js 0000666 00000000104 15051445057 0010116 0 ustar 00 'use strict';
module.exports = require('./async').forEachOfSeries;
applyEach.js 0000666 00000000076 15051445057 0007025 0 ustar 00 'use strict';
module.exports = require('./async').applyEach;
reduce.js 0000666 00000000073 15051445057 0006363 0 ustar 00 'use strict';
module.exports = require('./async').reduce;
retryable.js 0000666 00000000076 15051445057 0007110 0 ustar 00 'use strict';
module.exports = require('./async').retryable;
whilst.js 0000666 00000000073 15051445057 0006426 0 ustar 00 'use strict';
module.exports = require('./async').whilst;
times.js 0000666 00000000072 15051445057 0006234 0 ustar 00 'use strict';
module.exports = require('./async').times;
anyLimit.js 0000666 00000000075 15051445057 0006704 0 ustar 00 'use strict';
module.exports = require('./async').anyLimit;
README.md 0000666 00000030721 15051445057 0006040 0 ustar 00 Neo-Async
Neo-Async is thought to be used as a drop-in replacement for [Async](https://github.com/caolan/async), it almost fully covers its functionality and runs [faster](#benchmark).
Benchmark is [here](#benchmark)!
Bluebird's benchmark is [here](https://github.com/suguru03/bluebird/tree/aigle/benchmark)!
## Code Coverage
## Installation
### In a browser
```html
```
### In an AMD loader
```js
require(['async'], function(async) {});
```
### Promise and async/await
I recommend to use [`Aigle`](https://github.com/suguru03/aigle).
It is optimized for Promise handling and has almost the same functionality as `neo-async`.
### Node.js
#### standard
```bash
$ npm install neo-async
```
```js
var async = require('neo-async');
```
#### replacement
```bash
$ npm install neo-async
$ ln -s ./node_modules/neo-async ./node_modules/async
```
```js
var async = require('async');
```
### Bower
```bash
bower install neo-async
```
## Feature
[JSDoc](http://suguru03.github.io/neo-async/doc/async.html)
\* not in Async
### Collections
- [`each`](http://suguru03.github.io/neo-async/doc/async.each.html)
- [`eachSeries`](http://suguru03.github.io/neo-async/doc/async.eachSeries.html)
- [`eachLimit`](http://suguru03.github.io/neo-async/doc/async.eachLimit.html)
- [`forEach`](http://suguru03.github.io/neo-async/doc/async.each.html) -> [`each`](http://suguru03.github.io/neo-async/doc/async.each.html)
- [`forEachSeries`](http://suguru03.github.io/neo-async/doc/async.eachSeries.html) -> [`eachSeries`](http://suguru03.github.io/neo-async/doc/async.eachSeries.html)
- [`forEachLimit`](http://suguru03.github.io/neo-async/doc/async.eachLimit.html) -> [`eachLimit`](http://suguru03.github.io/neo-async/doc/async.eachLimit.html)
- [`eachOf`](http://suguru03.github.io/neo-async/doc/async.each.html) -> [`each`](http://suguru03.github.io/neo-async/doc/async.each.html)
- [`eachOfSeries`](http://suguru03.github.io/neo-async/doc/async.eachSeries.html) -> [`eachSeries`](http://suguru03.github.io/neo-async/doc/async.eachSeries.html)
- [`eachOfLimit`](http://suguru03.github.io/neo-async/doc/async.eachLimit.html) -> [`eachLimit`](http://suguru03.github.io/neo-async/doc/async.eachLimit.html)
- [`forEachOf`](http://suguru03.github.io/neo-async/doc/async.each.html) -> [`each`](http://suguru03.github.io/neo-async/doc/async.each.html)
- [`forEachOfSeries`](http://suguru03.github.io/neo-async/doc/async.eachSeries.html) -> [`eachSeries`](http://suguru03.github.io/neo-async/doc/async.eachSeries.html)
- [`eachOfLimit`](http://suguru03.github.io/neo-async/doc/async.eachLimit.html) -> [`forEachLimit`](http://suguru03.github.io/neo-async/doc/async.eachLimit.html)
- [`map`](http://suguru03.github.io/neo-async/doc/async.map.html)
- [`mapSeries`](http://suguru03.github.io/neo-async/doc/async.mapSeries.html)
- [`mapLimit`](http://suguru03.github.io/neo-async/doc/async.mapLimit.html)
- [`mapValues`](http://suguru03.github.io/neo-async/doc/async.mapValues.html)
- [`mapValuesSeries`](http://suguru03.github.io/neo-async/doc/async.mapValuesSeries.html)
- [`mapValuesLimit`](http://suguru03.github.io/neo-async/doc/async.mapValuesLimit.html)
- [`filter`](http://suguru03.github.io/neo-async/doc/async.filter.html)
- [`filterSeries`](http://suguru03.github.io/neo-async/doc/async.filterSeries.html)
- [`filterLimit`](http://suguru03.github.io/neo-async/doc/async.filterLimit.html)
- [`select`](http://suguru03.github.io/neo-async/doc/async.filter.html) -> [`filter`](http://suguru03.github.io/neo-async/doc/async.filter.html)
- [`selectSeries`](http://suguru03.github.io/neo-async/doc/async.filterSeries.html) -> [`filterSeries`](http://suguru03.github.io/neo-async/doc/async.filterSeries.html)
- [`selectLimit`](http://suguru03.github.io/neo-async/doc/async.filterLimit.html) -> [`filterLimit`](http://suguru03.github.io/neo-async/doc/async.filterLimit.html)
- [`reject`](http://suguru03.github.io/neo-async/doc/async.reject.html)
- [`rejectSeries`](http://suguru03.github.io/neo-async/doc/async.rejectSeries.html)
- [`rejectLimit`](http://suguru03.github.io/neo-async/doc/async.rejectLimit.html)
- [`detect`](http://suguru03.github.io/neo-async/doc/async.detect.html)
- [`detectSeries`](http://suguru03.github.io/neo-async/doc/async.detectSeries.html)
- [`detectLimit`](http://suguru03.github.io/neo-async/doc/async.detectLimit.html)
- [`find`](http://suguru03.github.io/neo-async/doc/async.detect.html) -> [`detect`](http://suguru03.github.io/neo-async/doc/async.detect.html)
- [`findSeries`](http://suguru03.github.io/neo-async/doc/async.detectSeries.html) -> [`detectSeries`](http://suguru03.github.io/neo-async/doc/async.detectSeries.html)
- [`findLimit`](http://suguru03.github.io/neo-async/doc/async.detectLimit.html) -> [`detectLimit`](http://suguru03.github.io/neo-async/doc/async.detectLimit.html)
- [`pick`](http://suguru03.github.io/neo-async/doc/async.pick.html) *
- [`pickSeries`](http://suguru03.github.io/neo-async/doc/async.pickSeries.html) *
- [`pickLimit`](http://suguru03.github.io/neo-async/doc/async.pickLimit.html) *
- [`omit`](http://suguru03.github.io/neo-async/doc/async.omit.html) *
- [`omitSeries`](http://suguru03.github.io/neo-async/doc/async.omitSeries.html) *
- [`omitLimit`](http://suguru03.github.io/neo-async/doc/async.omitLimit.html) *
- [`reduce`](http://suguru03.github.io/neo-async/doc/async.reduce.html)
- [`inject`](http://suguru03.github.io/neo-async/doc/async.reduce.html) -> [`reduce`](http://suguru03.github.io/neo-async/doc/async.reduce.html)
- [`foldl`](http://suguru03.github.io/neo-async/doc/async.reduce.html) -> [`reduce`](http://suguru03.github.io/neo-async/doc/async.reduce.html)
- [`reduceRight`](http://suguru03.github.io/neo-async/doc/async.reduceRight.html)
- [`foldr`](http://suguru03.github.io/neo-async/doc/async.reduceRight.html) -> [`reduceRight`](http://suguru03.github.io/neo-async/doc/async.reduceRight.html)
- [`transform`](http://suguru03.github.io/neo-async/doc/async.transform.html)
- [`transformSeries`](http://suguru03.github.io/neo-async/doc/async.transformSeries.html) *
- [`transformLimit`](http://suguru03.github.io/neo-async/doc/async.transformLimit.html) *
- [`sortBy`](http://suguru03.github.io/neo-async/doc/async.sortBy.html)
- [`sortBySeries`](http://suguru03.github.io/neo-async/doc/async.sortBySeries.html) *
- [`sortByLimit`](http://suguru03.github.io/neo-async/doc/async.sortByLimit.html) *
- [`some`](http://suguru03.github.io/neo-async/doc/async.some.html)
- [`someSeries`](http://suguru03.github.io/neo-async/doc/async.someSeries.html)
- [`someLimit`](http://suguru03.github.io/neo-async/doc/async.someLimit.html)
- [`any`](http://suguru03.github.io/neo-async/doc/async.some.html) -> [`some`](http://suguru03.github.io/neo-async/doc/async.some.html)
- [`anySeries`](http://suguru03.github.io/neo-async/doc/async.someSeries.html) -> [`someSeries`](http://suguru03.github.io/neo-async/doc/async.someSeries.html)
- [`anyLimit`](http://suguru03.github.io/neo-async/doc/async.someLimit.html) -> [`someLimit`](http://suguru03.github.io/neo-async/doc/async.someLimit.html)
- [`every`](http://suguru03.github.io/neo-async/doc/async.every.html)
- [`everySeries`](http://suguru03.github.io/neo-async/doc/async.everySeries.html)
- [`everyLimit`](http://suguru03.github.io/neo-async/doc/async.everyLimit.html)
- [`all`](http://suguru03.github.io/neo-async/doc/async.every.html) -> [`every`](http://suguru03.github.io/neo-async/doc/async.every.html)
- [`allSeries`](http://suguru03.github.io/neo-async/doc/async.everySeries.html) -> [`every`](http://suguru03.github.io/neo-async/doc/async.everySeries.html)
- [`allLimit`](http://suguru03.github.io/neo-async/doc/async.everyLimit.html) -> [`every`](http://suguru03.github.io/neo-async/doc/async.everyLimit.html)
- [`concat`](http://suguru03.github.io/neo-async/doc/async.concat.html)
- [`concatSeries`](http://suguru03.github.io/neo-async/doc/async.concatSeries.html)
- [`concatLimit`](http://suguru03.github.io/neo-async/doc/async.concatLimit.html) *
### Control Flow
- [`parallel`](http://suguru03.github.io/neo-async/doc/async.parallel.html)
- [`series`](http://suguru03.github.io/neo-async/doc/async.series.html)
- [`parallelLimit`](http://suguru03.github.io/neo-async/doc/async.series.html)
- [`tryEach`](http://suguru03.github.io/neo-async/doc/async.tryEach.html)
- [`waterfall`](http://suguru03.github.io/neo-async/doc/async.waterfall.html)
- [`angelFall`](http://suguru03.github.io/neo-async/doc/async.angelFall.html) *
- [`angelfall`](http://suguru03.github.io/neo-async/doc/async.angelFall.html) -> [`angelFall`](http://suguru03.github.io/neo-async/doc/async.angelFall.html) *
- [`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`](http://suguru03.github.io/neo-async/doc/async.times.html)
- [`timesSeries`](http://suguru03.github.io/neo-async/doc/async.timesSeries.html)
- [`timesLimit`](http://suguru03.github.io/neo-async/doc/async.timesLimit.html)
- [`race`](#race)
### Utils
- [`apply`](#apply)
- [`setImmediate`](#setImmediate)
- [`nextTick`](#nextTick)
- [`memoize`](#memoize)
- [`unmemoize`](#unmemoize)
- [`ensureAsync`](#ensureAsync)
- [`constant`](#constant)
- [`asyncify`](#asyncify)
- [`wrapSync`](#asyncify) -> [`asyncify`](#asyncify)
- [`log`](#log)
- [`dir`](#dir)
- [`timeout`](http://suguru03.github.io/neo-async/doc/async.timeout.html)
- [`reflect`](#reflect)
- [`reflectAll`](#reflectAll)
- [`createLogger`](#createLogger)
## Mode
- [`safe`](#safe) *
- [`fast`](#fast) *
## Benchmark
[Benchmark: Async vs Neo-Async](http://suguru03.hatenablog.com/entry/2016/06/10/135559)
### How to check
```bash
$ node perf
```
### Environment
* Darwin 17.3.0 x64
* Node.js v8.9.4
* async v2.6.0
* neo-async v2.5.0
* benchmark v2.1.4
### Result
The value is the ratio (Neo-Async/Async) of the average speed.
#### Collections
|function|benchmark|
|---|--:|
|each/forEach|2.43|
|eachSeries/forEachSeries|1.75|
|eachLimit/forEachLimit|1.68|
|eachOf|3.29|
|eachOfSeries|1.50|
|eachOfLimit|1.59|
|map|3.95|
|mapSeries|1.81|
|mapLimit|1.27|
|mapValues|2.73|
|mapValuesSeries|1.59|
|mapValuesLimit|1.23|
|filter|3.00|
|filterSeries|1.74|
|filterLimit|1.17|
|reject|4.59|
|rejectSeries|2.31|
|rejectLimit|1.58|
|detect|4.30|
|detectSeries|1.86|
|detectLimit|1.32|
|reduce|1.82|
|transform|2.46|
|sortBy|4.08|
|some|2.19|
|someSeries|1.83|
|someLimit|1.32|
|every|2.09|
|everySeries|1.84|
|everyLimit|1.35|
|concat|3.79|
|concatSeries|4.45|
#### Control Flow
|funciton|benchmark|
|---|--:|
|parallel|2.93|
|series|1.96|
|waterfall|1.29|
|whilst|1.00|
|doWhilst|1.12|
|until|1.12|
|doUntil|1.12|
|during|1.18|
|doDuring|2.42|
|times|4.25|
|auto|1.97|
## License
[](https://app.fossa.io/projects/git%2Bgithub.com%2Fsuguru03%2Fneo-async?ref=badge_large)
mapValuesLimit.js 0000666 00000000103 15051445057 0010042 0 ustar 00 'use strict';
module.exports = require('./async').mapValuesLimit;
filterSeries.js 0000666 00000000101 15051445057 0007544 0 ustar 00 'use strict';
module.exports = require('./async').filterSeries;
selectLimit.js 0000666 00000000100 15051445057 0007361 0 ustar 00 'use strict';
module.exports = require('./async').selectLimit;
eachSeries.js 0000666 00000000077 15051445057 0007173 0 ustar 00 'use strict';
module.exports = require('./async').eachSeries;
pickSeries.js 0000666 00000000077 15051445057 0007221 0 ustar 00 'use strict';
module.exports = require('./async').pickSeries;
doWhilst.js 0000666 00000000075 15051445057 0006713 0 ustar 00 'use strict';
module.exports = require('./async').doWhilst;
series.js 0000666 00000000073 15051445057 0006406 0 ustar 00 'use strict';
module.exports = require('./async').series;
findSeries.js 0000666 00000000077 15051445057 0007213 0 ustar 00 'use strict';
module.exports = require('./async').findSeries;
mapValuesSeries.js 0000666 00000000104 15051445057 0010217 0 ustar 00 'use strict';
module.exports = require('./async').mapValuesSeries;
transform.js 0000666 00000000076 15051445057 0007132 0 ustar 00 'use strict';
module.exports = require('./async').transform;
until.js 0000666 00000000072 15051445057 0006246 0 ustar 00 'use strict';
module.exports = require('./async').until;
groupBy.js 0000666 00000000074 15051445057 0006544 0 ustar 00 'use strict';
module.exports = require('./async').groupBy;
parallel.js 0000666 00000000075 15051445057 0006712 0 ustar 00 'use strict';
module.exports = require('./async').parallel;
forEachSeries.js 0000666 00000000102 15051445057 0007627 0 ustar 00 'use strict';
module.exports = require('./async').forEachSeries;
timesSeries.js 0000666 00000000100 15051445057 0007377 0 ustar 00 'use strict';
module.exports = require('./async').timesSeries;
mapSeries.js 0000666 00000000076 15051445057 0007047 0 ustar 00 'use strict';
module.exports = require('./async').mapSeries;
reject.js 0000666 00000000073 15051445057 0006370 0 ustar 00 'use strict';
module.exports = require('./async').reject;
timesLimit.js 0000666 00000000077 15051445057 0007240 0 ustar 00 'use strict';
module.exports = require('./async').timesLimit;
priorityQueue.js 0000666 00000000102 15051445057 0007773 0 ustar 00 'use strict';
module.exports = require('./async').priorityQueue;
everyLimit.js 0000666 00000000077 15051445057 0007251 0 ustar 00 'use strict';
module.exports = require('./async').everyLimit;
reduceRight.js 0000666 00000000100 15051445057 0007350 0 ustar 00 'use strict';
module.exports = require('./async').reduceRight;
someSeries.js 0000666 00000000077 15051445057 0007236 0 ustar 00 'use strict';
module.exports = require('./async').someSeries;
createLogger.js 0000666 00000000101 15051445057 0007507 0 ustar 00 'use strict';
module.exports = require('./async').createLogger;
reflectAll.js 0000666 00000000077 15051445057 0007175 0 ustar 00 'use strict';
module.exports = require('./async').reflectAll;
retry.js 0000666 00000000072 15051445057 0006260 0 ustar 00 'use strict';
module.exports = require('./async').retry;
cargo.js 0000666 00000000072 15051445057 0006206 0 ustar 00 'use strict';
module.exports = require('./async').cargo;
eachLimit.js 0000666 00000000076 15051445057 0007016 0 ustar 00 'use strict';
module.exports = require('./async').eachLimit;
wrapSync.js 0000666 00000000075 15051445057 0006724 0 ustar 00 'use strict';
module.exports = require('./async').wrapSync;
omitSeries.js 0000666 00000000077 15051445057 0007243 0 ustar 00 'use strict';
module.exports = require('./async').omitSeries;
detect.js 0000666 00000000073 15051445057 0006364 0 ustar 00 'use strict';
module.exports = require('./async').detect;
forEach.js 0000666 00000000074 15051445057 0006464 0 ustar 00 'use strict';
module.exports = require('./async').forEach;
eachOfSeries.js 0000666 00000000101 15051445057 0007444 0 ustar 00 'use strict';
module.exports = require('./async').eachOfSeries;
inject.js 0000666 00000000073 15051445057 0006370 0 ustar 00 'use strict';
module.exports = require('./async').inject;
transformSeries.js 0000666 00000000104 15051445057 0010275 0 ustar 00 'use strict';
module.exports = require('./async').transformSeries;
forEachOfLimit.js 0000666 00000000103 15051445057 0007741 0 ustar 00 'use strict';
module.exports = require('./async').forEachOfLimit;
iterator.js 0000666 00000000075 15051445057 0006747 0 ustar 00 'use strict';
module.exports = require('./async').iterator;
each.js 0000666 00000000071 15051445057 0006012 0 ustar 00 'use strict';
module.exports = require('./async').each;
tryEach.js 0000666 00000000074 15051445057 0006514 0 ustar 00 'use strict';
module.exports = require('./async').tryEach;
foldr.js 0000666 00000000072 15051445057 0006221 0 ustar 00 'use strict';
module.exports = require('./async').foldr;
transformLimit.js 0000666 00000000103 15051445057 0010120 0 ustar 00 'use strict';
module.exports = require('./async').transformLimit;
log.js 0000666 00000000070 15051445057 0005672 0 ustar 00 'use strict';
module.exports = require('./async').log;
safe.js 0000666 00000000071 15051445057 0006030 0 ustar 00 'use strict';
module.exports = require('./async').safe;
autoInject.js 0000666 00000000077 15051445057 0007225 0 ustar 00 'use strict';
module.exports = require('./async').autoInject;
timeout.js 0000666 00000000074 15051445057 0006603 0 ustar 00 'use strict';
module.exports = require('./async').timeout;
angelFall.js 0000666 00000000076 15051445057 0007004 0 ustar 00 'use strict';
module.exports = require('./async').angelfall;
doDuring.js 0000666 00000000075 15051445057 0006671 0 ustar 00 'use strict';
module.exports = require('./async').doDuring;
apply.js 0000666 00000000072 15051445057 0006240 0 ustar 00 'use strict';
module.exports = require('./async').apply;
applyEachSeries.js 0000666 00000000104 15051445057 0010170 0 ustar 00 'use strict';
module.exports = require('./async').applyEachSeries;
memoize.js 0000666 00000000074 15051445057 0006562 0 ustar 00 'use strict';
module.exports = require('./async').memoize;
detectLimit.js 0000666 00000000100 15051445057 0007352 0 ustar 00 'use strict';
module.exports = require('./async').detectLimit;
all.js 0000666 00000000070 15051445057 0005661 0 ustar 00 'use strict';
module.exports = require('./async').all;
select.js 0000666 00000000073 15051445057 0006373 0 ustar 00 'use strict';
module.exports = require('./async').select;
async.min.js 0000666 00000116533 15051445057 0007024 0 ustar 00 (function(N,O){"object"===typeof exports&&"undefined"!==typeof module?O(exports):"function"===typeof define&&define.amd?define(["exports"],O):N.async?O(N.neo_async=N.neo_async||{}):O(N.async=N.async||{})})(this,function(N){function O(a){var c=function(a){var d=J(arguments,1);setTimeout(function(){a.apply(null,d)})};T="function"===typeof setImmediate?setImmediate:c;"object"===typeof process&&"function"===typeof process.nextTick?(D=/^v0.10/.test(process.version)?T:process.nextTick,ba=/^v0/.test(process.version)?
T:process.nextTick):ba=D=T;!1===a&&(D=function(a){a()})}function H(a){for(var c=-1,b=a.length,d=Array(b);++c=d)return[];for(var e=Array(d);++bd[e]){var g=d[f];
d[f]=d[e];d[e]=g}}if(!(e>b)){for(var l,e=a[a[c]>a[e]?c:e],f=c,g=b;f<=g;){for(l=f;f=l&&a[g]>=e;)g--;if(f>g)break;var q=a;l=d;var s=f++,h=g--,k=q[s];q[s]=q[h];q[h]=k;q=l[s];l[s]=l[h];l[h]=q}e=f;ca(a,c,e-1,d);ca(a,e,b,d)}}}function S(a){var c=[];Q(a,function(a){a!==w&&(C(a)?X.apply(c,a):c.push(a))});return c}function da(a,c,b){var d=-1,e=a.length;if(3===c.length)for(;++db)return e(null,[]);y=y||Array(m);K(b>m?m:b,x)}}function Y(a,c,b){function d(){c(a[v],s)}function e(){c(a[v],v,s)}function f(){n=r.next();n.done?b(null):c(n.value,s)}function g(){n=r.next();n.done?b(null):c(n.value,v,s)}function l(){c(a[m[v]],s)}function q(){k=m[v];c(a[k],k,s)}function s(a,d){a?b(a):++v===h||!1===d?(p=A,b(null)):u?D(p):
(u=!0,p());u=!1}b=E(b||w);var h,k,m,r,n,p,u=!1,v=0;C(a)?(h=a.length,p=3===c.length?e:d):a&&(z&&a[z]?(h=Infinity,r=a[z](),p=3===c.length?g:f):"object"===typeof a&&(m=F(a),h=m.length,p=3===c.length?q:l));if(!h)return b(null);p()}function Z(a,c,b,d){function e(){xc)return d(null);K(c>k?k:c,v)}function za(a,c,b){function d(){c(a[t],s)}function e(){c(a[t],t,s)}function f(){n=r.next();
n.done?b(null,p):c(n.value,s)}function g(){n=r.next();n.done?b(null,p):c(n.value,t,s)}function l(){c(a[m[t]],s)}function q(){k=m[t];c(a[k],k,s)}function s(a,d){a?(u=A,b=E(b),b(a,H(p))):(p[t]=d,++t===h?(u=A,b(null,p),b=A):v?D(u):(v=!0,u()),v=!1)}b=b||w;var h,k,m,r,n,p,u,v=!1,t=0;C(a)?(h=a.length,u=3===c.length?e:d):a&&(z&&a[z]?(h=Infinity,p=[],r=a[z](),u=3===c.length?g:f):"object"===typeof a&&(m=F(a),h=m.length,u=3===c.length?q:l));if(!h)return b(null,[]);p=p||Array(h);u()}function Aa(a,c,b,d){return function(e,
f,g){function l(a){var b=!1;return function(c,e){b&&A();b=!0;c?(g=I(g),g(c)):!!e===d?(g=I(g),g(null,a)):++h===q&&g(null)}}g=g||w;var q,s,h=0;C(e)?(q=e.length,a(e,f,l)):e&&(z&&e[z]?(q=b(e,f,l))&&q===h&&g(null):"object"===typeof e&&(s=F(e),q=s.length,c(e,f,l,s)));q||g(null)}}function Ba(a){return function(c,b,d){function e(){r=c[x];b(r,h)}function f(){r=c[x];b(r,x,h)}function g(){u=p.next();r=u.value;u.done?d(null):b(r,h)}function l(){u=p.next();r=u.value;u.done?d(null):b(r,x,h)}function q(){r=c[n[x]];
b(r,h)}function s(){m=n[x];r=c[m];b(r,m,h)}function h(b,c){b?d(b):!!c===a?(v=A,d(null,r)):++x===k?(v=A,d(null)):t?D(v):(t=!0,v());t=!1}d=E(d||w);var k,m,r,n,p,u,v,t=!1,x=0;C(c)?(k=c.length,v=3===b.length?f:e):c&&(z&&c[z]?(k=Infinity,p=c[z](),v=3===b.length?l:g):"object"===typeof c&&(n=F(c),k=n.length,v=3===b.length?s:q));if(!k)return d(null);v()}}function Ca(a){return function(c,b,d,e){function f(){r=G++;rb)return e(null);K(b>m?m:b,x)}}function Da(a,c,b,d){return function(e,f,g){function l(a,b){return function(c,e){null===a&&A();c?(a=null,g=I(g),g(c,L(k))):(!!e===d&&(k[a]=b),a=null,++h===q&&g(null,k))}}g=g||w;var q,s,h=0,k={};C(e)?(q=e.length,a(e,f,l)):e&&(z&&e[z]?(q=b(e,f,l))&&q===h&&g(null,k):"object"===typeof e&&(s=F(e),q=s.length,c(e,f,l,s)));if(!q)return g(null,{})}}function Ea(a){return function(c,
b,d){function e(){m=y;r=c[y];b(r,h)}function f(){m=y;r=c[y];b(r,y,h)}function g(){m=y;u=p.next();r=u.value;u.done?d(null,x):b(r,h)}function l(){m=y;u=p.next();r=u.value;u.done?d(null,x):b(r,m,h)}function q(){m=n[y];r=c[m];b(r,h)}function s(){m=n[y];r=c[m];b(r,m,h)}function h(b,c){b?d(b,x):(!!c===a&&(x[m]=r),++y===k?(v=A,d(null,x)):t?D(v):(t=!0,v()),t=!1)}d=E(d||w);var k,m,r,n,p,u,v,t=!1,x={},y=0;C(c)?(k=c.length,v=3===b.length?f:e):c&&(z&&c[z]?(k=Infinity,p=c[z](),v=3===b.length?l:g):"object"===typeof c&&
(n=F(c),k=n.length,v=3===b.length?s:q));if(!k)return d(null,{});v()}}function Fa(a){return function(c,b,d,e){function f(){r=B++;rb)return e(null,{});K(b>m?m:b,x)}}function $(a,c,b,d){function e(d){b(d,a[t],h)}function f(d){b(d,a[t],t,h)}function g(a){p=n.next();p.done?d(null,a):b(a,p.value,
h)}function l(a){p=n.next();p.done?d(null,a):b(a,p.value,t,h)}function q(d){b(d,a[r[t]],h)}function s(d){m=r[t];b(d,a[m],m,h)}function h(a,c){a?d(a,c):++t===k?(b=A,d(null,c)):v?D(function(){u(c)}):(v=!0,u(c));v=!1}d=E(d||w);var k,m,r,n,p,u,v=!1,t=0;C(a)?(k=a.length,u=4===b.length?f:e):a&&(z&&a[z]?(k=Infinity,n=a[z](),u=4===b.length?l:g):"object"===typeof a&&(r=F(a),k=r.length,u=4===b.length?s:q));if(!k)return d(null,c);u(c)}function Ga(a,c,b,d){function e(d){b(d,a[--s],q)}function f(d){b(d,a[--s],
s,q)}function g(d){b(d,a[m[--s]],q)}function l(d){k=m[--s];b(d,a[k],k,q)}function q(a,b){a?d(a,b):0===s?(u=A,d(null,b)):v?D(function(){u(b)}):(v=!0,u(b));v=!1}d=E(d||w);var s,h,k,m,r,n,p,u,v=!1;if(C(a))s=a.length,u=4===b.length?f:e;else if(a)if(z&&a[z]){p=[];r=a[z]();for(h=-1;!1===(n=r.next()).done;)p[++h]=n.value;a=p;s=p.length;u=4===b.length?f:e}else"object"===typeof a&&(m=F(a),s=m.length,u=4===b.length?l:g);if(!s)return d(null,c);u(c)}function Ha(a,c,b){b=b||w;ja(a,c,function(a,c){if(a)return b(a);
b(null,!!c)})}function Ia(a,c,b){b=b||w;ka(a,c,function(a,c){if(a)return b(a);b(null,!!c)})}function Ja(a,c,b,d){d=d||w;la(a,c,b,function(a,b){if(a)return d(a);d(null,!!b)})}function Ka(a,c){return C(a)?0===a.length?(c(null),!1):!0:(c(Error("First argument to waterfall must be an array of functions")),!1)}function ma(a,c,b){switch(c.length){case 0:case 1:return a(b);case 2:return a(c[1],b);case 3:return a(c[1],c[2],b);case 4:return a(c[1],c[2],c[3],b);case 5:return a(c[1],c[2],c[3],c[4],b);case 6:return a(c[1],
c[2],c[3],c[4],c[5],b);default:return c=J(c,1),c.push(b),a.apply(null,c)}}function La(a,c){function b(b,h){if(b)q=A,c=E(c),c(b);else if(++d===f){q=A;var k=c;c=A;2===arguments.length?k(b,h):k.apply(null,H(arguments))}else g=a[d],l=arguments,e?D(q):(e=!0,q()),e=!1}c=c||w;if(Ka(a,c)){var d=0,e=!1,f=a.length,g=a[d],l=[],q=function(){switch(g.length){case 0:try{b(null,g())}catch(a){b(a)}break;case 1:return g(b);case 2:return g(l[1],b);case 3:return g(l[1],l[2],b);case 4:return g(l[1],l[2],l[3],b);case 5:return g(l[1],
l[2],l[3],l[4],b);default:return l=J(l,1),l[g.length-1]=b,g.apply(null,l)}};q()}}function Ma(){var a=H(arguments);return function(){var c=this,b=H(arguments),d=b[b.length-1];"function"===typeof d?b.pop():d=w;$(a,b,function(a,b,d){a.push(function(a){var b=J(arguments,1);d(a,b)});b.apply(c,a)},function(a,b){b=C(b)?b:[b];b.unshift(a);d.apply(c,b)})}}function Na(a){return function(c){var b=function(){var b=this,d=H(arguments),g=d.pop()||w;return a(c,function(a,c){a.apply(b,d.concat([c]))},g)};if(1b)throw Error("Concurrency must not be zero");var h=0,k=[],m,r,n={_tasks:new M,concurrency:b,payload:d,saturated:w,unsaturated:w,buffer:b/4,empty:w,drain:w,error:w,started:!1,paused:!1,push:function(a,
b){f(a,b)},kill:function(){n.drain=w;n._tasks.empty()},unshift:function(a,b){f(a,b,!0)},remove:function(a){n._tasks.remove(a)},process:a?l:q,length:function(){return n._tasks.length},running:function(){return h},workersList:function(){return k},idle:function(){return 0===n.length()+h},pause:function(){n.paused=!0},resume:function(){!1!==n.paused&&(n.paused=!1,K(n.concurrency=arguments.length?f:J(arguments,1);if(a){q=g=0;s.length=0;var k=L(l);k[d]=f;d=null;var h=
b;b=w;h(a,k)}else q--,g--,l[d]=f,e(d),d=null}function n(){0===--v&&s.push([p,u,c])}var p,u;if(C(a)){var v=a.length-1;p=a[v];u=v;if(0===v)s.push([p,u,c]);else for(var t=-1;++t=arguments.length)return b(a,e);var f=H(arguments);return b.apply(null,f)}c(d)}function e(){c(f)}function f(a,d){if(++s===g||!a||q&&!q(a)){if(2>=arguments.length)return b(a,d);var c=H(arguments);return b.apply(null,c)}setTimeout(e,l(s))}var g,l,q,s=0;if(3>arguments.length&&"function"===typeof a)b=c||w,c=a,a=null,g=5;else switch(b=b||w,typeof a){case "object":"function"===typeof a.errorFilter&&(q=a.errorFilter);var h=a.interval;
switch(typeof h){case "function":l=h;break;case "string":case "number":l=(h=+h)?function(){return h}:function(){return 0}}g=+a.times||5;break;case "number":g=a||5;break;case "string":g=+a||5;break;default:throw Error("Invalid arguments for async.retry");}if("function"!==typeof c)throw Error("Invalid arguments for async.retry");l?c(f):c(d)}function Pa(a){return function(){var c=H(arguments),b=c.pop(),d;try{d=a.apply(this,c)}catch(e){return b(e)}d&&"function"===typeof d.then?d.then(function(a){try{b(null,
a)}catch(d){D(Qa,d)}},function(a){a=a&&a.message?a:Error(a);try{b(a,void 0)}catch(d){D(Qa,d)}}):b(null,d)}}function Qa(a){throw a;}function Ra(a){return function(){function c(a,d){if(a)return b(null,{error:a});2=arguments.length?c:J(arguments,1),a=null,++q===f&&d(null,l))}}d=d||w;var f,g,l,q=0;C(b)?(f=b.length,l=Array(f),a(b,e)):b&&"object"===typeof b&&(g=F(b),f=g.length,l={},c(b,e,g));f||d(null,l)}}(function(a,c){for(var b=-1,d=a.length;++bc)return d(null,[]);v=v||Array(k);K(c>k?k:c,t)},mapValues:fb,mapValuesSeries:function(a,c,b){function d(){k=t;c(a[t],
s)}function e(){k=t;c(a[t],t,s)}function f(){k=t;n=r.next();n.done?b(null,v):c(n.value,s)}function g(){k=t;n=r.next();n.done?b(null,v):c(n.value,t,s)}function l(){k=m[t];c(a[k],s)}function q(){k=m[t];c(a[k],k,s)}function s(a,d){a?(p=A,b=E(b),b(a,L(v))):(v[k]=d,++t===h?(p=A,b(null,v),b=A):u?D(p):(u=!0,p()),u=!1)}b=b||w;var h,k,m,r,n,p,u=!1,v={},t=0;C(a)?(h=a.length,p=3===c.length?e:d):a&&(z&&a[z]?(h=Infinity,r=a[z](),p=3===c.length?g:f):"object"===typeof a&&(m=F(a),h=m.length,p=3===c.length?q:l));
if(!h)return b(null,v);p()},mapValuesLimit:function(a,c,b,d){function e(){m=y++;mc)return d(null,x);K(c>k?k:c,v)},filter:Ta,filterSeries:Ua,filterLimit:Va,select:Ta,selectSeries:Ua,selectLimit:Va,reject:gb,rejectSeries:hb,rejectLimit:ib,detect:ja,detectSeries:ka,detectLimit:la,find:ja,findSeries:ka,findLimit:la,pick:jb,pickSeries:kb,
pickLimit:lb,omit:mb,omitSeries:nb,omitLimit:ob,reduce:$,inject:$,foldl:$,reduceRight:Ga,foldr:Ga,transform:pb,transformSeries:function(a,c,b,d){function e(){b(v,a[x],h)}function f(){b(v,a[x],x,h)}function g(){p=n.next();p.done?d(null,v):b(v,p.value,h)}function l(){p=n.next();p.done?d(null,v):b(v,p.value,x,h)}function q(){b(v,a[r[x]],h)}function s(){m=r[x];b(v,a[m],m,h)}function h(a,b){a?d(a,v):++x===k||!1===b?(u=A,d(null,v)):t?D(u):(t=!0,u());t=!1}3===arguments.length&&(d=b,b=c,c=void 0);d=E(d||
w);var k,m,r,n,p,u,v,t=!1,x=0;C(a)?(k=a.length,v=void 0!==c?c:[],u=4===b.length?f:e):a&&(z&&a[z]?(k=Infinity,n=a[z](),v=void 0!==c?c:{},u=4===b.length?l:g):"object"===typeof a&&(r=F(a),k=r.length,v=void 0!==c?c:{},u=4===b.length?s:q));if(!k)return d(null,void 0!==c?c:v||{});u()},transformLimit:function(a,c,b,d,e){function f(){r=A++;rc)return e(null,void 0!==b?b:x||{});K(c>m?m:c,t)},sortBy:qb,sortBySeries:function(a,c,b){function d(){m=a[y];c(m,s)}function e(){m=a[y];c(m,y,s)}function f(){p=n.next();if(p.done)return b(null,P(u,v));m=p.value;u[y]=m;c(m,s)}function g(){p=n.next();if(p.done)return b(null,P(u,v));m=p.value;u[y]=m;c(m,y,s)}function l(){m=a[r[y]];u[y]=m;c(m,s)}function q(){k=r[y];m=a[k];u[y]=m;c(m,k,s)}function s(a,d){v[y]=d;a?b(a):++y===h?(t=A,b(null,
P(u,v))):x?D(t):(x=!0,t());x=!1}b=E(b||w);var h,k,m,r,n,p,u,v,t,x=!1,y=0;C(a)?(h=a.length,u=a,v=Array(h),t=3===c.length?e:d):a&&(z&&a[z]?(h=Infinity,u=[],v=[],n=a[z](),t=3===c.length?g:f):"object"===typeof a&&(r=F(a),h=r.length,u=Array(h),v=Array(h),t=3===c.length?q:l));if(!h)return b(null,[]);t()},sortByLimit:function(a,c,b,d){function e(){Bc)return d(null,[]);x=x||Array(k);K(c>k?k:c,y)},some:Ha,someSeries:Ia,someLimit:Ja,any:Ha,anySeries:Ia,anyLimit:Ja,every:Wa,everySeries:Xa,everyLimit:Ya,all:Wa,allSeries:Xa,allLimit:Ya,concat:rb,concatSeries:function(a,c,b){function d(){c(a[t],s)}function e(){c(a[t],t,s)}function f(){n=r.next();n.done?b(null,v):c(n.value,s)}function g(){n=r.next();n.done?b(null,v):c(n.value,t,s)}function l(){c(a[m[t]],
s)}function q(){k=m[t];c(a[k],k,s)}function s(a,d){C(d)?X.apply(v,d):2<=arguments.length&&X.apply(v,J(arguments,1));a?b(a,v):++t===h?(p=A,b(null,v)):u?D(p):(u=!0,p());u=!1}b=E(b||w);var h,k,m,r,n,p,u=!1,v=[],t=0;C(a)?(h=a.length,p=3===c.length?e:d):a&&(z&&a[z]?(h=Infinity,r=a[z](),p=3===c.length?g:f):"object"===typeof a&&(m=F(a),h=m.length,p=3===c.length?q:l));if(!h)return b(null,v);p()},concatLimit:function(a,c,b,d){function e(){tc)return d(null,[]);u=u||Array(k);K(c>k?k:c,p)},groupBy:sb,groupBySeries:function(a,c,b){function d(){m=a[t];c(m,s)}function e(){m=a[t];c(m,t,s)}function f(){p=n.next();m=p.value;p.done?b(null,x):c(m,s)}function g(){p=n.next();m=p.value;p.done?
b(null,x):c(m,t,s)}function l(){m=a[r[t]];c(m,s)}function q(){k=r[t];m=a[k];c(m,k,s)}function s(a,d){if(a)u=A,b=E(b),b(a,L(x));else{var c=x[d];c?c.push(m):x[d]=[m];++t===h?(u=A,b(null,x)):v?D(u):(v=!0,u());v=!1}}b=E(b||w);var h,k,m,r,n,p,u,v=!1,t=0,x={};C(a)?(h=a.length,u=3===c.length?e:d):a&&(z&&a[z]?(h=Infinity,n=a[z](),u=3===c.length?g:f):"object"===typeof a&&(r=F(a),h=r.length,u=3===c.length?q:l));if(!h)return b(null,x);u()},groupByLimit:function(a,c,b,d){function e(){yc)return d(null,B);K(c>k?k:c,t)},parallel:tb,series:function(a,c){function b(){g=k;a[k](e)}function d(){g=l[k];a[g](e)}function e(a,b){a?(s=A,c=E(c),c(a,q)):(q[g]=2>=arguments.length?b:J(arguments,1),++k===f?(s=A,c(null,q)):h?D(s):(h=!0,s()),h=!1)}c=c||w;var f,g,l,q,s,h=!1,k=0;if(C(a))f=a.length,q=Array(f),
s=b;else if(a&&"object"===typeof a)l=F(a),f=l.length,q={},s=d;else return c(null);if(!f)return c(null,q);s()},parallelLimit:function(a,c,b){function d(){l=r++;if(l=arguments.length?c:J(arguments,1),a=null,++n===g?b(null,h):m?D(k):(m=!0,k()),m=!1)}}b=b||w;var g,l,q,s,h,k,m=!1,r=0,n=0;C(a)?(g=a.length,h=Array(g),k=d):a&&"object"===typeof a&&(s=F(a),g=s.length,h=
{},k=e);if(!g||isNaN(c)||1>c)return b(null,h);K(c>g?g:c,k)},tryEach:function(a,c){function b(){a[q](e)}function d(){a[g[q]](e)}function e(a,b){a?++q===f?c(a):l():2>=arguments.length?c(null,b):c(null,J(arguments,1))}c=c||w;var f,g,l,q=0;C(a)?(f=a.length,l=b):a&&"object"===typeof a&&(g=F(a),f=g.length,l=d);if(!f)return c(null);l()},waterfall:function(a,c){function b(){ma(e,f,d(e))}function d(h){return function(k,m){void 0===h&&(c=w,A());h=void 0;k?(g=c,c=A,g(k)):++q===s?(g=c,c=A,2>=arguments.length?
g(k,m):g.apply(null,H(arguments))):(l?(f=arguments,e=a[q]||A,D(b)):(l=!0,ma(a[q]||A,arguments,d(q))),l=!1)}}c=c||w;if(Ka(a,c)){var e,f,g,l,q=0,s=a.length;ma(a[0],[],d(0))}},angelFall:La,angelfall:La,whilst:function(a,c,b){function d(){g?D(e):(g=!0,c(f));g=!1}function e(){c(f)}function f(c,e){if(c)return b(c);2>=arguments.length?a(e)?d():b(null,e):(e=J(arguments,1),a.apply(null,e)?d():b.apply(null,[null].concat(e)))}b=b||w;var g=!1;a()?d():b(null)},doWhilst:function(a,c,b){function d(){g?D(e):(g=!0,
a(f));g=!1}function e(){a(f)}function f(a,e){if(a)return b(a);2>=arguments.length?c(e)?d():b(null,e):(e=J(arguments,1),c.apply(null,e)?d():b.apply(null,[null].concat(e)))}b=b||w;var g=!1;e()},until:function(a,c,b){function d(){g?D(e):(g=!0,c(f));g=!1}function e(){c(f)}function f(c,e){if(c)return b(c);2>=arguments.length?a(e)?b(null,e):d():(e=J(arguments,1),a.apply(null,e)?b.apply(null,[null].concat(e)):d())}b=b||w;var g=!1;a()?b(null):d()},doUntil:function(a,c,b){function d(){g?D(e):(g=!0,a(f));g=
!1}function e(){a(f)}function f(a,e){if(a)return b(a);2>=arguments.length?c(e)?b(null,e):d():(e=J(arguments,1),c.apply(null,e)?b.apply(null,[null].concat(e)):d())}b=b||w;var g=!1;e()},during:function(a,c,b){function d(a,d){if(a)return b(a);d?c(e):b(null)}function e(c){if(c)return b(c);a(d)}b=b||w;a(d)},doDuring:function(a,c,b){function d(d,c){if(d)return b(d);c?a(e):b(null)}function e(a,e){if(a)return b(a);switch(arguments.length){case 0:case 1:c(d);break;case 2:c(e,d);break;default:var l=J(arguments,
1);l.push(d);c.apply(null,l)}}b=b||w;d(null,!0)},forever:function(a,c){function b(){a(d)}function d(a){if(a){if(c)return c(a);throw a;}e?D(b):(e=!0,b());e=!1}var e=!1;b()},compose:function(){return Ma.apply(null,Za(arguments))},seq:Ma,applyEach:ub,applyEachSeries:vb,queue:function(a,c){return na(!0,a,c)},priorityQueue:function(a,c){var b=na(!0,a,c);b.push=function(a,c,f){b.started=!0;c=c||0;var g=C(a)?a:[a],l=g.length;if(void 0===a||0===l)b.idle()&&D(b.drain);else{f="function"===typeof f?f:w;for(a=
b._tasks.head;a&&c>=a.priority;)a=a.next;for(;l--;){var q={data:g[l],priority:c,callback:f};a?b._tasks.insertBefore(a,q):b._tasks.push(q);D(b.process)}}};delete b.unshift;return b},cargo:function(a,c){return na(!1,a,1,c)},auto:Oa,autoInject:function(a,c,b){var d={};W(a,function(a,b){var c,l=a.length;if(C(a)){if(0===l)throw Error("autoInject task functions require explicit parameters.");c=H(a);l=c.length-1;a=c[l];if(0===l){d[b]=a;return}}else{if(1===l){d[b]=a;return}c=ab(a);if(0===l&&0===c.length)throw Error("autoInject task functions require explicit parameters.");
l=c.length-1}c[l]=function(b,d){switch(l){case 1:a(b[c[0]],d);break;case 2:a(b[c[0]],b[c[1]],d);break;case 3:a(b[c[0]],b[c[1]],b[c[2]],d);break;default:for(var f=-1;++fa)return b(null,[]);var e=Array(a);K(a,function(a){c(a,d(a))})},timesSeries:function(a,c,b){function d(){c(l,
e)}function e(c,e){f[l]=e;c?(b(c),b=A):++l>=a?(b(null,f),b=A):g?D(d):(g=!0,d());g=!1}b=b||w;a=+a;if(isNaN(a)||1>a)return b(null,[]);var f=Array(a),g=!1,l=0;d()},timesLimit:function(a,c,b,d){function e(){var c=q++;c=a?(d(null,g),d=A):l?D(e):(l=!0,e());l=!1}}d=d||w;a=+a;if(isNaN(a)||1>a||isNaN(c)||1>c)return d(null,[]);var g=Array(a),l=!1,q=0,s=0;K(c>a?a:c,e)},race:function(a,c){c=I(c||w);var b,d,e=-1;if(C(a))for(b=
a.length;++e= 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.2
* @namespace async
*/
var index = {
VERSION: '2.6.2',
// 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);
// Avoid leaking the callback
_callback = undefined;
}
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 = new DLL();
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;
}
});
find.js 0000666 00000000071 15051445057 0006032 0 ustar 00 'use strict';
module.exports = require('./async').find;
compose.js 0000666 00000000074 15051445057 0006562 0 ustar 00 'use strict';
module.exports = require('./async').compose;
queue.js 0000666 00000000072 15051445057 0006237 0 ustar 00 'use strict';
module.exports = require('./async').queue;
concatSeries.js 0000666 00000000101 15051445057 0007526 0 ustar 00 'use strict';
module.exports = require('./async').concatSeries;
ensureAsync.js 0000666 00000000100 15051445057 0007402 0 ustar 00 'use strict';
module.exports = require('./async').ensureAsync;
filter.js 0000666 00000000073 15051445057 0006401 0 ustar 00 'use strict';
module.exports = require('./async').filter;
pick.js 0000666 00000000071 15051445057 0006040 0 ustar 00 'use strict';
module.exports = require('./async').pick;
doUntil.js 0000666 00000000074 15051445057 0006533 0 ustar 00 'use strict';
module.exports = require('./async').doUntil;
LICENSE 0000666 00000002137 15051445057 0005566 0 ustar 00 MIT License
Copyright (c) 2014-2018 Suguru Motegi
Based on Async.js, Copyright Caolan McMahon
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
sortBy.js 0000666 00000000073 15051445057 0006376 0 ustar 00 'use strict';
module.exports = require('./async').sortBy;
eachOf.js 0000666 00000000073 15051445057 0006301 0 ustar 00 'use strict';
module.exports = require('./async').eachOf;
allSeries.js 0000666 00000000076 15051445057 0007042 0 ustar 00 'use strict';
module.exports = require('./async').allSeries;
detectSeries.js 0000666 00000000101 15051445057 0007527 0 ustar 00 'use strict';
module.exports = require('./async').detectSeries;
asyncify.js 0000666 00000000075 15051445057 0006743 0 ustar 00 'use strict';
module.exports = require('./async').asyncify;
omit.js 0000666 00000000071 15051445057 0006062 0 ustar 00 'use strict';
module.exports = require('./async').omit;
auto.js 0000666 00000000071 15051445057 0006062 0 ustar 00 'use strict';
module.exports = require('./async').auto;
sortByLimit.js 0000666 00000000100 15051445057 0007364 0 ustar 00 'use strict';
module.exports = require('./async').sortByLimit;
forEachOf.js 0000666 00000000076 15051445057 0006753 0 ustar 00 'use strict';
module.exports = require('./async').forEachOf;
mapLimit.js 0000666 00000000075 15051445057 0006672 0 ustar 00 'use strict';
module.exports = require('./async').mapLimit;
findLimit.js 0000666 00000000076 15051445057 0007036 0 ustar 00 'use strict';
module.exports = require('./async').findLimit;
groupBySeries.js 0000666 00000000102 15051445057 0007707 0 ustar 00 'use strict';
module.exports = require('./async').groupBySeries;
concatLimit.js 0000666 00000000100 15051445057 0007351 0 ustar 00 'use strict';
module.exports = require('./async').concatLimit;
setImmediate.js 0000666 00000000101 15051445057 0007516 0 ustar 00 'use strict';
module.exports = require('./async').setImmediate;
selectSeries.js 0000666 00000000101 15051445057 0007536 0 ustar 00 'use strict';
module.exports = require('./async').selectSeries;
reflect.js 0000666 00000000074 15051445057 0006541 0 ustar 00 'use strict';
module.exports = require('./async').reflect;
everySeries.js 0000666 00000000100 15051445057 0007410 0 ustar 00 'use strict';
module.exports = require('./async').everySeries;
any.js 0000666 00000000070 15051445057 0005700 0 ustar 00 'use strict';
module.exports = require('./async').any;
someLimit.js 0000666 00000000076 15051445057 0007061 0 ustar 00 'use strict';
module.exports = require('./async').someLimit;
dir.js 0000666 00000000070 15051445057 0005667 0 ustar 00 'use strict';
module.exports = require('./async').dir;
fast.js 0000666 00000000071 15051445057 0006047 0 ustar 00 'use strict';
module.exports = require('./async').fast;
forever.js 0000666 00000000074 15051445057 0006565 0 ustar 00 'use strict';
module.exports = require('./async').forever;
package.json 0000666 00000002540 15051445057 0007045 0 ustar 00 {
"name": "neo-async",
"version": "2.6.2",
"description": "Neo-Async is a drop-in replacement for Async, it almost fully covers its functionality and runs faster ",
"main": "async.js",
"license": "MIT",
"keywords": [
"async",
"util"
],
"repository": {
"type": "git",
"url": "git@github.com:suguru03/neo-async.git"
},
"homepage": "https://github.com/suguru03/neo-async",
"dependencies": {},
"devDependencies": {
"aigle": "^1.14.0",
"async": "^2.6.0",
"benchmark": "^2.1.1",
"bluebird": "^3.5.1",
"codecov.io": "^0.1.6",
"fs-extra": "^4.0.2",
"func-comparator": "^0.7.2",
"gulp": "^4.0.2",
"gulp-bump": "^2.8.0",
"gulp-exit": "0.0.2",
"gulp-git": "^2.4.2",
"gulp-jscs": "^4.0.0",
"gulp-mocha": "^4.2.0",
"gulp-tag-version": "^1.3.0",
"gulp-util": "^3.0.7",
"husky": "^1.2.0",
"istanbul": "^0.4.3",
"jsdoc": "^3.5.5",
"jshint": "^2.9.5",
"lint-staged": "^8.1.0",
"lodash": "^4.16.6",
"minimist": "^1.2.0",
"mocha": "^3.5.3",
"mocha-parallel-executor": "^0.3.0",
"mocha.parallel": "^0.15.3",
"prettier": "^1.15.2",
"require-dir": "^0.3.0"
},
"lint-staged": {
"*.{js,ts}": [
"prettier --write",
"git add"
]
},
"prettier": {
"printWidth": 100,
"singleQuote": true
},
"browser": "async.min.js"
}