pax_global_header 0000666 0000000 0000000 00000000064 13466145133 0014520 g ustar 00root root 0000000 0000000 52 comment=1e68fa1555f6ac7781124de5712f8a4b187f814e
neo-async-2.6.1/ 0000775 0000000 0000000 00000000000 13466145133 0013422 5 ustar 00root root 0000000 0000000 neo-async-2.6.1/.circleci/ 0000775 0000000 0000000 00000000000 13466145133 0015255 5 ustar 00root root 0000000 0000000 neo-async-2.6.1/.circleci/config.yml 0000664 0000000 0000000 00000001414 13466145133 0017245 0 ustar 00root root 0000000 0000000
# Javascript Node CircleCI 2.0 configuration file
#
# Check https://circleci.com/docs/2.0/language-javascript/ for more details
#
version: 2
jobs:
build:
docker:
# specify the version you desire here
- image: circleci/node:10
working_directory: ~/repo
steps:
- checkout
# Download and cache dependencies
- restore_cache:
keys:
- v1-dependencies-{{ checksum "package.json" }}
# fallback to using the latest cache if no exact match is found
- v1-dependencies-
- run: npm install
- save_cache:
paths:
- node_modules
key: v1-dependencies-{{ checksum "package.json" }}
# run tests!
- run:
name: Test
command: npm test
neo-async-2.6.1/.gitignore 0000664 0000000 0000000 00000000102 13466145133 0015403 0 ustar 00root root 0000000 0000000 node_modules
npm-debug.log
coverage
doc
build
compiler.jar
.idea
neo-async-2.6.1/.jsbeautifyrc 0000664 0000000 0000000 00000001074 13466145133 0016117 0 ustar 00root root 0000000 0000000 {
"indent_size": 2,
"indent_char": " ",
"eol": "\n",
"indent_level": 0,
"indent_with_tabs": false,
"preserve_newlines": true,
"max_preserve_newlines": 2,
"jslint_happy": false,
"space_after_anon_function": false,
"brace_style": "collapse",
"keep_array_indentation": true,
"keep_function_indentation": false,
"space_before_conditional": true,
"break_chained_methods": false,
"eval_code": false,
"unescape_strings": false,
"wrap_line_length": 0,
"wrap_attributes": "auto",
"wrap_attributes_indent_size": 2,
"end_with_newline": true
}
neo-async-2.6.1/.jscsrc 0000664 0000000 0000000 00000002573 13466145133 0014721 0 ustar 00root root 0000000 0000000 {
"disallowKeywords": ["with"],
"disallowMixedSpacesAndTabs": true,
"disallowMultipleLineStrings": true,
"disallowNewlineBeforeBlockStatements": true,
"disallowSpaceAfterObjectKeys": true,
"disallowSpaceAfterPrefixUnaryOperators": ["!"],
"disallowSpaceBeforeBinaryOperators": [","],
"disallowSpacesInAnonymousFunctionExpression": {
"beforeOpeningRoundBrace": true
},
"disallowSpacesInFunctionDeclaration": {
"beforeOpeningRoundBrace": true
},
"disallowSpacesInNamedFunctionExpression": {
"beforeOpeningRoundBrace": true
},
"disallowSpacesInsideParentheses": true,
"disallowTrailingComma": true,
"disallowTrailingWhitespace": true,
"requireSpaceAfterKeywords": ["if", "else", "for", "while", "do", "switch", "return", "try", "catch"],
"requireSpacesInFunction": {
"beforeOpeningCurlyBrace": true
},
"validateParameterSeparator": ", ",
"requireCurlyBraces": ["if", "else", "for", "while", "do", "try", "catch"],
"requireSpaceAfterBinaryOperators": ["?", ":", "+", "-", "/", "*", "%", "==", "===", "!=", "!==", ">", ">=", "<", "<=", "&&", "||"],
"requireSpaceBeforeBinaryOperators": ["?", ":", "+", "-", "/", "*", "%", "==", "===", "!=", "!==", ">", ">=", "<", "<=", "&&", "||"],
"disallowImplicitTypeConversion": ["string"],
"disallowMultipleLineBreaks": true,
"disallowKeywordsOnNewLine": ["else"],
"requireLineFeedAtFileEnd": true
}
neo-async-2.6.1/.jsdocrc 0000664 0000000 0000000 00000000272 13466145133 0015053 0 ustar 00root root 0000000 0000000 {
"opts": {
"destination": "./doc",
"recurse": true
},
"source": {
"includePattern": ".+\\.js(doc)?$",
"excludePattern": "(coverage/)|(doc/)|(node_modules/)"
}
}
neo-async-2.6.1/.jshintrc 0000664 0000000 0000000 00000002140 13466145133 0015244 0 ustar 00root root 0000000 0000000 {
"predef": [
"define",
"Symbol"
],
"indent": 2,
"bitwise": false,
"camelcase": false,
"curly": false,
"eqeqeq": true,
"forin": false,
"immed": true,
"latedef": false,
"newcap": false,
"noarg": true,
"noempty": false,
"nonew": false,
"plusplus": false,
"quotmark": false,
"regexp": false,
"undef": true,
"unused": true,
"strict": true,
"trailing": true,
"maxparams": false,
"maxdepth": false,
"maxstatements": false,
"maxcomplexity": false,
"maxlen": false,
"boss": false,
"debug": false,
"eqnull": true,
"esnext": true,
"evil": true,
"expr": true,
"funcscope": false,
"globalstrict": false,
"lastsemic": false,
"laxbreak": false,
"laxcomma": true,
"loopfunc": false,
"multistr": false,
"onecase": false,
"proto": true,
"regexdash": false,
"scripturl": true,
"smarttabs": false,
"shadow": false,
"sub": false,
"supernew": false,
"validthis": false,
"browser": true,
"jquery": true,
"node": true,
"worker": true,
"nomen": false,
"onevar": false,
"white": false,
"-W018": true,
"es3":true
}
neo-async-2.6.1/.travis.yml 0000664 0000000 0000000 00000000217 13466145133 0015533 0 ustar 00root root 0000000 0000000 language: node_js
after_success: 'make test-codecov; make clean'
install: npm install
node_js:
- 'node'
- '12'
- '10'
- '8'
- '6'
neo-async-2.6.1/LICENSE 0000664 0000000 0000000 00000002137 13466145133 0014432 0 ustar 00root root 0000000 0000000 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.
neo-async-2.6.1/Makefile 0000664 0000000 0000000 00000001071 13466145133 0015061 0 ustar 00root root 0000000 0000000 MOCHA=./node_modules/mocha/bin/_mocha
ISTANBUL=./node_modules/.bin/istanbul
test-cov: clean
$(ISTANBUL) cover $(MOCHA) --report lcovonly -- -R spec ./test/*/*.js
test-codecov:
cat ./coverage/lcov.info | ./node_modules/codecov.io/bin/codecov.io.js --verbose
release-test:
DELAY=20 npm test | npm run-script cov:100
clean:
rm -rf coverage
minify:
java -jar ../compiler-latest/compiler.jar --js ./lib/async.js --js_output_file ./lib/async.min.js
cp:
cp ./lib/async.min.js ./dist/async.min.js
cp ./lib/async.js ./dist/async.js
release: release-test minify cp
neo-async-2.6.1/README.md 0000664 0000000 0000000 00000030034 13466145133 0014701 0 ustar 00root root 0000000 0000000 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|
neo-async-2.6.1/bower.json 0000664 0000000 0000000 00000001034 13466145133 0015431 0 ustar 00root root 0000000 0000000 {
"name": "neo-async",
"main": "lib/async.js",
"version": "2.6.1",
"homepage": "https://github.com/suguru03/neo-async",
"authors": [
"Suguru Motegi"
],
"description": "Neo-Async is thought to be used as a drop-in replacement for Async, it almost fully covers its functionality and runs faster ",
"moduleType": [
"amd",
"globals",
"node"
],
"keywords": [
"async",
"util"
],
"license": "MIT",
"ignore": [
"**/.*",
"node_modules",
"bower_components",
"test",
"tests"
]
}
neo-async-2.6.1/dist/ 0000775 0000000 0000000 00000000000 13466145133 0014365 5 ustar 00root root 0000000 0000000 neo-async-2.6.1/dist/async.js 0000664 0000000 0000000 00000713024 13466145133 0016047 0 ustar 00root root 0000000 0000000 (function(global, factory) {
/*jshint -W030 */
'use strict';
typeof exports === 'object' && typeof module !== 'undefined'
? factory(exports)
: typeof define === 'function' && define.amd
? define(['exports'], factory)
: global.async
? factory((global.neo_async = global.neo_async || {}))
: factory((global.async = global.async || {}));
})(this, function(exports) {
'use strict';
var noop = function noop() {};
var throwError = function throwError() {
throw new Error('Callback was already called.');
};
var DEFAULT_TIMES = 5;
var DEFAULT_INTERVAL = 0;
var obj = 'object';
var func = 'function';
var isArray = Array.isArray;
var nativeKeys = Object.keys;
var nativePush = Array.prototype.push;
var iteratorSymbol = typeof Symbol === func && Symbol.iterator;
var nextTick, asyncNextTick, asyncSetImmediate;
createImmediate();
/**
* @memberof async
* @namespace each
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done();
* }, num * 10);
* };
* async.each(array, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done();
* }, num * 10);
* };
* async.each(array, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [[1, 0], [2, 2], [3, 1]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done();
* }, num * 10);
* };
* async.each(object, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done();
* }, num * 10);
* };
* async.each(object, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
* });
*
* @example
*
* // break
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num !== 2);
* }, num * 10);
* };
* async.each(array, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [1, 2]
* });
*
*/
var each = createEach(arrayEach, baseEach, symbolEach);
/**
* @memberof async
* @namespace map
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.map(array, iterator, function(err, res) {
* console.log(res); // [1, 3, 2];
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num);
* }, num * 10);
* };
* async.map(array, iterator, function(err, res) {
* console.log(res); // [1, 3, 2]
* console.log(order); // [[1, 0], [2, 2], [3, 1]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.map(object, iterator, function(err, res) {
* console.log(res); // [1, 3, 2]
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num);
* }, num * 10);
* };
* async.map(object, iterator, function(err, res) {
* console.log(res); // [1, 3, 2]
* console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
* });
*
*/
var map = createMap(arrayEachIndex, baseEachIndex, symbolEachIndex, true);
/**
* @memberof async
* @namespace mapValues
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.mapValues(array, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 3, '2': 2 }
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num);
* }, num * 10);
* };
* async.mapValues(array, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 3, '2': 2 }
* console.log(order); // [[1, 0], [2, 2], [3, 1]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.mapValues(object, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 3, c: 2 }
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num);
* }, num * 10);
* };
* async.mapValues(object, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 3, c: 2 }
* console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
* });
*
*/
var mapValues = createMap(arrayEachIndex, baseEachKey, symbolEachKey, false);
/**
* @memberof async
* @namespace filter
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.filter(array, iterator, function(err, res) {
* console.log(res); // [1, 3];
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.filter(array, iterator, function(err, res) {
* console.log(res); // [1, 3];
* console.log(order); // [[1, 0], [2, 2], [3, 1]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.filter(object, iterator, function(err, res) {
* console.log(res); // [1, 3];
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.filter(object, iterator, function(err, res) {
* console.log(res); // [1, 3];
* console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
* });
*
*/
var filter = createFilter(arrayEachIndexValue, baseEachIndexValue, symbolEachIndexValue, true);
/**
* @memberof async
* @namespace filterSeries
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.filterSeries(array, iterator, function(err, res) {
* console.log(res); // [1, 3];
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.filterSeries(array, iterator, function(err, res) {
* console.log(res); // [1, 3]
* console.log(order); // [[1, 0], [3, 1], [2, 2]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.filterSeries(object, iterator, function(err, res) {
* console.log(res); // [1, 3]
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.filterSeries(object, iterator, function(err, res) {
* console.log(res); // [1, 3]
* console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]
* });
*
*/
var filterSeries = createFilterSeries(true);
/**
* @memberof async
* @namespace filterLimit
* @param {Array|Object} collection
* @param {number} limit - limit >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.filterLimit(array, 2, iterator, function(err, res) {
* console.log(res); // [1, 5, 3]
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.filterLimit(array, 2, iterator, function(err, res) {
* console.log(res); // [1, 5, 3]
* console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.filterLimit(object, 2, iterator, function(err, res) {
* console.log(res); // [1, 5, 3]
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.filterLimit(object, 2, iterator, function(err, res) {
* console.log(res); // [1, 5, 3]
* console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
* });
*
*/
var filterLimit = createFilterLimit(true);
/**
* @memberof async
* @namespace reject
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.reject(array, iterator, function(err, res) {
* console.log(res); // [2];
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.reject(array, iterator, function(err, res) {
* console.log(res); // [2];
* console.log(order); // [[1, 0], [2, 2], [3, 1]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.reject(object, iterator, function(err, res) {
* console.log(res); // [2];
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.reject(object, iterator, function(err, res) {
* console.log(res); // [2];
* console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
* });
*
*/
var reject = createFilter(arrayEachIndexValue, baseEachIndexValue, symbolEachIndexValue, false);
/**
* @memberof async
* @namespace rejectSeries
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.rejectSeries(array, iterator, function(err, res) {
* console.log(res); // [2];
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.rejectSeries(object, iterator, function(err, res) {
* console.log(res); // [2];
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.rejectSeries(object, iterator, function(err, res) {
* console.log(res); // [2];
* console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]
* });
*
*/
var rejectSeries = createFilterSeries(false);
/**
* @memberof async
* @namespace rejectLimit
* @param {Array|Object} collection
* @param {number} limit - limit >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.rejectLimit(array, 2, iterator, function(err, res) {
* console.log(res); // [4, 2]
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.rejectLimit(array, 2, iterator, function(err, res) {
* console.log(res); // [4, 2]
* console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.rejectLimit(object, 2, iterator, function(err, res) {
* console.log(res); // [4, 2]
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.rejectLimit(object, 2, iterator, function(err, res) {
* console.log(res); // [4, 2]
* console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
* });
*
*/
var rejectLimit = createFilterLimit(false);
/**
* @memberof async
* @namespace detect
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.detect(array, iterator, function(err, res) {
* console.log(res); // 1
* console.log(order); // [1]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.detect(array, iterator, function(err, res) {
* console.log(res); // 1
* console.log(order); // [[1, 0]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.detect(object, iterator, function(err, res) {
* console.log(res); // 1
* console.log(order); // [1]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.detect(object, iterator, function(err, res) {
* console.log(res); // 1
* console.log(order); // [[1, 'a']]
* });
*
*/
var detect = createDetect(arrayEachValue, baseEachValue, symbolEachValue, true);
/**
* @memberof async
* @namespace detectSeries
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.detectSeries(array, iterator, function(err, res) {
* console.log(res); // 1
* console.log(order); // [1]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.detectSeries(array, iterator, function(err, res) {
* console.log(res); // 1
* console.log(order); // [[1, 0]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.detectSeries(object, iterator, function(err, res) {
* console.log(res); // 1
* console.log(order); // [1]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.detectSeries(object, iterator, function(err, res) {
* console.log(res); // 1
* console.log(order); // [[1, 'a']]
* });
*
*/
var detectSeries = createDetectSeries(true);
/**
* @memberof async
* @namespace detectLimit
* @param {Array|Object} collection
* @param {number} limit - limit >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.detectLimit(array, 2, iterator, function(err, res) {
* console.log(res); // 1
* console.log(order); // [1]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.detectLimit(array, 2, iterator, function(err, res) {
* console.log(res); // 1
* console.log(order); // [[1, 0]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.detectLimit(object, 2, iterator, function(err, res) {
* console.log(res); // 1
* console.log(order); // [1]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.detectLimit(object, 2, iterator, function(err, res) {
* console.log(res); // 1
* console.log(order); // [[1, 'a']]
* });
*
*/
var detectLimit = createDetectLimit(true);
/**
* @memberof async
* @namespace every
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.every(array, iterator, function(err, res) {
* console.log(res); // false
* console.log(order); // [1, 2]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.every(array, iterator, function(err, res) {
* console.log(res); // false
* console.log(order); // [[1, 0], [2, 2]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.every(object, iterator, function(err, res) {
* console.log(res); // false
* console.log(order); // [1, 2]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.every(object, iterator, function(err, res) {
* console.log(res); // false
* console.log(order); // [[1, 'a'], [2, 'c']]
* });
*
*/
var every = createEvery(arrayEachValue, baseEachValue, symbolEachValue);
/**
* @memberof async
* @namespace everySeries
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.everySeries(array, iterator, function(err, res) {
* console.log(res); // false
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.everySeries(array, iterator, function(err, res) {
* console.log(res); // false
* console.log(order); // [[1, 0], [3, 1], [2, 2]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.everySeries(object, iterator, function(err, res) {
* console.log(res); // false
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.everySeries(object, iterator, function(err, res) {
* console.log(res); // false
* console.log(order); // [[1, 'a'], [3, 'b'] [2, 'c']]
* });
*
*/
var everySeries = createEverySeries();
/**
* @memberof async
* @namespace everyLimit
* @param {Array|Object} collection
* @param {number} limit - limit >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.everyLimit(array, 2, iterator, function(err, res) {
* console.log(res); // false
* console.log(order); // [1, 3, 5, 2]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.everyLimit(array, 2, iterator, function(err, res) {
* console.log(res); // false
* console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.everyLimit(object, 2, iterator, function(err, res) {
* console.log(res); // false
* console.log(order); // [1, 3, 5, 2]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.everyLimit(object, 2, iterator, function(err, res) {
* console.log(res); // false
* console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e']]
* });
*
*/
var everyLimit = createEveryLimit();
/**
* @memberof async
* @namespace pick
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2, 4];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.pick(array, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 3 }
* console.log(order); // [1, 2, 3, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2, 4];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.pick(array, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 3 }
* console.log(order); // [[0, 1], [2, 2], [3, 1], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.pick(object, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 3 }
* console.log(order); // [1, 2, 3, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.pick(object, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 3 }
* console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b'], [4, 'd']]
* });
*
*/
var pick = createPick(arrayEachIndexValue, baseEachKeyValue, symbolEachKeyValue, true);
/**
* @memberof async
* @namespace pickSeries
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2, 4];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.pickSeries(array, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 3 }
* console.log(order); // [1, 3, 2, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2, 4];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.pickSeries(array, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 3 }
* console.log(order); // [[0, 1], [3, 1], [2, 2], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.pickSeries(object, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 3 }
* console.log(order); // [1, 3, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.pickSeries(object, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 3 }
* console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c'], [4, 'd']]
* });
*
*/
var pickSeries = createPickSeries(true);
/**
* @memberof async
* @namespace pickLimit
* @param {Array|Object} collection
* @param {number} limit - limit >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.pickLimit(array, 2, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 5, '2': 3 }
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.pickLimit(array, 2, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 5, '2': 3 }
* console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.pickLimit(object, 2, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 5, c: 3 }
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.pickLimit(object, 2, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 5, c: 3 }
* console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
* });
*
*/
var pickLimit = createPickLimit(true);
/**
* @memberof async
* @namespace omit
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2, 4];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.omit(array, iterator, function(err, res) {
* console.log(res); // { '2': 2, '3': 4 }
* console.log(order); // [1, 2, 3, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2, 4];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.omit(array, iterator, function(err, res) {
* console.log(res); // { '2': 2, '3': 4 }
* console.log(order); // [[0, 1], [2, 2], [3, 1], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.omit(object, iterator, function(err, res) {
* console.log(res); // { c: 2, d: 4 }
* console.log(order); // [1, 2, 3, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.omit(object, iterator, function(err, res) {
* console.log(res); // { c: 2, d: 4 }
* console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b'], [4, 'd']]
* });
*
*/
var omit = createPick(arrayEachIndexValue, baseEachKeyValue, symbolEachKeyValue, false);
/**
* @memberof async
* @namespace omitSeries
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2, 4];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.omitSeries(array, iterator, function(err, res) {
* console.log(res); // { '2': 2, '3': 4 }
* console.log(order); // [1, 3, 2, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2, 4];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.omitSeries(array, iterator, function(err, res) {
* console.log(res); // { '2': 2, '3': 4 }
* console.log(order); // [[0, 1], [3, 1], [2, 2], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.omitSeries(object, iterator, function(err, res) {
* console.log(res); // { c: 2, d: 4 }
* console.log(order); // [1, 3, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.omitSeries(object, iterator, function(err, res) {
* console.log(res); // { c: 2, d: 4 }
* console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c'], [4, 'd']]
* });
*
*/
var omitSeries = createPickSeries(false);
/**
* @memberof async
* @namespace omitLimit
* @param {Array|Object} collection
* @param {number} limit - limit >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.omitLimit(array, 2, iterator, function(err, res) {
* console.log(res); // { '3': 4, '4': 2 }
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.omitLimit(array, 2, iterator, function(err, res) {
* console.log(res); // { '3': 4, '4': 2 }
* console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.omitLimit(object, 2, iterator, function(err, res) {
* console.log(res); // { d: 4, e: 2 }
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.omitLimit(object, 2, iterator, function(err, res) {
* console.log(res); // { d: 4, e: 2 }
* console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
* });
*
*/
var omitLimit = createPickLimit(false);
/**
* @memberof async
* @namespace transform
* @param {Array|Object} collection
* @param {Array|Object|Function} [accumulator]
* @param {Function} [iterator]
* @param {Function} [callback]
* @example
*
* // array
* var order = [];
* var collection = [1, 3, 2, 4];
* var iterator = function(result, num, done) {
* setTimeout(function() {
* order.push(num);
* result.push(num)
* done();
* }, num * 10);
* };
* async.transform(collection, iterator, function(err, res) {
* console.log(res); // [1, 2, 3, 4]
* console.log(order); // [1, 2, 3, 4]
* });
*
* @example
*
* // array with index and accumulator
* var order = [];
* var collection = [1, 3, 2, 4];
* var iterator = function(result, num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* result[index] = num;
* done();
* }, num * 10);
* };
* async.transform(collection, {}, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 3, '2': 2, '3': 4 }
* console.log(order); // [[1, 0], [2, 2], [3, 1], [4, 3]]
* });
*
* @example
*
* // object with accumulator
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(result, num, done) {
* setTimeout(function() {
* order.push(num);
* result.push(num);
* done();
* }, num * 10);
* };
* async.transform(collection, [], iterator, function(err, res) {
* console.log(res); // [1, 2, 3, 4]
* console.log(order); // [1, 2, 3, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(result, num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* result[key] = num;
* done();
* }, num * 10);
* };
* async.transform(collection, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 3, c: 2, d: 4 }
* console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b'], [4, 'd']]
* });
*
*/
var transform = createTransform(arrayEachResult, baseEachResult, symbolEachResult);
/**
* @memberof async
* @namespace sortBy
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.sortBy(array, iterator, function(err, res) {
* console.log(res); // [1, 2, 3];
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num);
* }, num * 10);
* };
* async.sortBy(array, iterator, function(err, res) {
* console.log(res); // [1, 2, 3]
* console.log(order); // [[1, 0], [2, 2], [3, 1]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.sortBy(object, iterator, function(err, res) {
* console.log(res); // [1, 2, 3]
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num);
* }, num * 10);
* };
* async.sortBy(object, iterator, function(err, res) {
* console.log(res); // [1, 2, 3]
* console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
* });
*
*/
var sortBy = createSortBy(arrayEachIndexValue, baseEachIndexValue, symbolEachIndexValue);
/**
* @memberof async
* @namespace concat
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, [num]);
* }, num * 10);
* };
* async.concat(array, iterator, function(err, res) {
* console.log(res); // [1, 2, 3];
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, [num]);
* }, num * 10);
* };
* async.concat(array, iterator, function(err, res) {
* console.log(res); // [1, 2, 3]
* console.log(order); // [[1, 0], [2, 2], [3, 1]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, [num]);
* }, num * 10);
* };
* async.concat(object, iterator, function(err, res) {
* console.log(res); // [1, 2, 3]
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, [num]);
* }, num * 10);
* };
* async.concat(object, iterator, function(err, res) {
* console.log(res); // [1, 2, 3]
* console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
* });
*
*/
var concat = createConcat(arrayEachIndex, baseEachIndex, symbolEachIndex);
/**
* @memberof async
* @namespace groupBy
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [4.2, 6.4, 6.1];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, Math.floor(num));
* }, num * 10);
* };
* async.groupBy(array, iterator, function(err, res) {
* console.log(res); // { '4': [4.2], '6': [6.1, 6.4] }
* console.log(order); // [4.2, 6.1, 6.4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [4.2, 6.4, 6.1];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, Math.floor(num));
* }, num * 10);
* };
* async.groupBy(array, iterator, function(err, res) {
* console.log(res); // { '4': [4.2], '6': [6.1, 6.4] }
* console.log(order); // [[4.2, 0], [6.1, 2], [6.4, 1]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 4.2, b: 6.4, c: 6.1 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, Math.floor(num));
* }, num * 10);
* };
* async.groupBy(object, iterator, function(err, res) {
* console.log(res); // { '4': [4.2], '6': [6.1, 6.4] }
* console.log(order); // [4.2, 6.1, 6.4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 4.2, b: 6.4, c: 6.1 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, Math.floor(num));
* }, num * 10);
* };
* async.groupBy(object, iterator, function(err, res) {
* console.log(res); // { '4': [4.2], '6': [6.1, 6.4] }
* console.log(order); // [[4.2, 'a'], [6.1, 'c'], [6.4, 'b']]
* });
*
*/
var groupBy = createGroupBy(arrayEachValue, baseEachValue, symbolEachValue);
/**
* @memberof async
* @namespace parallel
* @param {Array|Object} tasks - functions
* @param {Function} callback
* @example
*
* var order = [];
* var tasks = [
* function(done) {
* setTimeout(function() {
* order.push(1);
* done(null, 1);
* }, 10);
* },
* function(done) {
* setTimeout(function() {
* order.push(2);
* done(null, 2);
* }, 30);
* },
* function(done) {
* setTimeout(function() {
* order.push(3);
* done(null, 3);
* }, 40);
* },
* function(done) {
* setTimeout(function() {
* order.push(4);
* done(null, 4);
* }, 20);
* }
* ];
* async.parallel(tasks, function(err, res) {
* console.log(res); // [1, 2, 3, 4];
* console.log(order); // [1, 4, 2, 3]
* });
*
* @example
*
* var order = [];
* var tasks = {
* 'a': function(done) {
* setTimeout(function() {
* order.push(1);
* done(null, 1);
* }, 10);
* },
* 'b': function(done) {
* setTimeout(function() {
* order.push(2);
* done(null, 2);
* }, 30);
* },
* 'c': function(done) {
* setTimeout(function() {
* order.push(3);
* done(null, 3);
* }, 40);
* },
* 'd': function(done) {
* setTimeout(function() {
* order.push(4);
* done(null, 4);
* }, 20);
* }
* };
* async.parallel(tasks, function(err, res) {
* console.log(res); // { a: 1, b: 2, c: 3, d:4 }
* console.log(order); // [1, 4, 2, 3]
* });
*
*/
var parallel = createParallel(arrayEachFunc, baseEachFunc);
/**
* @memberof async
* @namespace applyEach
*/
var applyEach = createApplyEach(map);
/**
* @memberof async
* @namespace applyEachSeries
*/
var applyEachSeries = createApplyEach(mapSeries);
/**
* @memberof async
* @namespace log
*/
var log = createLogger('log');
/**
* @memberof async
* @namespace dir
*/
var dir = createLogger('dir');
/**
* @version 2.6.1
* @namespace async
*/
var index = {
VERSION: '2.6.1',
// Collections
each: each,
eachSeries: eachSeries,
eachLimit: eachLimit,
forEach: each,
forEachSeries: eachSeries,
forEachLimit: eachLimit,
eachOf: each,
eachOfSeries: eachSeries,
eachOfLimit: eachLimit,
forEachOf: each,
forEachOfSeries: eachSeries,
forEachOfLimit: eachLimit,
map: map,
mapSeries: mapSeries,
mapLimit: mapLimit,
mapValues: mapValues,
mapValuesSeries: mapValuesSeries,
mapValuesLimit: mapValuesLimit,
filter: filter,
filterSeries: filterSeries,
filterLimit: filterLimit,
select: filter,
selectSeries: filterSeries,
selectLimit: filterLimit,
reject: reject,
rejectSeries: rejectSeries,
rejectLimit: rejectLimit,
detect: detect,
detectSeries: detectSeries,
detectLimit: detectLimit,
find: detect,
findSeries: detectSeries,
findLimit: detectLimit,
pick: pick,
pickSeries: pickSeries,
pickLimit: pickLimit,
omit: omit,
omitSeries: omitSeries,
omitLimit: omitLimit,
reduce: reduce,
inject: reduce,
foldl: reduce,
reduceRight: reduceRight,
foldr: reduceRight,
transform: transform,
transformSeries: transformSeries,
transformLimit: transformLimit,
sortBy: sortBy,
sortBySeries: sortBySeries,
sortByLimit: sortByLimit,
some: some,
someSeries: someSeries,
someLimit: someLimit,
any: some,
anySeries: someSeries,
anyLimit: someLimit,
every: every,
everySeries: everySeries,
everyLimit: everyLimit,
all: every,
allSeries: everySeries,
allLimit: everyLimit,
concat: concat,
concatSeries: concatSeries,
concatLimit: concatLimit,
groupBy: groupBy,
groupBySeries: groupBySeries,
groupByLimit: groupByLimit,
// Control Flow
parallel: parallel,
series: series,
parallelLimit: parallelLimit,
tryEach: tryEach,
waterfall: waterfall,
angelFall: angelFall,
angelfall: angelFall,
whilst: whilst,
doWhilst: doWhilst,
until: until,
doUntil: doUntil,
during: during,
doDuring: doDuring,
forever: forever,
compose: compose,
seq: seq,
applyEach: applyEach,
applyEachSeries: applyEachSeries,
queue: queue,
priorityQueue: priorityQueue,
cargo: cargo,
auto: auto,
autoInject: autoInject,
retry: retry,
retryable: retryable,
iterator: iterator,
times: times,
timesSeries: timesSeries,
timesLimit: timesLimit,
race: race,
// Utils
apply: apply,
nextTick: asyncNextTick,
setImmediate: asyncSetImmediate,
memoize: memoize,
unmemoize: unmemoize,
ensureAsync: ensureAsync,
constant: constant,
asyncify: asyncify,
wrapSync: asyncify,
log: log,
dir: dir,
reflect: reflect,
reflectAll: reflectAll,
timeout: timeout,
createLogger: createLogger,
// Mode
safe: safe,
fast: fast
};
exports['default'] = index;
baseEachSync(
index,
function(func, key) {
exports[key] = func;
},
nativeKeys(index)
);
/**
* @private
*/
function createImmediate(safeMode) {
var delay = function delay(fn) {
var args = slice(arguments, 1);
setTimeout(function() {
fn.apply(null, args);
});
};
asyncSetImmediate = typeof setImmediate === func ? setImmediate : delay;
if (typeof process === obj && typeof process.nextTick === func) {
nextTick = /^v0.10/.test(process.version) ? asyncSetImmediate : process.nextTick;
asyncNextTick = /^v0/.test(process.version) ? asyncSetImmediate : process.nextTick;
} else {
asyncNextTick = nextTick = asyncSetImmediate;
}
if (safeMode === false) {
nextTick = function(cb) {
cb();
};
}
}
/* sync functions based on lodash */
/**
* Converts `arguments` to an array.
*
* @private
* @param {Array} array = The array to slice.
*/
function createArray(array) {
var index = -1;
var size = array.length;
var result = Array(size);
while (++index < size) {
result[index] = array[index];
}
return result;
}
/**
* Create an array from `start`
*
* @private
* @param {Array} array - The array to slice.
* @param {number} start - The start position.
*/
function slice(array, start) {
var end = array.length;
var index = -1;
var size = end - start;
if (size <= 0) {
return [];
}
var result = Array(size);
while (++index < size) {
result[index] = array[index + start];
}
return result;
}
/**
* @private
* @param {Object} object
*/
function objectClone(object) {
var keys = nativeKeys(object);
var size = keys.length;
var index = -1;
var result = {};
while (++index < size) {
var key = keys[index];
result[key] = object[key];
}
return result;
}
/**
* Create an array with all falsey values removed.
*
* @private
* @param {Array} array - The array to compact.
*/
function compact(array) {
var index = -1;
var size = array.length;
var result = [];
while (++index < size) {
var value = array[index];
if (value) {
result[result.length] = value;
}
}
return result;
}
/**
* Create an array of reverse sequence.
*
* @private
* @param {Array} array - The array to reverse.
*/
function reverse(array) {
var index = -1;
var size = array.length;
var result = Array(size);
var resIndex = size;
while (++index < size) {
result[--resIndex] = array[index];
}
return result;
}
/**
* Checks if key exists in object property.
*
* @private
* @param {Object} object - The object to inspect.
* @param {string} key - The key to check.
*/
function has(object, key) {
return object.hasOwnProperty(key);
}
/**
* Check if target exists in array.
* @private
* @param {Array} array
* @param {*} target
*/
function notInclude(array, target) {
var index = -1;
var size = array.length;
while (++index < size) {
if (array[index] === target) {
return false;
}
}
return true;
}
/**
* @private
* @param {Array} array - The array to iterate over.
* @param {Function} iterator - The function invoked per iteration.
*/
function arrayEachSync(array, iterator) {
var index = -1;
var size = array.length;
while (++index < size) {
iterator(array[index], index);
}
return array;
}
/**
* @private
* @param {Object} object - The object to iterate over.
* @param {Function} iterator - The function invoked per iteration.
* @param {Array} keys
*/
function baseEachSync(object, iterator, keys) {
var index = -1;
var size = keys.length;
while (++index < size) {
var key = keys[index];
iterator(object[key], key);
}
return object;
}
/**
* @private
* @param {number} n
* @param {Function} iterator
*/
function timesSync(n, iterator) {
var index = -1;
while (++index < n) {
iterator(index);
}
}
/**
* @private
* @param {Array} array
* @param {number[]} criteria
*/
function sortByCriteria(array, criteria) {
var l = array.length;
var indices = Array(l);
var i;
for (i = 0; i < l; i++) {
indices[i] = i;
}
quickSort(criteria, 0, l - 1, indices);
var result = Array(l);
for (var n = 0; n < l; n++) {
i = indices[n];
result[n] = i === undefined ? array[n] : array[i];
}
return result;
}
function partition(array, i, j, mid, indices) {
var l = i;
var r = j;
while (l <= r) {
i = l;
while (l < r && array[l] < mid) {
l++;
}
while (r >= i && array[r] >= mid) {
r--;
}
if (l > r) {
break;
}
swap(array, indices, l++, r--);
}
return l;
}
function swap(array, indices, l, r) {
var n = array[l];
array[l] = array[r];
array[r] = n;
var i = indices[l];
indices[l] = indices[r];
indices[r] = i;
}
function quickSort(array, i, j, indices) {
if (i === j) {
return;
}
var k = i;
while (++k <= j && array[i] === array[k]) {
var l = k - 1;
if (indices[l] > indices[k]) {
var index = indices[l];
indices[l] = indices[k];
indices[k] = index;
}
}
if (k > j) {
return;
}
var p = array[i] > array[k] ? i : k;
k = partition(array, i, j, array[p], indices);
quickSort(array, i, k - 1, indices);
quickSort(array, k, j, indices);
}
/**
* @Private
*/
function makeConcatResult(array) {
var result = [];
arrayEachSync(array, function(value) {
if (value === noop) {
return;
}
if (isArray(value)) {
nativePush.apply(result, value);
} else {
result.push(value);
}
});
return result;
}
/* async functions */
/**
* @private
*/
function arrayEach(array, iterator, callback) {
var index = -1;
var size = array.length;
if (iterator.length === 3) {
while (++index < size) {
iterator(array[index], index, onlyOnce(callback));
}
} else {
while (++index < size) {
iterator(array[index], onlyOnce(callback));
}
}
}
/**
* @private
*/
function baseEach(object, iterator, callback, keys) {
var key;
var index = -1;
var size = keys.length;
if (iterator.length === 3) {
while (++index < size) {
key = keys[index];
iterator(object[key], key, onlyOnce(callback));
}
} else {
while (++index < size) {
iterator(object[keys[index]], onlyOnce(callback));
}
}
}
/**
* @private
*/
function symbolEach(collection, iterator, callback) {
var iter = collection[iteratorSymbol]();
var index = 0;
var item;
if (iterator.length === 3) {
while ((item = iter.next()).done === false) {
iterator(item.value, index++, onlyOnce(callback));
}
} else {
while ((item = iter.next()).done === false) {
index++;
iterator(item.value, onlyOnce(callback));
}
}
return index;
}
/**
* @private
*/
function arrayEachResult(array, result, iterator, callback) {
var index = -1;
var size = array.length;
if (iterator.length === 4) {
while (++index < size) {
iterator(result, array[index], index, onlyOnce(callback));
}
} else {
while (++index < size) {
iterator(result, array[index], onlyOnce(callback));
}
}
}
/**
* @private
*/
function baseEachResult(object, result, iterator, callback, keys) {
var key;
var index = -1;
var size = keys.length;
if (iterator.length === 4) {
while (++index < size) {
key = keys[index];
iterator(result, object[key], key, onlyOnce(callback));
}
} else {
while (++index < size) {
iterator(result, object[keys[index]], onlyOnce(callback));
}
}
}
/**
* @private
*/
function symbolEachResult(collection, result, iterator, callback) {
var item;
var index = 0;
var iter = collection[iteratorSymbol]();
if (iterator.length === 4) {
while ((item = iter.next()).done === false) {
iterator(result, item.value, index++, onlyOnce(callback));
}
} else {
while ((item = iter.next()).done === false) {
index++;
iterator(result, item.value, onlyOnce(callback));
}
}
return index;
}
/**
* @private
*/
function arrayEachFunc(array, createCallback) {
var index = -1;
var size = array.length;
while (++index < size) {
array[index](createCallback(index));
}
}
/**
* @private
*/
function baseEachFunc(object, createCallback, keys) {
var key;
var index = -1;
var size = keys.length;
while (++index < size) {
key = keys[index];
object[key](createCallback(key));
}
}
/**
* @private
*/
function arrayEachIndex(array, iterator, createCallback) {
var index = -1;
var size = array.length;
if (iterator.length === 3) {
while (++index < size) {
iterator(array[index], index, createCallback(index));
}
} else {
while (++index < size) {
iterator(array[index], createCallback(index));
}
}
}
/**
* @private
*/
function baseEachIndex(object, iterator, createCallback, keys) {
var key;
var index = -1;
var size = keys.length;
if (iterator.length === 3) {
while (++index < size) {
key = keys[index];
iterator(object[key], key, createCallback(index));
}
} else {
while (++index < size) {
iterator(object[keys[index]], createCallback(index));
}
}
}
/**
* @private
*/
function symbolEachIndex(collection, iterator, createCallback) {
var item;
var index = 0;
var iter = collection[iteratorSymbol]();
if (iterator.length === 3) {
while ((item = iter.next()).done === false) {
iterator(item.value, index, createCallback(index++));
}
} else {
while ((item = iter.next()).done === false) {
iterator(item.value, createCallback(index++));
}
}
return index;
}
/**
* @private
*/
function baseEachKey(object, iterator, createCallback, keys) {
var key;
var index = -1;
var size = keys.length;
if (iterator.length === 3) {
while (++index < size) {
key = keys[index];
iterator(object[key], key, createCallback(key));
}
} else {
while (++index < size) {
key = keys[index];
iterator(object[key], createCallback(key));
}
}
}
/**
* @private
*/
function symbolEachKey(collection, iterator, createCallback) {
var item;
var index = 0;
var iter = collection[iteratorSymbol]();
if (iterator.length === 3) {
while ((item = iter.next()).done === false) {
iterator(item.value, index, createCallback(index++));
}
} else {
while ((item = iter.next()).done === false) {
iterator(item.value, createCallback(index++));
}
}
return index;
}
/**
* @private
*/
function arrayEachValue(array, iterator, createCallback) {
var value;
var index = -1;
var size = array.length;
if (iterator.length === 3) {
while (++index < size) {
value = array[index];
iterator(value, index, createCallback(value));
}
} else {
while (++index < size) {
value = array[index];
iterator(value, createCallback(value));
}
}
}
/**
* @private
*/
function baseEachValue(object, iterator, createCallback, keys) {
var key, value;
var index = -1;
var size = keys.length;
if (iterator.length === 3) {
while (++index < size) {
key = keys[index];
value = object[key];
iterator(value, key, createCallback(value));
}
} else {
while (++index < size) {
value = object[keys[index]];
iterator(value, createCallback(value));
}
}
}
/**
* @private
*/
function symbolEachValue(collection, iterator, createCallback) {
var value, item;
var index = 0;
var iter = collection[iteratorSymbol]();
if (iterator.length === 3) {
while ((item = iter.next()).done === false) {
value = item.value;
iterator(value, index++, createCallback(value));
}
} else {
while ((item = iter.next()).done === false) {
index++;
value = item.value;
iterator(value, createCallback(value));
}
}
return index;
}
/**
* @private
*/
function arrayEachIndexValue(array, iterator, createCallback) {
var value;
var index = -1;
var size = array.length;
if (iterator.length === 3) {
while (++index < size) {
value = array[index];
iterator(value, index, createCallback(index, value));
}
} else {
while (++index < size) {
value = array[index];
iterator(value, createCallback(index, value));
}
}
}
/**
* @private
*/
function baseEachIndexValue(object, iterator, createCallback, keys) {
var key, value;
var index = -1;
var size = keys.length;
if (iterator.length === 3) {
while (++index < size) {
key = keys[index];
value = object[key];
iterator(value, key, createCallback(index, value));
}
} else {
while (++index < size) {
value = object[keys[index]];
iterator(value, createCallback(index, value));
}
}
}
/**
* @private
*/
function symbolEachIndexValue(collection, iterator, createCallback) {
var value, item;
var index = 0;
var iter = collection[iteratorSymbol]();
if (iterator.length === 3) {
while ((item = iter.next()).done === false) {
value = item.value;
iterator(value, index, createCallback(index++, value));
}
} else {
while ((item = iter.next()).done === false) {
value = item.value;
iterator(value, createCallback(index++, value));
}
}
return index;
}
/**
* @private
*/
function baseEachKeyValue(object, iterator, createCallback, keys) {
var key, value;
var index = -1;
var size = keys.length;
if (iterator.length === 3) {
while (++index < size) {
key = keys[index];
value = object[key];
iterator(value, key, createCallback(key, value));
}
} else {
while (++index < size) {
key = keys[index];
value = object[key];
iterator(value, createCallback(key, value));
}
}
}
/**
* @private
*/
function symbolEachKeyValue(collection, iterator, createCallback) {
var value, item;
var index = 0;
var iter = collection[iteratorSymbol]();
if (iterator.length === 3) {
while ((item = iter.next()).done === false) {
value = item.value;
iterator(value, index, createCallback(index++, value));
}
} else {
while ((item = iter.next()).done === false) {
value = item.value;
iterator(value, createCallback(index++, value));
}
}
return index;
}
/**
* @private
* @param {Function} func
*/
function onlyOnce(func) {
return function(err, res) {
var fn = func;
func = throwError;
fn(err, res);
};
}
/**
* @private
* @param {Function} func
*/
function once(func) {
return function(err, res) {
var fn = func;
func = noop;
fn(err, res);
};
}
/**
* @private
* @param {Function} arrayEach
* @param {Function} baseEach
*/
function createEach(arrayEach, baseEach, symbolEach) {
return function each(collection, iterator, callback) {
callback = once(callback || noop);
var size, keys;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
arrayEach(collection, iterator, done);
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = symbolEach(collection, iterator, done);
size && size === completed && callback(null);
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
baseEach(collection, iterator, done, keys);
}
if (!size) {
callback(null);
}
function done(err, bool) {
if (err) {
callback = once(callback);
callback(err);
} else if (++completed === size) {
callback(null);
} else if (bool === false) {
callback = once(callback);
callback(null);
}
}
};
}
/**
* @private
* @param {Function} arrayEach
* @param {Function} baseEach
* @param {Function} symbolEach
*/
function createMap(arrayEach, baseEach, symbolEach, useArray) {
var init, clone;
if (useArray) {
init = Array;
clone = createArray;
} else {
init = function() {
return {};
};
clone = objectClone;
}
return function(collection, iterator, callback) {
callback = callback || noop;
var size, keys, result;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
result = init(size);
arrayEach(collection, iterator, createCallback);
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
// TODO: size could be changed
result = init(0);
size = symbolEach(collection, iterator, createCallback);
size && size === completed && callback(null, result);
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
result = init(size);
baseEach(collection, iterator, createCallback, keys);
}
if (!size) {
callback(null, init());
}
function createCallback(key) {
return function done(err, res) {
if (key === null) {
throwError();
}
if (err) {
key = null;
callback = once(callback);
callback(err, clone(result));
return;
}
result[key] = res;
key = null;
if (++completed === size) {
callback(null, result);
}
};
}
};
}
/**
* @private
* @param {Function} arrayEach
* @param {Function} baseEach
* @param {Function} symbolEach
* @param {boolean} bool
*/
function createFilter(arrayEach, baseEach, symbolEach, bool) {
return function(collection, iterator, callback) {
callback = callback || noop;
var size, keys, result;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
result = Array(size);
arrayEach(collection, iterator, createCallback);
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
result = [];
size = symbolEach(collection, iterator, createCallback);
size && size === completed && callback(null, compact(result));
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
result = Array(size);
baseEach(collection, iterator, createCallback, keys);
}
if (!size) {
return callback(null, []);
}
function createCallback(index, value) {
return function done(err, res) {
if (index === null) {
throwError();
}
if (err) {
index = null;
callback = once(callback);
callback(err);
return;
}
if (!!res === bool) {
result[index] = value;
}
index = null;
if (++completed === size) {
callback(null, compact(result));
}
};
}
};
}
/**
* @private
* @param {boolean} bool
*/
function createFilterSeries(bool) {
return function(collection, iterator, callback) {
callback = onlyOnce(callback || noop);
var size, key, value, keys, iter, item, iterate;
var sync = false;
var completed = 0;
var result = [];
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size) {
return callback(null, []);
}
iterate();
function arrayIterator() {
value = collection[completed];
iterator(value, done);
}
function arrayIteratorWithIndex() {
value = collection[completed];
iterator(value, completed, done);
}
function symbolIterator() {
item = iter.next();
value = item.value;
item.done ? callback(null, result) : iterator(value, done);
}
function symbolIteratorWithKey() {
item = iter.next();
value = item.value;
item.done ? callback(null, result) : iterator(value, completed, done);
}
function objectIterator() {
key = keys[completed];
value = collection[key];
iterator(value, done);
}
function objectIteratorWithKey() {
key = keys[completed];
value = collection[key];
iterator(value, key, done);
}
function done(err, res) {
if (err) {
callback(err);
return;
}
if (!!res === bool) {
result[result.length] = value;
}
if (++completed === size) {
iterate = throwError;
callback(null, result);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
};
}
/**
* @private
* @param {boolean} bool
*/
function createFilterLimit(bool) {
return function(collection, limit, iterator, callback) {
callback = callback || noop;
var size, index, key, value, keys, iter, item, iterate, result;
var sync = false;
var started = 0;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
result = [];
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size || isNaN(limit) || limit < 1) {
return callback(null, []);
}
result = result || Array(size);
timesSync(limit > size ? size : limit, iterate);
function arrayIterator() {
index = started++;
if (index < size) {
value = collection[index];
iterator(value, createCallback(value, index));
}
}
function arrayIteratorWithIndex() {
index = started++;
if (index < size) {
value = collection[index];
iterator(value, index, createCallback(value, index));
}
}
function symbolIterator() {
item = iter.next();
if (item.done === false) {
value = item.value;
iterator(value, createCallback(value, started++));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, compact(result));
}
}
function symbolIteratorWithKey() {
item = iter.next();
if (item.done === false) {
value = item.value;
iterator(value, started, createCallback(value, started++));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, compact(result));
}
}
function objectIterator() {
index = started++;
if (index < size) {
value = collection[keys[index]];
iterator(value, createCallback(value, index));
}
}
function objectIteratorWithKey() {
index = started++;
if (index < size) {
key = keys[index];
value = collection[key];
iterator(value, key, createCallback(value, index));
}
}
function createCallback(value, index) {
return function(err, res) {
if (index === null) {
throwError();
}
if (err) {
index = null;
iterate = noop;
callback = once(callback);
callback(err);
return;
}
if (!!res === bool) {
result[index] = value;
}
index = null;
if (++completed === size) {
callback = onlyOnce(callback);
callback(null, compact(result));
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
};
}
};
}
/**
* @memberof async
* @namespace eachSeries
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done();
* }, num * 10);
* };
* async.eachSeries(array, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done();
* }, num * 10);
* };
* async.eachSeries(array, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [[1, 0], [3, 1], [2, 2]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done();
* }, num * 10);
* };
* async.eachSeries(object, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done();
* }, num * 10);
* };
* async.eachSeries(object, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [[1, 'a'], [3, 'b'], [2, 'b']]
* });
*
* @example
*
* // break
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num !== 3);
* }, num * 10);
* };
* async.eachSeries(array, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [1, 3]
* });
*/
function eachSeries(collection, iterator, callback) {
callback = onlyOnce(callback || noop);
var size, key, keys, iter, item, iterate;
var sync = false;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size) {
return callback(null);
}
iterate();
function arrayIterator() {
iterator(collection[completed], done);
}
function arrayIteratorWithIndex() {
iterator(collection[completed], completed, done);
}
function symbolIterator() {
item = iter.next();
item.done ? callback(null) : iterator(item.value, done);
}
function symbolIteratorWithKey() {
item = iter.next();
item.done ? callback(null) : iterator(item.value, completed, done);
}
function objectIterator() {
iterator(collection[keys[completed]], done);
}
function objectIteratorWithKey() {
key = keys[completed];
iterator(collection[key], key, done);
}
function done(err, bool) {
if (err) {
callback(err);
} else if (++completed === size || bool === false) {
iterate = throwError;
callback(null);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* @memberof async
* @namespace eachLimit
* @param {Array|Object} collection
* @param {number} limit - limit >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done();
* }, num * 10);
* };
* async.eachLimit(array, 2, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done();
* }, num * 10);
* };
* async.eachLimit(array, 2, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done();
* }, num * 10);
* };
* async.eachLimit(object, 2, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done();
* }, num * 10);
* };
* async.eachLimit(object, 2, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
* });
*
* @example
*
* // break
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num !== 5);
* }, num * 10);
* };
* async.eachLimit(array, 2, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [1, 3, 5]
* });
*
*/
function eachLimit(collection, limit, iterator, callback) {
callback = callback || noop;
var size, index, key, keys, iter, item, iterate;
var sync = false;
var started = 0;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
} else {
return callback(null);
}
if (!size || isNaN(limit) || limit < 1) {
return callback(null);
}
timesSync(limit > size ? size : limit, iterate);
function arrayIterator() {
if (started < size) {
iterator(collection[started++], done);
}
}
function arrayIteratorWithIndex() {
index = started++;
if (index < size) {
iterator(collection[index], index, done);
}
}
function symbolIterator() {
item = iter.next();
if (item.done === false) {
started++;
iterator(item.value, done);
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null);
}
}
function symbolIteratorWithKey() {
item = iter.next();
if (item.done === false) {
iterator(item.value, started++, done);
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null);
}
}
function objectIterator() {
if (started < size) {
iterator(collection[keys[started++]], done);
}
}
function objectIteratorWithKey() {
index = started++;
if (index < size) {
key = keys[index];
iterator(collection[key], key, done);
}
}
function done(err, bool) {
if (err || bool === false) {
iterate = noop;
callback = once(callback);
callback(err);
} else if (++completed === size) {
iterator = noop;
iterate = throwError;
callback = onlyOnce(callback);
callback(null);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* @memberof async
* @namespace mapSeries
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.mapSeries(array, iterator, function(err, res) {
* console.log(res); // [1, 3, 2];
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num);
* }, num * 10);
* };
* async.mapSeries(array, iterator, function(err, res) {
* console.log(res); // [1, 3, 2]
* console.log(order); // [[1, 0], [3, 1], [2, 2]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.mapSeries(object, iterator, function(err, res) {
* console.log(res); // [1, 3, 2]
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num);
* }, num * 10);
* };
* async.mapSeries(object, iterator, function(err, res) {
* console.log(res); // [1, 3, 2]
* console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]
* });
*
*/
function mapSeries(collection, iterator, callback) {
callback = callback || noop;
var size, key, keys, iter, item, result, iterate;
var sync = false;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
result = [];
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size) {
return callback(null, []);
}
result = result || Array(size);
iterate();
function arrayIterator() {
iterator(collection[completed], done);
}
function arrayIteratorWithIndex() {
iterator(collection[completed], completed, done);
}
function symbolIterator() {
item = iter.next();
item.done ? callback(null, result) : iterator(item.value, done);
}
function symbolIteratorWithKey() {
item = iter.next();
item.done ? callback(null, result) : iterator(item.value, completed, done);
}
function objectIterator() {
iterator(collection[keys[completed]], done);
}
function objectIteratorWithKey() {
key = keys[completed];
iterator(collection[key], key, done);
}
function done(err, res) {
if (err) {
iterate = throwError;
callback = onlyOnce(callback);
callback(err, createArray(result));
return;
}
result[completed] = res;
if (++completed === size) {
iterate = throwError;
callback(null, result);
callback = throwError;
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* @memberof async
* @namespace mapLimit
* @param {Array|Object} collection
* @param {number} limit - limit >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.mapLimit(array, 2, iterator, function(err, res) {
* console.log(res); // [1, 5, 3, 4, 2]
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num);
* }, num * 10);
* };
* async.mapLimit(array, 2, iterator, function(err, res) {
* console.log(res); // [1, 5, 3, 4, 2]
* console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.mapLimit(object, 2, iterator, function(err, res) {
* console.log(res); // [1, 5, 3, 4, 2]
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num);
* }, num * 10);
* };
* async.mapLimit(object, 2, iterator, function(err, res) {
* console.log(res); // [1, 5, 3, 4, 2]
* console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
* });
*
*/
function mapLimit(collection, limit, iterator, callback) {
callback = callback || noop;
var size, index, key, keys, iter, item, result, iterate;
var sync = false;
var started = 0;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
result = [];
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size || isNaN(limit) || limit < 1) {
return callback(null, []);
}
result = result || Array(size);
timesSync(limit > size ? size : limit, iterate);
function arrayIterator() {
index = started++;
if (index < size) {
iterator(collection[index], createCallback(index));
}
}
function arrayIteratorWithIndex() {
index = started++;
if (index < size) {
iterator(collection[index], index, createCallback(index));
}
}
function symbolIterator() {
item = iter.next();
if (item.done === false) {
iterator(item.value, createCallback(started++));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, result);
}
}
function symbolIteratorWithKey() {
item = iter.next();
if (item.done === false) {
iterator(item.value, started, createCallback(started++));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, result);
}
}
function objectIterator() {
index = started++;
if (index < size) {
iterator(collection[keys[index]], createCallback(index));
}
}
function objectIteratorWithKey() {
index = started++;
if (index < size) {
key = keys[index];
iterator(collection[key], key, createCallback(index));
}
}
function createCallback(index) {
return function(err, res) {
if (index === null) {
throwError();
}
if (err) {
index = null;
iterate = noop;
callback = once(callback);
callback(err, createArray(result));
return;
}
result[index] = res;
index = null;
if (++completed === size) {
iterate = throwError;
callback(null, result);
callback = throwError;
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
};
}
}
/**
* @memberof async
* @namespace mapValuesSeries
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.mapValuesSeries(array, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 3, '2': 2 }
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num);
* }, num * 10);
* };
* async.mapValuesSeries(array, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 3, '2': 2 }
* console.log(order); // [[1, 0], [3, 1], [2, 2]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.mapValuesSeries(object, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 3, c: 2 }
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num);
* }, num * 10);
* };
* async.mapValuesSeries(object, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 3, c: 2 }
* console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]
* });
*
*/
function mapValuesSeries(collection, iterator, callback) {
callback = callback || noop;
var size, key, keys, iter, item, iterate;
var sync = false;
var result = {};
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size) {
return callback(null, result);
}
iterate();
function arrayIterator() {
key = completed;
iterator(collection[completed], done);
}
function arrayIteratorWithIndex() {
key = completed;
iterator(collection[completed], completed, done);
}
function symbolIterator() {
key = completed;
item = iter.next();
item.done ? callback(null, result) : iterator(item.value, done);
}
function symbolIteratorWithKey() {
key = completed;
item = iter.next();
item.done ? callback(null, result) : iterator(item.value, completed, done);
}
function objectIterator() {
key = keys[completed];
iterator(collection[key], done);
}
function objectIteratorWithKey() {
key = keys[completed];
iterator(collection[key], key, done);
}
function done(err, res) {
if (err) {
iterate = throwError;
callback = onlyOnce(callback);
callback(err, objectClone(result));
return;
}
result[key] = res;
if (++completed === size) {
iterate = throwError;
callback(null, result);
callback = throwError;
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* @memberof async
* @namespace mapValuesLimit
* @param {Array|Object} collection
* @param {number} limit - limit >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.mapValuesLimit(array, 2, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 5, '2': 3, '3': 4, '4': 2 }
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num);
* }, num * 10);
* };
* async.mapValuesLimit(array, 2, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 5, '2': 3, '3': 4, '4': 2 }
* console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.mapValuesLimit(object, 2, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 5, c: 3, d: 4, e: 2 }
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num);
* }, num * 10);
* };
* async.mapValuesLimit(object, 2, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 5, c: 3, d: 4, e: 2 }
* console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
* });
*
*/
function mapValuesLimit(collection, limit, iterator, callback) {
callback = callback || noop;
var size, index, key, keys, iter, item, iterate;
var sync = false;
var result = {};
var started = 0;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size || isNaN(limit) || limit < 1) {
return callback(null, result);
}
timesSync(limit > size ? size : limit, iterate);
function arrayIterator() {
index = started++;
if (index < size) {
iterator(collection[index], createCallback(index));
}
}
function arrayIteratorWithIndex() {
index = started++;
if (index < size) {
iterator(collection[index], index, createCallback(index));
}
}
function symbolIterator() {
item = iter.next();
if (item.done === false) {
iterator(item.value, createCallback(started++));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, result);
}
}
function symbolIteratorWithKey() {
item = iter.next();
if (item.done === false) {
iterator(item.value, started, createCallback(started++));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, result);
}
}
function objectIterator() {
index = started++;
if (index < size) {
key = keys[index];
iterator(collection[key], createCallback(key));
}
}
function objectIteratorWithKey() {
index = started++;
if (index < size) {
key = keys[index];
iterator(collection[key], key, createCallback(key));
}
}
function createCallback(key) {
return function(err, res) {
if (key === null) {
throwError();
}
if (err) {
key = null;
iterate = noop;
callback = once(callback);
callback(err, objectClone(result));
return;
}
result[key] = res;
key = null;
if (++completed === size) {
callback(null, result);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
};
}
}
/**
* @private
* @param {Function} arrayEach
* @param {Function} baseEach
* @param {Function} symbolEach
* @param {boolean} bool
*/
function createDetect(arrayEach, baseEach, symbolEach, bool) {
return function(collection, iterator, callback) {
callback = callback || noop;
var size, keys;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
arrayEach(collection, iterator, createCallback);
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = symbolEach(collection, iterator, createCallback);
size && size === completed && callback(null);
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
baseEach(collection, iterator, createCallback, keys);
}
if (!size) {
callback(null);
}
function createCallback(value) {
var called = false;
return function done(err, res) {
if (called) {
throwError();
}
called = true;
if (err) {
callback = once(callback);
callback(err);
} else if (!!res === bool) {
callback = once(callback);
callback(null, value);
} else if (++completed === size) {
callback(null);
}
};
}
};
}
/**
* @private
* @param {boolean} bool
*/
function createDetectSeries(bool) {
return function(collection, iterator, callback) {
callback = onlyOnce(callback || noop);
var size, key, value, keys, iter, item, iterate;
var sync = false;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size) {
return callback(null);
}
iterate();
function arrayIterator() {
value = collection[completed];
iterator(value, done);
}
function arrayIteratorWithIndex() {
value = collection[completed];
iterator(value, completed, done);
}
function symbolIterator() {
item = iter.next();
value = item.value;
item.done ? callback(null) : iterator(value, done);
}
function symbolIteratorWithKey() {
item = iter.next();
value = item.value;
item.done ? callback(null) : iterator(value, completed, done);
}
function objectIterator() {
value = collection[keys[completed]];
iterator(value, done);
}
function objectIteratorWithKey() {
key = keys[completed];
value = collection[key];
iterator(value, key, done);
}
function done(err, res) {
if (err) {
callback(err);
} else if (!!res === bool) {
iterate = throwError;
callback(null, value);
} else if (++completed === size) {
iterate = throwError;
callback(null);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
};
}
/**
* @private
* @param {boolean} bool
*/
function createDetectLimit(bool) {
return function(collection, limit, iterator, callback) {
callback = callback || noop;
var size, index, key, value, keys, iter, item, iterate;
var sync = false;
var started = 0;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size || isNaN(limit) || limit < 1) {
return callback(null);
}
timesSync(limit > size ? size : limit, iterate);
function arrayIterator() {
index = started++;
if (index < size) {
value = collection[index];
iterator(value, createCallback(value));
}
}
function arrayIteratorWithIndex() {
index = started++;
if (index < size) {
value = collection[index];
iterator(value, index, createCallback(value));
}
}
function symbolIterator() {
item = iter.next();
if (item.done === false) {
started++;
value = item.value;
iterator(value, createCallback(value));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null);
}
}
function symbolIteratorWithKey() {
item = iter.next();
if (item.done === false) {
value = item.value;
iterator(value, started++, createCallback(value));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null);
}
}
function objectIterator() {
index = started++;
if (index < size) {
value = collection[keys[index]];
iterator(value, createCallback(value));
}
}
function objectIteratorWithKey() {
if (started < size) {
key = keys[started++];
value = collection[key];
iterator(value, key, createCallback(value));
}
}
function createCallback(value) {
var called = false;
return function(err, res) {
if (called) {
throwError();
}
called = true;
if (err) {
iterate = noop;
callback = once(callback);
callback(err);
} else if (!!res === bool) {
iterate = noop;
callback = once(callback);
callback(null, value);
} else if (++completed === size) {
callback(null);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
};
}
};
}
/**
* @private
* @param {Function} arrayEach
* @param {Function} baseEach
* @param {Function} symbolEach
* @param {boolean} bool
*/
function createPick(arrayEach, baseEach, symbolEach, bool) {
return function(collection, iterator, callback) {
callback = callback || noop;
var size, keys;
var completed = 0;
var result = {};
if (isArray(collection)) {
size = collection.length;
arrayEach(collection, iterator, createCallback);
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = symbolEach(collection, iterator, createCallback);
size && size === completed && callback(null, result);
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
baseEach(collection, iterator, createCallback, keys);
}
if (!size) {
return callback(null, {});
}
function createCallback(key, value) {
return function done(err, res) {
if (key === null) {
throwError();
}
if (err) {
key = null;
callback = once(callback);
callback(err, objectClone(result));
return;
}
if (!!res === bool) {
result[key] = value;
}
key = null;
if (++completed === size) {
callback(null, result);
}
};
}
};
}
/**
* @private
* @param {boolean} bool
*/
function createPickSeries(bool) {
return function(collection, iterator, callback) {
callback = onlyOnce(callback || noop);
var size, key, value, keys, iter, item, iterate;
var sync = false;
var result = {};
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size) {
return callback(null, {});
}
iterate();
function arrayIterator() {
key = completed;
value = collection[completed];
iterator(value, done);
}
function arrayIteratorWithIndex() {
key = completed;
value = collection[completed];
iterator(value, completed, done);
}
function symbolIterator() {
key = completed;
item = iter.next();
value = item.value;
item.done ? callback(null, result) : iterator(value, done);
}
function symbolIteratorWithKey() {
key = completed;
item = iter.next();
value = item.value;
item.done ? callback(null, result) : iterator(value, key, done);
}
function objectIterator() {
key = keys[completed];
value = collection[key];
iterator(value, done);
}
function objectIteratorWithKey() {
key = keys[completed];
value = collection[key];
iterator(value, key, done);
}
function done(err, res) {
if (err) {
callback(err, result);
return;
}
if (!!res === bool) {
result[key] = value;
}
if (++completed === size) {
iterate = throwError;
callback(null, result);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
};
}
/**
* @private
* @param {boolean} bool
*/
function createPickLimit(bool) {
return function(collection, limit, iterator, callback) {
callback = callback || noop;
var size, index, key, value, keys, iter, item, iterate;
var sync = false;
var result = {};
var started = 0;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size || isNaN(limit) || limit < 1) {
return callback(null, {});
}
timesSync(limit > size ? size : limit, iterate);
function arrayIterator() {
index = started++;
if (index < size) {
value = collection[index];
iterator(value, createCallback(value, index));
}
}
function arrayIteratorWithIndex() {
index = started++;
if (index < size) {
value = collection[index];
iterator(value, index, createCallback(value, index));
}
}
function symbolIterator() {
item = iter.next();
if (item.done === false) {
value = item.value;
iterator(value, createCallback(value, started++));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, result);
}
}
function symbolIteratorWithKey() {
item = iter.next();
if (item.done === false) {
value = item.value;
iterator(value, started, createCallback(value, started++));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, result);
}
}
function objectIterator() {
if (started < size) {
key = keys[started++];
value = collection[key];
iterator(value, createCallback(value, key));
}
}
function objectIteratorWithKey() {
if (started < size) {
key = keys[started++];
value = collection[key];
iterator(value, key, createCallback(value, key));
}
}
function createCallback(value, key) {
return function(err, res) {
if (key === null) {
throwError();
}
if (err) {
key = null;
iterate = noop;
callback = once(callback);
callback(err, objectClone(result));
return;
}
if (!!res === bool) {
result[key] = value;
}
key = null;
if (++completed === size) {
iterate = throwError;
callback = onlyOnce(callback);
callback(null, result);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
};
}
};
}
/**
* @memberof async
* @namespace reduce
* @param {Array|Object} collection
* @param {*} result
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var collection = [1, 3, 2, 4];
* var iterator = function(result, num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, result + num);
* }, num * 10);
* };
* async.reduce(collection, 0, iterator, function(err, res) {
* console.log(res); // 10
* console.log(order); // [1, 3, 2, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var collection = [1, 3, 2, 4];
* var iterator = function(result, num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, result + num);
* }, num * 10);
* };
* async.reduce(collection, '', iterator, function(err, res) {
* console.log(res); // '1324'
* console.log(order); // [[1, 0], [3, 1], [2, 2], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(result, num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, result + num);
* }, num * 10);
* };
* async.reduce(collection, '', iterator, function(err, res) {
* console.log(res); // '1324'
* console.log(order); // [1, 3, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(result, num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, result + num);
* }, num * 10);
* };
* async.reduce(collection, 0, iterator, function(err, res) {
* console.log(res); // 10
* console.log(order); // [[1, 'a'], [3, 'b'], [2, 'b'], [4, 'd']]
* });
*
*/
function reduce(collection, result, iterator, callback) {
callback = onlyOnce(callback || noop);
var size, key, keys, iter, item, iterate;
var sync = false;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
iterate = iterator.length === 4 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 4 ? objectIteratorWithKey : objectIterator;
}
if (!size) {
return callback(null, result);
}
iterate(result);
function arrayIterator(result) {
iterator(result, collection[completed], done);
}
function arrayIteratorWithIndex(result) {
iterator(result, collection[completed], completed, done);
}
function symbolIterator(result) {
item = iter.next();
item.done ? callback(null, result) : iterator(result, item.value, done);
}
function symbolIteratorWithKey(result) {
item = iter.next();
item.done ? callback(null, result) : iterator(result, item.value, completed, done);
}
function objectIterator(result) {
iterator(result, collection[keys[completed]], done);
}
function objectIteratorWithKey(result) {
key = keys[completed];
iterator(result, collection[key], key, done);
}
function done(err, result) {
if (err) {
callback(err, result);
} else if (++completed === size) {
iterator = throwError;
callback(null, result);
} else if (sync) {
nextTick(function() {
iterate(result);
});
} else {
sync = true;
iterate(result);
}
sync = false;
}
}
/**
* @memberof async
* @namespace reduceRight
* @param {Array|Object} collection
* @param {*} result
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var collection = [1, 3, 2, 4];
* var iterator = function(result, num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, result + num);
* }, num * 10);
* };
* async.reduceRight(collection, 0, iterator, function(err, res) {
* console.log(res); // 10
* console.log(order); // [4, 2, 3, 1]
* });
*
* @example
*
* // array with index
* var order = [];
* var collection = [1, 3, 2, 4];
* var iterator = function(result, num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, result + num);
* }, num * 10);
* };
* async.reduceRight(collection, '', iterator, function(err, res) {
* console.log(res); // '4231'
* console.log(order); // [[4, 3], [2, 2], [3, 1], [1, 0]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(result, num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, result + num);
* }, num * 10);
* };
* async.reduceRight(collection, '', iterator, function(err, res) {
* console.log(res); // '4231'
* console.log(order); // [4, 2, 3, 1]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(result, num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, result + num);
* }, num * 10);
* };
* async.reduceRight(collection, 0, iterator, function(err, res) {
* console.log(res); // 10
* console.log(order); // [[4, 3], [2, 2], [3, 1], [1, 0]]
* });
*
*/
function reduceRight(collection, result, iterator, callback) {
callback = onlyOnce(callback || noop);
var resIndex, index, key, keys, iter, item, col, iterate;
var sync = false;
if (isArray(collection)) {
resIndex = collection.length;
iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
col = [];
iter = collection[iteratorSymbol]();
index = -1;
while ((item = iter.next()).done === false) {
col[++index] = item.value;
}
collection = col;
resIndex = col.length;
iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
resIndex = keys.length;
iterate = iterator.length === 4 ? objectIteratorWithKey : objectIterator;
}
if (!resIndex) {
return callback(null, result);
}
iterate(result);
function arrayIterator(result) {
iterator(result, collection[--resIndex], done);
}
function arrayIteratorWithIndex(result) {
iterator(result, collection[--resIndex], resIndex, done);
}
function objectIterator(result) {
iterator(result, collection[keys[--resIndex]], done);
}
function objectIteratorWithKey(result) {
key = keys[--resIndex];
iterator(result, collection[key], key, done);
}
function done(err, result) {
if (err) {
callback(err, result);
} else if (resIndex === 0) {
iterate = throwError;
callback(null, result);
} else if (sync) {
nextTick(function() {
iterate(result);
});
} else {
sync = true;
iterate(result);
}
sync = false;
}
}
/**
* @private
* @param {Function} arrayEach
* @param {Function} baseEach
* @param {Function} symbolEach
*/
function createTransform(arrayEach, baseEach, symbolEach) {
return function transform(collection, accumulator, iterator, callback) {
if (arguments.length === 3) {
callback = iterator;
iterator = accumulator;
accumulator = undefined;
}
callback = callback || noop;
var size, keys, result;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
result = accumulator !== undefined ? accumulator : [];
arrayEach(collection, result, iterator, done);
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
result = accumulator !== undefined ? accumulator : {};
size = symbolEach(collection, result, iterator, done);
size && size === completed && callback(null, result);
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
result = accumulator !== undefined ? accumulator : {};
baseEach(collection, result, iterator, done, keys);
}
if (!size) {
callback(null, accumulator !== undefined ? accumulator : result || {});
}
function done(err, bool) {
if (err) {
callback = once(callback);
callback(err, isArray(result) ? createArray(result) : objectClone(result));
} else if (++completed === size) {
callback(null, result);
} else if (bool === false) {
callback = once(callback);
callback(null, isArray(result) ? createArray(result) : objectClone(result));
}
}
};
}
/**
* @memberof async
* @namespace transformSeries
* @param {Array|Object} collection
* @param {Array|Object|Function} [accumulator]
* @param {Function} [iterator]
* @param {Function} [callback]
* @example
*
* // array
* var order = [];
* var collection = [1, 3, 2, 4];
* var iterator = function(result, num, done) {
* setTimeout(function() {
* order.push(num);
* result.push(num)
* done();
* }, num * 10);
* };
* async.transformSeries(collection, iterator, function(err, res) {
* console.log(res); // [1, 3, 2, 4]
* console.log(order); // [1, 3, 2, 4]
* });
*
* @example
*
* // array with index and accumulator
* var order = [];
* var collection = [1, 3, 2, 4];
* var iterator = function(result, num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* result[index] = num;
* done();
* }, num * 10);
* };
* async.transformSeries(collection, {}, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 3, '2': 2, '3': 4 }
* console.log(order); // [[1, 0], [3, 1], [2, 2], [4, 3]]
* });
*
* @example
*
* // object with accumulator
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(result, num, done) {
* setTimeout(function() {
* order.push(num);
* result.push(num);
* done();
* }, num * 10);
* };
* async.transformSeries(collection, [], iterator, function(err, res) {
* console.log(res); // [1, 3, 2, 4]
* console.log(order); // [1, 3, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(result, num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* result[key] = num;
* done();
* }, num * 10);
* };
* async.transformSeries(collection, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 3, c: 2, d: 4 }
* console.log(order); // [[1, 'a'], [3, 'b'], [2, 'b'], [4, 'd']]
* });
*
*/
function transformSeries(collection, accumulator, iterator, callback) {
if (arguments.length === 3) {
callback = iterator;
iterator = accumulator;
accumulator = undefined;
}
callback = onlyOnce(callback || noop);
var size, key, keys, iter, item, iterate, result;
var sync = false;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
result = accumulator !== undefined ? accumulator : [];
iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
result = accumulator !== undefined ? accumulator : {};
iterate = iterator.length === 4 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
result = accumulator !== undefined ? accumulator : {};
iterate = iterator.length === 4 ? objectIteratorWithKey : objectIterator;
}
if (!size) {
return callback(null, accumulator !== undefined ? accumulator : result || {});
}
iterate();
function arrayIterator() {
iterator(result, collection[completed], done);
}
function arrayIteratorWithIndex() {
iterator(result, collection[completed], completed, done);
}
function symbolIterator() {
item = iter.next();
item.done ? callback(null, result) : iterator(result, item.value, done);
}
function symbolIteratorWithKey() {
item = iter.next();
item.done ? callback(null, result) : iterator(result, item.value, completed, done);
}
function objectIterator() {
iterator(result, collection[keys[completed]], done);
}
function objectIteratorWithKey() {
key = keys[completed];
iterator(result, collection[key], key, done);
}
function done(err, bool) {
if (err) {
callback(err, result);
} else if (++completed === size || bool === false) {
iterate = throwError;
callback(null, result);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* @memberof async
* @namespace transformLimit
* @param {Array|Object} collection
* @param {number} limit - limit >= 1
* @param {Array|Object|Function} [accumulator]
* @param {Function} [iterator]
* @param {Function} [callback]
* @example
*
* // array
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(result, num, done) {
* setTimeout(function() {
* order.push(num);
* result.push(num);
* done();
* }, num * 10);
* };
* async.transformLimit(array, 2, iterator, function(err, res) {
* console.log(res); // [1, 3, 5, 2, 4]
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // array with index and accumulator
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(result, num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* result[index] = key;
* done();
* }, num * 10);
* };
* async.transformLimit(array, 2, {}, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 5, '2': 3, '3': 4, '4': 2 }
* console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
* });
*
* @example
*
* // object with accumulator
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(result, num, done) {
* setTimeout(function() {
* order.push(num);
* result.push(num);
* done();
* }, num * 10);
* };
* async.transformLimit(object, 2, [], iterator, function(err, res) {
* console.log(res); // [1, 3, 5, 2, 4]
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(result, num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* result[key] = num;
* done();
* }, num * 10);
* };
* async.transformLimit(object, 2, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 5, c: 3, d: 4, e: 2 };
* console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
* });
*
*/
function transformLimit(collection, limit, accumulator, iterator, callback) {
if (arguments.length === 4) {
callback = iterator;
iterator = accumulator;
accumulator = undefined;
}
callback = callback || noop;
var size, index, key, keys, iter, item, iterate, result;
var sync = false;
var started = 0;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
result = accumulator !== undefined ? accumulator : [];
iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
result = accumulator !== undefined ? accumulator : {};
iterate = iterator.length === 4 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
result = accumulator !== undefined ? accumulator : {};
iterate = iterator.length === 4 ? objectIteratorWithKey : objectIterator;
}
if (!size || isNaN(limit) || limit < 1) {
return callback(null, accumulator !== undefined ? accumulator : result || {});
}
timesSync(limit > size ? size : limit, iterate);
function arrayIterator() {
index = started++;
if (index < size) {
iterator(result, collection[index], onlyOnce(done));
}
}
function arrayIteratorWithIndex() {
index = started++;
if (index < size) {
iterator(result, collection[index], index, onlyOnce(done));
}
}
function symbolIterator() {
item = iter.next();
if (item.done === false) {
started++;
iterator(result, item.value, onlyOnce(done));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, result);
}
}
function symbolIteratorWithKey() {
item = iter.next();
if (item.done === false) {
iterator(result, item.value, started++, onlyOnce(done));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, result);
}
}
function objectIterator() {
index = started++;
if (index < size) {
iterator(result, collection[keys[index]], onlyOnce(done));
}
}
function objectIteratorWithKey() {
index = started++;
if (index < size) {
key = keys[index];
iterator(result, collection[key], key, onlyOnce(done));
}
}
function done(err, bool) {
if (err || bool === false) {
iterate = noop;
callback(err || null, isArray(result) ? createArray(result) : objectClone(result));
callback = noop;
} else if (++completed === size) {
iterator = noop;
callback(null, result);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* @private
* @param {function} arrayEach
* @param {function} baseEach
* @param {function} symbolEach
*/
function createSortBy(arrayEach, baseEach, symbolEach) {
return function sortBy(collection, iterator, callback) {
callback = callback || noop;
var size, array, criteria;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
array = Array(size);
criteria = Array(size);
arrayEach(collection, iterator, createCallback);
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
array = [];
criteria = [];
size = symbolEach(collection, iterator, createCallback);
size && size === completed && callback(null, sortByCriteria(array, criteria));
} else if (typeof collection === obj) {
var keys = nativeKeys(collection);
size = keys.length;
array = Array(size);
criteria = Array(size);
baseEach(collection, iterator, createCallback, keys);
}
if (!size) {
callback(null, []);
}
function createCallback(index, value) {
var called = false;
array[index] = value;
return function done(err, criterion) {
if (called) {
throwError();
}
called = true;
criteria[index] = criterion;
if (err) {
callback = once(callback);
callback(err);
} else if (++completed === size) {
callback(null, sortByCriteria(array, criteria));
}
};
}
};
}
/**
* @memberof async
* @namespace sortBySeries
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.sortBySeries(array, iterator, function(err, res) {
* console.log(res); // [1, 2, 3];
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num);
* }, num * 10);
* };
* async.sortBySeries(array, iterator, function(err, res) {
* console.log(res); // [1, 2, 3]
* console.log(order); // [[1, 0], [3, 1], [2, 2]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.sortBySeries(object, iterator, function(err, res) {
* console.log(res); // [1, 2, 3]
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num);
* }, num * 10);
* };
* async.sortBySeries(object, iterator, function(err, res) {
* console.log(res); // [1, 2, 3]
* console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]
* });
*
*/
function sortBySeries(collection, iterator, callback) {
callback = onlyOnce(callback || noop);
var size, key, value, keys, iter, item, array, criteria, iterate;
var sync = false;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
array = collection;
criteria = Array(size);
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
array = [];
criteria = [];
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
array = Array(size);
criteria = Array(size);
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size) {
return callback(null, []);
}
iterate();
function arrayIterator() {
value = collection[completed];
iterator(value, done);
}
function arrayIteratorWithIndex() {
value = collection[completed];
iterator(value, completed, done);
}
function symbolIterator() {
item = iter.next();
if (item.done) {
return callback(null, sortByCriteria(array, criteria));
}
value = item.value;
array[completed] = value;
iterator(value, done);
}
function symbolIteratorWithKey() {
item = iter.next();
if (item.done) {
return callback(null, sortByCriteria(array, criteria));
}
value = item.value;
array[completed] = value;
iterator(value, completed, done);
}
function objectIterator() {
value = collection[keys[completed]];
array[completed] = value;
iterator(value, done);
}
function objectIteratorWithKey() {
key = keys[completed];
value = collection[key];
array[completed] = value;
iterator(value, key, done);
}
function done(err, criterion) {
criteria[completed] = criterion;
if (err) {
callback(err);
} else if (++completed === size) {
iterate = throwError;
callback(null, sortByCriteria(array, criteria));
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* @memberof async
* @namespace sortByLimit
* @param {Array|Object} collection
* @param {number} limit - limit >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.sortByLimit(array, 2, iterator, function(err, res) {
* console.log(res); // [1, 2, 3, 4, 5]
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num);
* }, num * 10);
* };
* async.sortByLimit(array, 2, iterator, function(err, res) {
* console.log(res); // [1, 2, 3, 4, 5]
* console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.sortByLimit(object, 2, iterator, function(err, res) {
* console.log(res); // [1, 2, 3, 4, 5]
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num);
* }, num * 10);
* };
* async.sortByLimit(object, 2, iterator, function(err, res) {
* console.log(res); // [1, 2, 3, 4, 5]
* console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
* });
*
*/
function sortByLimit(collection, limit, iterator, callback) {
callback = callback || noop;
var size, index, key, value, array, keys, iter, item, criteria, iterate;
var sync = false;
var started = 0;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
array = collection;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
array = [];
criteria = [];
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
array = Array(size);
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size || isNaN(limit) || limit < 1) {
return callback(null, []);
}
criteria = criteria || Array(size);
timesSync(limit > size ? size : limit, iterate);
function arrayIterator() {
if (started < size) {
value = collection[started];
iterator(value, createCallback(value, started++));
}
}
function arrayIteratorWithIndex() {
index = started++;
if (index < size) {
value = collection[index];
iterator(value, index, createCallback(value, index));
}
}
function symbolIterator() {
item = iter.next();
if (item.done === false) {
value = item.value;
array[started] = value;
iterator(value, createCallback(value, started++));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, sortByCriteria(array, criteria));
}
}
function symbolIteratorWithKey() {
item = iter.next();
if (item.done === false) {
value = item.value;
array[started] = value;
iterator(value, started, createCallback(value, started++));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, sortByCriteria(array, criteria));
}
}
function objectIterator() {
if (started < size) {
value = collection[keys[started]];
array[started] = value;
iterator(value, createCallback(value, started++));
}
}
function objectIteratorWithKey() {
if (started < size) {
key = keys[started];
value = collection[key];
array[started] = value;
iterator(value, key, createCallback(value, started++));
}
}
function createCallback(value, index) {
var called = false;
return function(err, criterion) {
if (called) {
throwError();
}
called = true;
criteria[index] = criterion;
if (err) {
iterate = noop;
callback(err);
callback = noop;
} else if (++completed === size) {
callback(null, sortByCriteria(array, criteria));
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
};
}
}
/**
* @memberof async
* @namespace some
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.some(array, iterator, function(err, res) {
* console.log(res); // true
* console.log(order); // [1]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.some(array, iterator, function(err, res) {
* console.log(res); // true
* console.log(order); // [[1, 0]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.some(object, iterator, function(err, res) {
* console.log(res); // true
* console.log(order); // [1]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.some(object, iterator, function(err, res) {
* console.log(res); // true
* console.log(order); // [[1, 'a']]
* });
*
*/
function some(collection, iterator, callback) {
callback = callback || noop;
detect(collection, iterator, done);
function done(err, res) {
if (err) {
return callback(err);
}
callback(null, !!res);
}
}
/**
* @memberof async
* @namespace someSeries
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.someSeries(array, iterator, function(err, res) {
* console.log(res); // true
* console.log(order); // [1]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.someSeries(array, iterator, function(err, res) {
* console.log(res); // true
* console.log(order); // [[1, 0]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.someSeries(object, iterator, function(err, res) {
* console.log(res); // true
* console.log(order); // [1]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.someSeries(object, iterator, function(err, res) {
* console.log(res); // true
* console.log(order); // [[1, 'a']]
* });
*
*/
function someSeries(collection, iterator, callback) {
callback = callback || noop;
detectSeries(collection, iterator, done);
function done(err, res) {
if (err) {
return callback(err);
}
callback(null, !!res);
}
}
/**
* @memberof async
* @namespace someLimit
* @param {Array|Object} collection
* @param {number} limit - limit >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.someLimit(array, 2, iterator, function(err, res) {
* console.log(res); // true
* console.log(order); // [1]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.someLimit(array, 2, iterator, function(err, res) {
* console.log(res); // true
* console.log(order); // [[1, 0]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.someLimit(object, 2, iterator, function(err, res) {
* console.log(res); // true
* console.log(order); // [1]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.someLimit(object, 2, iterator, function(err, res) {
* console.log(res); // true
* console.log(order); // [[1, 'a']]
* });
*
*/
function someLimit(collection, limit, iterator, callback) {
callback = callback || noop;
detectLimit(collection, limit, iterator, done);
function done(err, res) {
if (err) {
return callback(err);
}
callback(null, !!res);
}
}
/**
* @private
* @param {Function} arrayEach
* @param {Function} baseEach
* @param {Function} symbolEach
*/
function createEvery(arrayEach, baseEach, symbolEach) {
var deny = createDetect(arrayEach, baseEach, symbolEach, false);
return function every(collection, iterator, callback) {
callback = callback || noop;
deny(collection, iterator, done);
function done(err, res) {
if (err) {
return callback(err);
}
callback(null, !res);
}
};
}
/**
* @private
*/
function createEverySeries() {
var denySeries = createDetectSeries(false);
return function everySeries(collection, iterator, callback) {
callback = callback || noop;
denySeries(collection, iterator, done);
function done(err, res) {
if (err) {
return callback(err);
}
callback(null, !res);
}
};
}
/**
* @private
*/
function createEveryLimit() {
var denyLimit = createDetectLimit(false);
return function everyLimit(collection, limit, iterator, callback) {
callback = callback || noop;
denyLimit(collection, limit, iterator, done);
function done(err, res) {
if (err) {
return callback(err);
}
callback(null, !res);
}
};
}
/**
* @private
* @param {Function} arrayEach
* @param {Function} baseEach
* @param {Function} symbolEach
*/
function createConcat(arrayEach, baseEach, symbolEach) {
return function concat(collection, iterator, callback) {
callback = callback || noop;
var size, result;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
result = Array(size);
arrayEach(collection, iterator, createCallback);
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
result = [];
size = symbolEach(collection, iterator, createCallback);
size && size === completed && callback(null, result);
} else if (typeof collection === obj) {
var keys = nativeKeys(collection);
size = keys.length;
result = Array(size);
baseEach(collection, iterator, createCallback, keys);
}
if (!size) {
callback(null, []);
}
function createCallback(index) {
return function done(err, res) {
if (index === null) {
throwError();
}
if (err) {
index = null;
callback = once(callback);
arrayEachSync(result, function(array, index) {
if (array === undefined) {
result[index] = noop;
}
});
callback(err, makeConcatResult(result));
return;
}
switch (arguments.length) {
case 0:
case 1:
result[index] = noop;
break;
case 2:
result[index] = res;
break;
default:
result[index] = slice(arguments, 1);
break;
}
index = null;
if (++completed === size) {
callback(null, makeConcatResult(result));
}
};
}
};
}
/**
* @memberof async
* @namespace concatSeries
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, [num]);
* }, num * 10);
* };
* async.concatSeries(array, iterator, function(err, res) {
* console.log(res); // [1, 3, 2];
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, [num]);
* }, num * 10);
* };
* async.concatSeries(array, iterator, function(err, res) {
* console.log(res); // [1, 3, 2]
* console.log(order); // [[1, 0], [3, 1], [2, 2]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, [num]);
* }, num * 10);
* };
* async.concatSeries(object, iterator, function(err, res) {
* console.log(res); // [1, 3, 2]
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, [num]);
* }, num * 10);
* };
* async.concatSeries(object, iterator, function(err, res) {
* console.log(res); // [1, 3, 2]
* console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]
* });
*
*/
function concatSeries(collection, iterator, callback) {
callback = onlyOnce(callback || noop);
var size, key, keys, iter, item, iterate;
var sync = false;
var result = [];
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size) {
return callback(null, result);
}
iterate();
function arrayIterator() {
iterator(collection[completed], done);
}
function arrayIteratorWithIndex() {
iterator(collection[completed], completed, done);
}
function symbolIterator() {
item = iter.next();
item.done ? callback(null, result) : iterator(item.value, done);
}
function symbolIteratorWithKey() {
item = iter.next();
item.done ? callback(null, result) : iterator(item.value, completed, done);
}
function objectIterator() {
iterator(collection[keys[completed]], done);
}
function objectIteratorWithKey() {
key = keys[completed];
iterator(collection[key], key, done);
}
function done(err, array) {
if (isArray(array)) {
nativePush.apply(result, array);
} else if (arguments.length >= 2) {
nativePush.apply(result, slice(arguments, 1));
}
if (err) {
callback(err, result);
} else if (++completed === size) {
iterate = throwError;
callback(null, result);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* @memberof async
* @namespace concatLimit
* @param {Array|Object} collection
* @param {number} limit - limit >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, [num]);
* }, num * 10);
* };
* async.concatLimit(array, 2, iterator, function(err, res) {
* console.log(res); // [1, 3, 5, 2, 4]
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, [num]);
* }, num * 10);
* };
* async.cocnatLimit(array, 2, iterator, function(err, res) {
* console.log(res); // [1, 3, 5, 2, 4]
* console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, [num]);
* }, num * 10);
* };
* async.concatLimit(object, 2, iterator, function(err, res) {
* console.log(res); // [1, 3, 5, 2, 4]
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num);
* }, num * 10);
* };
* async.cocnatLimit(object, 2, iterator, function(err, res) {
* console.log(res); // [1, 3, 5, 2, 4]
* console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
* });
*
*/
function concatLimit(collection, limit, iterator, callback) {
callback = callback || noop;
var size, key, iter, item, iterate, result;
var sync = false;
var started = 0;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
result = [];
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
var keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size || isNaN(limit) || limit < 1) {
return callback(null, []);
}
result = result || Array(size);
timesSync(limit > size ? size : limit, iterate);
function arrayIterator() {
if (started < size) {
iterator(collection[started], createCallback(started++));
}
}
function arrayIteratorWithIndex() {
if (started < size) {
iterator(collection[started], started, createCallback(started++));
}
}
function symbolIterator() {
item = iter.next();
if (item.done === false) {
iterator(item.value, createCallback(started++));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, makeConcatResult(result));
}
}
function symbolIteratorWithKey() {
item = iter.next();
if (item.done === false) {
iterator(item.value, started, createCallback(started++));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, makeConcatResult(result));
}
}
function objectIterator() {
if (started < size) {
iterator(collection[keys[started]], createCallback(started++));
}
}
function objectIteratorWithKey() {
if (started < size) {
key = keys[started];
iterator(collection[key], key, createCallback(started++));
}
}
function createCallback(index) {
return function(err, res) {
if (index === null) {
throwError();
}
if (err) {
index = null;
iterate = noop;
callback = once(callback);
arrayEachSync(result, function(array, index) {
if (array === undefined) {
result[index] = noop;
}
});
callback(err, makeConcatResult(result));
return;
}
switch (arguments.length) {
case 0:
case 1:
result[index] = noop;
break;
case 2:
result[index] = res;
break;
default:
result[index] = slice(arguments, 1);
break;
}
index = null;
if (++completed === size) {
iterate = throwError;
callback(null, makeConcatResult(result));
callback = throwError;
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
};
}
}
/**
* @private
* @param {Function} arrayEach
* @param {Function} baseEach
* @param {Function} symbolEach
*/
function createGroupBy(arrayEach, baseEach, symbolEach) {
return function groupBy(collection, iterator, callback) {
callback = callback || noop;
var size;
var completed = 0;
var result = {};
if (isArray(collection)) {
size = collection.length;
arrayEach(collection, iterator, createCallback);
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = symbolEach(collection, iterator, createCallback);
size && size === completed && callback(null, result);
} else if (typeof collection === obj) {
var keys = nativeKeys(collection);
size = keys.length;
baseEach(collection, iterator, createCallback, keys);
}
if (!size) {
callback(null, {});
}
function createCallback(value) {
var called = false;
return function done(err, key) {
if (called) {
throwError();
}
called = true;
if (err) {
callback = once(callback);
callback(err, objectClone(result));
return;
}
var array = result[key];
if (!array) {
result[key] = [value];
} else {
array.push(value);
}
if (++completed === size) {
callback(null, result);
}
};
}
};
}
/**
* @memberof async
* @namespace groupBySeries
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [4.2, 6.4, 6.1];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, Math.floor(num));
* }, num * 10);
* };
* async.groupBySeries(array, iterator, function(err, res) {
* console.log(res); // { '4': [4.2], '6': [6.4, 6.1] }
* console.log(order); // [4.2, 6.4, 6.1]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [4.2, 6.4, 6.1];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, Math.floor(num));
* }, num * 10);
* };
* async.groupBySeries(array, iterator, function(err, res) {
* console.log(res); // { '4': [4.2], '6': [6.4, 6.1] }
* console.log(order); // [[4.2, 0], [6.4, 1], [6.1, 2]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 4.2, b: 6.4, c: 6.1 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, Math.floor(num));
* }, num * 10);
* };
* async.groupBySeries(object, iterator, function(err, res) {
* console.log(res); // { '4': [4.2], '6': [6.4, 6.1] }
* console.log(order); // [4.2, 6.4, 6.1]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 4.2, b: 6.4, c: 6.1 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, Math.floor(num));
* }, num * 10);
* };
* async.groupBySeries(object, iterator, function(err, res) {
* console.log(res); // { '4': [4.2], '6': [6.4, 6.1] }
* console.log(order); // [[4.2, 'a'], [6.4, 'b'], [6.1, 'c']]
* });
*
*/
function groupBySeries(collection, iterator, callback) {
callback = onlyOnce(callback || noop);
var size, key, value, keys, iter, item, iterate;
var sync = false;
var completed = 0;
var result = {};
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size) {
return callback(null, result);
}
iterate();
function arrayIterator() {
value = collection[completed];
iterator(value, done);
}
function arrayIteratorWithIndex() {
value = collection[completed];
iterator(value, completed, done);
}
function symbolIterator() {
item = iter.next();
value = item.value;
item.done ? callback(null, result) : iterator(value, done);
}
function symbolIteratorWithKey() {
item = iter.next();
value = item.value;
item.done ? callback(null, result) : iterator(value, completed, done);
}
function objectIterator() {
value = collection[keys[completed]];
iterator(value, done);
}
function objectIteratorWithKey() {
key = keys[completed];
value = collection[key];
iterator(value, key, done);
}
function done(err, key) {
if (err) {
iterate = throwError;
callback = onlyOnce(callback);
callback(err, objectClone(result));
return;
}
var array = result[key];
if (!array) {
result[key] = [value];
} else {
array.push(value);
}
if (++completed === size) {
iterate = throwError;
callback(null, result);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* @memberof async
* @namespace groupByLimit
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1.1, 5.9, 3.2, 3.9, 2.1];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, Math.floor(num));
* }, num * 10);
* };
* async.groupByLimit(array, 2, iterator, function(err, res) {
* console.log(res); // { '1': [1.1], '3': [3.2, 3.9], '5': [5.9], '2': [2.1] }
* console.log(order); // [1.1, 3.2, 5.9, 2.1, 3.9]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1.1, 5.9, 3.2, 3.9, 2.1];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, Math.floor(num));
* }, num * 10);
* };
* async.groupByLimit(array, 2, iterator, function(err, res) {
* console.log(res); // { '1': [1.1], '3': [3.2, 3.9], '5': [5.9], '2': [2.1] }
* console.log(order); // [[1.1, 0], [3.2, 2], [5.9, 1], [2.1, 4], [3.9, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1.1, b: 5.9, c: 3.2, d: 3.9, e: 2.1 }
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, Math.floor(num));
* }, num * 10);
* };
* async.groupByLimit(object, 2, iterator, function(err, res) {
* console.log(res); // { '1': [1.1], '3': [3.2, 3.9], '5': [5.9], '2': [2.1] }
* console.log(order); // [1.1, 3.2, 5.9, 2.1, 3.9]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1.1, b: 5.9, c: 3.2, d: 3.9, e: 2.1 }
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, Math.floor(num));
* }, num * 10);
* };
* async.groupByLimit(object, 2, iterator, function(err, res) {
* console.log(res); // { '1': [1.1], '3': [3.2, 3.9], '5': [5.9], '2': [2.1] }
* console.log(order); // [[1.1, 'a'], [3.2, 'c'], [5.9, 'b'], [2.1, 'e'], [3.9, 'd']]
* });
*
*/
function groupByLimit(collection, limit, iterator, callback) {
callback = callback || noop;
var size, index, key, value, keys, iter, item, iterate;
var sync = false;
var started = 0;
var completed = 0;
var result = {};
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size || isNaN(limit) || limit < 1) {
return callback(null, result);
}
timesSync(limit > size ? size : limit, iterate);
function arrayIterator() {
if (started < size) {
value = collection[started++];
iterator(value, createCallback(value));
}
}
function arrayIteratorWithIndex() {
index = started++;
if (index < size) {
value = collection[index];
iterator(value, index, createCallback(value));
}
}
function symbolIterator() {
item = iter.next();
if (item.done === false) {
started++;
value = item.value;
iterator(value, createCallback(value));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, result);
}
}
function symbolIteratorWithKey() {
item = iter.next();
if (item.done === false) {
value = item.value;
iterator(value, started++, createCallback(value));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, result);
}
}
function objectIterator() {
if (started < size) {
value = collection[keys[started++]];
iterator(value, createCallback(value));
}
}
function objectIteratorWithKey() {
if (started < size) {
key = keys[started++];
value = collection[key];
iterator(value, key, createCallback(value));
}
}
function createCallback(value) {
var called = false;
return function(err, key) {
if (called) {
throwError();
}
called = true;
if (err) {
iterate = noop;
callback = once(callback);
callback(err, objectClone(result));
return;
}
var array = result[key];
if (!array) {
result[key] = [value];
} else {
array.push(value);
}
if (++completed === size) {
callback(null, result);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
};
}
}
/**
* @private
* @param {Function} arrayEach
* @param {Function} baseEach
*/
function createParallel(arrayEach, baseEach) {
return function parallel(tasks, callback) {
callback = callback || noop;
var size, keys, result;
var completed = 0;
if (isArray(tasks)) {
size = tasks.length;
result = Array(size);
arrayEach(tasks, createCallback);
} else if (tasks && typeof tasks === obj) {
keys = nativeKeys(tasks);
size = keys.length;
result = {};
baseEach(tasks, createCallback, keys);
}
if (!size) {
callback(null, result);
}
function createCallback(key) {
return function(err, res) {
if (key === null) {
throwError();
}
if (err) {
key = null;
callback = once(callback);
callback(err, result);
return;
}
result[key] = arguments.length <= 2 ? res : slice(arguments, 1);
key = null;
if (++completed === size) {
callback(null, result);
}
};
}
};
}
/**
* @memberof async
* @namespace series
* @param {Array|Object} tasks - functions
* @param {Function} callback
* @example
*
* var order = [];
* var tasks = [
* function(done) {
* setTimeout(function() {
* order.push(1);
* done(null, 1);
* }, 10);
* },
* function(done) {
* setTimeout(function() {
* order.push(2);
* done(null, 2);
* }, 30);
* },
* function(done) {
* setTimeout(function() {
* order.push(3);
* done(null, 3);
* }, 40);
* },
* function(done) {
* setTimeout(function() {
* order.push(4);
* done(null, 4);
* }, 20);
* }
* ];
* async.series(tasks, function(err, res) {
* console.log(res); // [1, 2, 3, 4];
* console.log(order); // [1, 2, 3, 4]
* });
*
* @example
*
* var order = [];
* var tasks = {
* 'a': function(done) {
* setTimeout(function() {
* order.push(1);
* done(null, 1);
* }, 10);
* },
* 'b': function(done) {
* setTimeout(function() {
* order.push(2);
* done(null, 2);
* }, 30);
* },
* 'c': function(done) {
* setTimeout(function() {
* order.push(3);
* done(null, 3);
* }, 40);
* },
* 'd': function(done) {
* setTimeout(function() {
* order.push(4);
* done(null, 4);
* }, 20);
* }
* };
* async.series(tasks, function(err, res) {
* console.log(res); // { a: 1, b: 2, c: 3, d:4 }
* console.log(order); // [1, 4, 2, 3]
* });
*
*/
function series(tasks, callback) {
callback = callback || noop;
var size, key, keys, result, iterate;
var sync = false;
var completed = 0;
if (isArray(tasks)) {
size = tasks.length;
result = Array(size);
iterate = arrayIterator;
} else if (tasks && typeof tasks === obj) {
keys = nativeKeys(tasks);
size = keys.length;
result = {};
iterate = objectIterator;
} else {
return callback(null);
}
if (!size) {
return callback(null, result);
}
iterate();
function arrayIterator() {
key = completed;
tasks[completed](done);
}
function objectIterator() {
key = keys[completed];
tasks[key](done);
}
function done(err, res) {
if (err) {
iterate = throwError;
callback = onlyOnce(callback);
callback(err, result);
return;
}
result[key] = arguments.length <= 2 ? res : slice(arguments, 1);
if (++completed === size) {
iterate = throwError;
callback(null, result);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* @memberof async
* @namespace parallelLimit
* @param {Array|Object} tasks - functions
* @param {number} limit - limit >= 1
* @param {Function} callback
* @example
*
* var order = [];
* var tasks = [
* function(done) {
* setTimeout(function() {
* order.push(1);
* done(null, 1);
* }, 10);
* },
* function(done) {
* setTimeout(function() {
* order.push(2);
* done(null, 2);
* }, 50);
* },
* function(done) {
* setTimeout(function() {
* order.push(3);
* done(null, 3);
* }, 30);
* },
* function(done) {
* setTimeout(function() {
* order.push(4);
* done(null, 4);
* }, 40);
* }
* ];
* async.parallelLimit(tasks, 2, function(err, res) {
* console.log(res); // [1, 2, 3, 4];
* console.log(order); // [1, 3, 2, 4]
* });
*
* @example
*
* var order = [];
* var tasks = {
* 'a': function(done) {
* setTimeout(function() {
* order.push(1);
* done(null, 1);
* }, 10);
* },
* 'b': function(done) {
* setTimeout(function() {
* order.push(2);
* done(null, 2);
* }, 50);
* },
* 'c': function(done) {
* setTimeout(function() {
* order.push(3);
* done(null, 3);
* }, 20);
* },
* 'd': function(done) {
* setTimeout(function() {
* order.push(4);
* done(null, 4);
* }, 40);
* }
* };
* async.parallelLimit(tasks, 2, function(err, res) {
* console.log(res); // { a: 1, b: 2, c: 3, d:4 }
* console.log(order); // [1, 3, 2, 4]
* });
*
*/
function parallelLimit(tasks, limit, callback) {
callback = callback || noop;
var size, index, key, keys, result, iterate;
var sync = false;
var started = 0;
var completed = 0;
if (isArray(tasks)) {
size = tasks.length;
result = Array(size);
iterate = arrayIterator;
} else if (tasks && typeof tasks === obj) {
keys = nativeKeys(tasks);
size = keys.length;
result = {};
iterate = objectIterator;
}
if (!size || isNaN(limit) || limit < 1) {
return callback(null, result);
}
timesSync(limit > size ? size : limit, iterate);
function arrayIterator() {
index = started++;
if (index < size) {
tasks[index](createCallback(index));
}
}
function objectIterator() {
if (started < size) {
key = keys[started++];
tasks[key](createCallback(key));
}
}
function createCallback(key) {
return function(err, res) {
if (key === null) {
throwError();
}
if (err) {
key = null;
iterate = noop;
callback = once(callback);
callback(err, result);
return;
}
result[key] = arguments.length <= 2 ? res : slice(arguments, 1);
key = null;
if (++completed === size) {
callback(null, result);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
};
}
}
/**
* @memberof async
* @namespace tryEach
* @param {Array|Object} tasks - functions
* @param {Function} callback
* @example
*
* var tasks = [
* function(done) {
* setTimeout(function() {
* done(new Error('error'));
* }, 10);
* },
* function(done) {
* setTimeout(function() {
* done(null, 2);
* }, 10);
* }
* ];
* async.tryEach(tasks, function(err, res) {
* console.log(res); // 2
* });
*
* @example
*
* var tasks = [
* function(done) {
* setTimeout(function() {
* done(new Error('error1'));
* }, 10);
* },
* function(done) {
* setTimeout(function() {
* done(new Error('error2');
* }, 10);
* }
* ];
* async.tryEach(tasks, function(err, res) {
* console.log(err); // error2
* console.log(res); // undefined
* });
*
*/
function tryEach(tasks, callback) {
callback = callback || noop;
var size, keys, iterate;
var sync = false;
var completed = 0;
if (isArray(tasks)) {
size = tasks.length;
iterate = arrayIterator;
} else if (tasks && typeof tasks === obj) {
keys = nativeKeys(tasks);
size = keys.length;
iterate = objectIterator;
}
if (!size) {
return callback(null);
}
iterate();
function arrayIterator() {
tasks[completed](done);
}
function objectIterator() {
tasks[keys[completed]](done);
}
function done(err, res) {
if (!err) {
if (arguments.length <= 2) {
callback(null, res);
} else {
callback(null, slice(arguments, 1));
}
} else if (++completed === size) {
callback(err);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* check for waterfall tasks
* @private
* @param {Array} tasks
* @param {Function} callback
* @return {boolean}
*/
function checkWaterfallTasks(tasks, callback) {
if (!isArray(tasks)) {
callback(new Error('First argument to waterfall must be an array of functions'));
return false;
}
if (tasks.length === 0) {
callback(null);
return false;
}
return true;
}
/**
* check for waterfall tasks
* @private
* @param {function} func
* @param {Array|Object} args - arguments
* @return {function} next
*/
function waterfallIterator(func, args, next) {
switch (args.length) {
case 0:
case 1:
return func(next);
case 2:
return func(args[1], next);
case 3:
return func(args[1], args[2], next);
case 4:
return func(args[1], args[2], args[3], next);
case 5:
return func(args[1], args[2], args[3], args[4], next);
case 6:
return func(args[1], args[2], args[3], args[4], args[5], next);
default:
args = slice(args, 1);
args.push(next);
return func.apply(null, args);
}
}
/**
* @memberof async
* @namespace waterfall
* @param {Array} tasks - functions
* @param {Function} callback
* @example
*
* var order = [];
* var tasks = [
* function(next) {
* setTimeout(function() {
* order.push(1);
* next(null, 1);
* }, 10);
* },
* function(arg1, next) {
* setTimeout(function() {
* order.push(2);
* next(null, 1, 2);
* }, 30);
* },
* function(arg1, arg2, next) {
* setTimeout(function() {
* order.push(3);
* next(null, 3);
* }, 20);
* },
* function(arg1, next) {
* setTimeout(function() {
* order.push(4);
* next(null, 1, 2, 3, 4);
* }, 40);
* }
* ];
* async.waterfall(tasks, function(err, arg1, arg2, arg3, arg4) {
* console.log(arg1, arg2, arg3, arg4); // 1 2 3 4
* });
*
*/
function waterfall(tasks, callback) {
callback = callback || noop;
if (!checkWaterfallTasks(tasks, callback)) {
return;
}
var func, args, done, sync;
var completed = 0;
var size = tasks.length;
waterfallIterator(tasks[0], [], createCallback(0));
function iterate() {
waterfallIterator(func, args, createCallback(func));
}
function createCallback(index) {
return function next(err, res) {
if (index === undefined) {
callback = noop;
throwError();
}
index = undefined;
if (err) {
done = callback;
callback = throwError;
done(err);
return;
}
if (++completed === size) {
done = callback;
callback = throwError;
if (arguments.length <= 2) {
done(err, res);
} else {
done.apply(null, createArray(arguments));
}
return;
}
if (sync) {
args = arguments;
func = tasks[completed] || throwError;
nextTick(iterate);
} else {
sync = true;
waterfallIterator(tasks[completed] || throwError, arguments, createCallback(completed));
}
sync = false;
};
}
}
/**
* `angelFall` is like `waterfall` and inject callback to last argument of next task.
*
* @memberof async
* @namespace angelFall
* @param {Array} tasks - functions
* @param {Function} callback
* @example
*
* var order = [];
* var tasks = [
* function(next) {
* setTimeout(function() {
* order.push(1);
* next(null, 1);
* }, 10);
* },
* function(arg1, empty, next) {
* setTimeout(function() {
* order.push(2);
* next(null, 1, 2);
* }, 30);
* },
* function(next) {
* setTimeout(function() {
* order.push(3);
* next(null, 3);
* }, 20);
* },
* function(arg1, empty1, empty2, empty3, next) {
* setTimeout(function() {
* order.push(4);
* next(null, 1, 2, 3, 4);
* }, 40);
* }
* ];
* async.angelFall(tasks, function(err, arg1, arg2, arg3, arg4) {
* console.log(arg1, arg2, arg3, arg4); // 1 2 3 4
* });
*
*/
function angelFall(tasks, callback) {
callback = callback || noop;
if (!checkWaterfallTasks(tasks, callback)) {
return;
}
var completed = 0;
var sync = false;
var size = tasks.length;
var func = tasks[completed];
var args = [];
var iterate = function() {
switch (func.length) {
case 0:
try {
next(null, func());
} catch (e) {
next(e);
}
return;
case 1:
return func(next);
case 2:
return func(args[1], next);
case 3:
return func(args[1], args[2], next);
case 4:
return func(args[1], args[2], args[3], next);
case 5:
return func(args[1], args[2], args[3], args[4], next);
default:
args = slice(args, 1);
args[func.length - 1] = next;
return func.apply(null, args);
}
};
iterate();
function next(err, res) {
if (err) {
iterate = throwError;
callback = onlyOnce(callback);
callback(err);
return;
}
if (++completed === size) {
iterate = throwError;
var done = callback;
callback = throwError;
if (arguments.length === 2) {
done(err, res);
} else {
done.apply(null, createArray(arguments));
}
return;
}
func = tasks[completed];
args = arguments;
if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* @memberof async
* @namespace whilst
* @param {Function} test
* @param {Function} iterator
* @param {Function} callback
*/
function whilst(test, iterator, callback) {
callback = callback || noop;
var sync = false;
if (test()) {
iterate();
} else {
callback(null);
}
function iterate() {
if (sync) {
nextTick(next);
} else {
sync = true;
iterator(done);
}
sync = false;
}
function next() {
iterator(done);
}
function done(err, arg) {
if (err) {
return callback(err);
}
if (arguments.length <= 2) {
if (test(arg)) {
iterate();
} else {
callback(null, arg);
}
return;
}
arg = slice(arguments, 1);
if (test.apply(null, arg)) {
iterate();
} else {
callback.apply(null, [null].concat(arg));
}
}
}
/**
* @memberof async
* @namespace doWhilst
* @param {Function} iterator
* @param {Function} test
* @param {Function} callback
*/
function doWhilst(iterator, test, callback) {
callback = callback || noop;
var sync = false;
next();
function iterate() {
if (sync) {
nextTick(next);
} else {
sync = true;
iterator(done);
}
sync = false;
}
function next() {
iterator(done);
}
function done(err, arg) {
if (err) {
return callback(err);
}
if (arguments.length <= 2) {
if (test(arg)) {
iterate();
} else {
callback(null, arg);
}
return;
}
arg = slice(arguments, 1);
if (test.apply(null, arg)) {
iterate();
} else {
callback.apply(null, [null].concat(arg));
}
}
}
/**
* @memberof async
* @namespace until
* @param {Function} test
* @param {Function} iterator
* @param {Function} callback
*/
function until(test, iterator, callback) {
callback = callback || noop;
var sync = false;
if (!test()) {
iterate();
} else {
callback(null);
}
function iterate() {
if (sync) {
nextTick(next);
} else {
sync = true;
iterator(done);
}
sync = false;
}
function next() {
iterator(done);
}
function done(err, arg) {
if (err) {
return callback(err);
}
if (arguments.length <= 2) {
if (!test(arg)) {
iterate();
} else {
callback(null, arg);
}
return;
}
arg = slice(arguments, 1);
if (!test.apply(null, arg)) {
iterate();
} else {
callback.apply(null, [null].concat(arg));
}
}
}
/**
* @memberof async
* @namespace doUntil
* @param {Function} iterator
* @param {Function} test
* @param {Function} callback
*/
function doUntil(iterator, test, callback) {
callback = callback || noop;
var sync = false;
next();
function iterate() {
if (sync) {
nextTick(next);
} else {
sync = true;
iterator(done);
}
sync = false;
}
function next() {
iterator(done);
}
function done(err, arg) {
if (err) {
return callback(err);
}
if (arguments.length <= 2) {
if (!test(arg)) {
iterate();
} else {
callback(null, arg);
}
return;
}
arg = slice(arguments, 1);
if (!test.apply(null, arg)) {
iterate();
} else {
callback.apply(null, [null].concat(arg));
}
}
}
/**
* @memberof async
* @namespace during
* @param {Function} test
* @param {Function} iterator
* @param {Function} callback
*/
function during(test, iterator, callback) {
callback = callback || noop;
_test();
function _test() {
test(iterate);
}
function iterate(err, truth) {
if (err) {
return callback(err);
}
if (truth) {
iterator(done);
} else {
callback(null);
}
}
function done(err) {
if (err) {
return callback(err);
}
_test();
}
}
/**
* @memberof async
* @namespace doDuring
* @param {Function} test
* @param {Function} iterator
* @param {Function} callback
*/
function doDuring(iterator, test, callback) {
callback = callback || noop;
iterate(null, true);
function iterate(err, truth) {
if (err) {
return callback(err);
}
if (truth) {
iterator(done);
} else {
callback(null);
}
}
function done(err, res) {
if (err) {
return callback(err);
}
switch (arguments.length) {
case 0:
case 1:
test(iterate);
break;
case 2:
test(res, iterate);
break;
default:
var args = slice(arguments, 1);
args.push(iterate);
test.apply(null, args);
break;
}
}
}
/**
* @memberof async
* @namespace forever
*/
function forever(iterator, callback) {
var sync = false;
iterate();
function iterate() {
iterator(next);
}
function next(err) {
if (err) {
if (callback) {
return callback(err);
}
throw err;
}
if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* @memberof async
* @namespace compose
*/
function compose() {
return seq.apply(null, reverse(arguments));
}
/**
* @memberof async
* @namespace seq
*/
function seq(/* functions... */) {
var fns = createArray(arguments);
return function() {
var self = this;
var args = createArray(arguments);
var callback = args[args.length - 1];
if (typeof callback === func) {
args.pop();
} else {
callback = noop;
}
reduce(fns, args, iterator, done);
function iterator(newargs, fn, callback) {
var func = function(err) {
var nextargs = slice(arguments, 1);
callback(err, nextargs);
};
newargs.push(func);
fn.apply(self, newargs);
}
function done(err, res) {
res = isArray(res) ? res : [res];
res.unshift(err);
callback.apply(self, res);
}
};
}
function createApplyEach(func) {
return function applyEach(fns /* arguments */) {
var go = function() {
var self = this;
var args = createArray(arguments);
var callback = args.pop() || noop;
return func(fns, iterator, callback);
function iterator(fn, done) {
fn.apply(self, args.concat([done]));
}
};
if (arguments.length > 1) {
var args = slice(arguments, 1);
return go.apply(this, args);
} else {
return go;
}
};
}
/**
* @see https://github.com/caolan/async/blob/master/lib/internal/DoublyLinkedList.js
*/
function DLL() {
this.head = null;
this.tail = null;
this.length = 0;
}
DLL.prototype._removeLink = function(node) {
var prev = node.prev;
var next = node.next;
if (prev) {
prev.next = next;
} else {
this.head = next;
}
if (next) {
next.prev = prev;
} else {
this.tail = prev;
}
node.prev = null;
node.next = null;
this.length--;
return node;
};
DLL.prototype.empty = DLL;
DLL.prototype._setInitial = function(node) {
this.length = 1;
this.head = this.tail = node;
};
DLL.prototype.insertBefore = function(node, newNode) {
newNode.prev = node.prev;
newNode.next = node;
if (node.prev) {
node.prev.next = newNode;
} else {
this.head = newNode;
}
node.prev = newNode;
this.length++;
};
DLL.prototype.unshift = function(node) {
if (this.head) {
this.insertBefore(this.head, node);
} else {
this._setInitial(node);
}
};
DLL.prototype.push = function(node) {
var tail = this.tail;
if (tail) {
node.prev = tail;
node.next = tail.next;
this.tail = node;
tail.next = node;
this.length++;
} else {
this._setInitial(node);
}
};
DLL.prototype.shift = function() {
return this.head && this._removeLink(this.head);
};
DLL.prototype.splice = function(end) {
var task;
var tasks = [];
while (end-- && (task = this.shift())) {
tasks.push(task);
}
return tasks;
};
DLL.prototype.remove = function(test) {
var node = this.head;
while (node) {
if (test(node)) {
this._removeLink(node);
}
node = node.next;
}
return this;
};
/**
* @private
*/
function baseQueue(isQueue, worker, concurrency, payload) {
if (concurrency === undefined) {
concurrency = 1;
} else if (isNaN(concurrency) || concurrency < 1) {
throw new Error('Concurrency must not be zero');
}
var workers = 0;
var workersList = [];
var _callback, _unshift;
var q = {
_tasks: new DLL(),
concurrency: concurrency,
payload: payload,
saturated: noop,
unsaturated: noop,
buffer: concurrency / 4,
empty: noop,
drain: noop,
error: noop,
started: false,
paused: false,
push: push,
kill: kill,
unshift: unshift,
remove: remove,
process: isQueue ? runQueue : runCargo,
length: getLength,
running: running,
workersList: getWorkersList,
idle: idle,
pause: pause,
resume: resume,
_worker: worker
};
return q;
function push(tasks, callback) {
_insert(tasks, callback);
}
function unshift(tasks, callback) {
_insert(tasks, callback, true);
}
function _exec(task) {
var item = {
data: task,
callback: _callback
};
if (_unshift) {
q._tasks.unshift(item);
} else {
q._tasks.push(item);
}
nextTick(q.process);
}
function _insert(tasks, callback, unshift) {
if (callback == null) {
callback = noop;
} else if (typeof callback !== 'function') {
throw new Error('task callback must be a function');
}
q.started = true;
var _tasks = isArray(tasks) ? tasks : [tasks];
if (tasks === undefined || !_tasks.length) {
if (q.idle()) {
nextTick(q.drain);
}
return;
}
_unshift = unshift;
_callback = callback;
arrayEachSync(_tasks, _exec);
}
function kill() {
q.drain = noop;
q._tasks.empty();
}
function _next(q, tasks) {
var called = false;
return function done(err, res) {
if (called) {
throwError();
}
called = true;
workers--;
var task;
var index = -1;
var size = workersList.length;
var taskIndex = -1;
var taskSize = tasks.length;
var useApply = arguments.length > 2;
var args = useApply && createArray(arguments);
while (++taskIndex < taskSize) {
task = tasks[taskIndex];
while (++index < size) {
if (workersList[index] === task) {
if (index === 0) {
workersList.shift();
} else {
workersList.splice(index, 1);
}
index = size;
size--;
}
}
index = -1;
if (useApply) {
task.callback.apply(task, args);
} else {
task.callback(err, res);
}
if (err) {
q.error(err, task.data);
}
}
if (workers <= q.concurrency - q.buffer) {
q.unsaturated();
}
if (q._tasks.length + workers === 0) {
q.drain();
}
q.process();
};
}
function runQueue() {
while (!q.paused && workers < q.concurrency && q._tasks.length) {
var task = q._tasks.shift();
workers++;
workersList.push(task);
if (q._tasks.length === 0) {
q.empty();
}
if (workers === q.concurrency) {
q.saturated();
}
var done = _next(q, [task]);
worker(task.data, done);
}
}
function runCargo() {
while (!q.paused && workers < q.concurrency && q._tasks.length) {
var tasks = q._tasks.splice(q.payload || q._tasks.length);
var index = -1;
var size = tasks.length;
var data = Array(size);
while (++index < size) {
data[index] = tasks[index].data;
}
workers++;
nativePush.apply(workersList, tasks);
if (q._tasks.length === 0) {
q.empty();
}
if (workers === q.concurrency) {
q.saturated();
}
var done = _next(q, tasks);
worker(data, done);
}
}
function getLength() {
return q._tasks.length;
}
function running() {
return workers;
}
function getWorkersList() {
return workersList;
}
function idle() {
return q.length() + workers === 0;
}
function pause() {
q.paused = true;
}
function _resume() {
nextTick(q.process);
}
function resume() {
if (q.paused === false) {
return;
}
q.paused = false;
var count = q.concurrency < q._tasks.length ? q.concurrency : q._tasks.length;
timesSync(count, _resume);
}
/**
* @param {Function} test
*/
function remove(test) {
q._tasks.remove(test);
}
}
/**
* @memberof async
* @namespace queue
*/
function queue(worker, concurrency) {
return baseQueue(true, worker, concurrency);
}
/**
* @memberof async
* @namespace priorityQueue
*/
function priorityQueue(worker, concurrency) {
var q = baseQueue(true, worker, concurrency);
q.push = push;
delete q.unshift;
return q;
function push(tasks, priority, callback) {
q.started = true;
priority = priority || 0;
var _tasks = isArray(tasks) ? tasks : [tasks];
var taskSize = _tasks.length;
if (tasks === undefined || taskSize === 0) {
if (q.idle()) {
nextTick(q.drain);
}
return;
}
callback = typeof callback === func ? callback : noop;
var nextNode = q._tasks.head;
while (nextNode && priority >= nextNode.priority) {
nextNode = nextNode.next;
}
while (taskSize--) {
var item = {
data: _tasks[taskSize],
priority: priority,
callback: callback
};
if (nextNode) {
q._tasks.insertBefore(nextNode, item);
} else {
q._tasks.push(item);
}
nextTick(q.process);
}
}
}
/**
* @memberof async
* @namespace cargo
*/
function cargo(worker, payload) {
return baseQueue(false, worker, 1, payload);
}
/**
* @memberof async
* @namespace auto
* @param {Object} tasks
* @param {number} [concurrency]
* @param {Function} [callback]
*/
function auto(tasks, concurrency, callback) {
if (typeof concurrency === func) {
callback = concurrency;
concurrency = null;
}
var keys = nativeKeys(tasks);
var rest = keys.length;
var results = {};
if (rest === 0) {
return callback(null, results);
}
var runningTasks = 0;
var readyTasks = [];
var listeners = Object.create(null);
callback = onlyOnce(callback || noop);
concurrency = concurrency || rest;
baseEachSync(tasks, iterator, keys);
proceedQueue();
function iterator(task, key) {
// no dependencies
var _task, _taskSize;
if (!isArray(task)) {
_task = task;
_taskSize = 0;
readyTasks.push([_task, _taskSize, done]);
return;
}
var dependencySize = task.length - 1;
_task = task[dependencySize];
_taskSize = dependencySize;
if (dependencySize === 0) {
readyTasks.push([_task, _taskSize, done]);
return;
}
// dependencies
var index = -1;
while (++index < dependencySize) {
var dependencyName = task[index];
if (notInclude(keys, dependencyName)) {
var msg =
'async.auto task `' +
key +
'` has non-existent dependency `' +
dependencyName +
'` in ' +
task.join(', ');
throw new Error(msg);
}
var taskListeners = listeners[dependencyName];
if (!taskListeners) {
taskListeners = listeners[dependencyName] = [];
}
taskListeners.push(taskListener);
}
function done(err, arg) {
if (key === null) {
throwError();
}
arg = arguments.length <= 2 ? arg : slice(arguments, 1);
if (err) {
rest = 0;
runningTasks = 0;
readyTasks.length = 0;
var safeResults = objectClone(results);
safeResults[key] = arg;
key = null;
var _callback = callback;
callback = noop;
_callback(err, safeResults);
return;
}
runningTasks--;
rest--;
results[key] = arg;
taskComplete(key);
key = null;
}
function taskListener() {
if (--dependencySize === 0) {
readyTasks.push([_task, _taskSize, done]);
}
}
}
function proceedQueue() {
if (readyTasks.length === 0 && runningTasks === 0) {
if (rest !== 0) {
throw new Error('async.auto task has cyclic dependencies');
}
return callback(null, results);
}
while (readyTasks.length && runningTasks < concurrency && callback !== noop) {
runningTasks++;
var array = readyTasks.shift();
if (array[1] === 0) {
array[0](array[2]);
} else {
array[0](results, array[2]);
}
}
}
function taskComplete(key) {
var taskListeners = listeners[key] || [];
arrayEachSync(taskListeners, function(task) {
task();
});
proceedQueue();
}
}
var FN_ARGS = /^(function)?\s*[^\(]*\(\s*([^\)]*)\)/m;
var FN_ARG_SPLIT = /,/;
var FN_ARG = /(=.+)?(\s*)$/;
var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
/**
* parse function arguments for `autoInject`
*
* @private
*/
function parseParams(func) {
func = func.toString().replace(STRIP_COMMENTS, '');
func = func.match(FN_ARGS)[2].replace(' ', '');
func = func ? func.split(FN_ARG_SPLIT) : [];
func = func.map(function(arg) {
return arg.replace(FN_ARG, '').trim();
});
return func;
}
/**
* @memberof async
* @namespace autoInject
* @param {Object} tasks
* @param {number} [concurrency]
* @param {Function} [callback]
*/
function autoInject(tasks, concurrency, callback) {
var newTasks = {};
baseEachSync(tasks, iterator, nativeKeys(tasks));
auto(newTasks, concurrency, callback);
function iterator(task, key) {
var params;
var taskLength = task.length;
if (isArray(task)) {
if (taskLength === 0) {
throw new Error('autoInject task functions require explicit parameters.');
}
params = createArray(task);
taskLength = params.length - 1;
task = params[taskLength];
if (taskLength === 0) {
newTasks[key] = task;
return;
}
} else if (taskLength === 1) {
newTasks[key] = task;
return;
} else {
params = parseParams(task);
if (taskLength === 0 && params.length === 0) {
throw new Error('autoInject task functions require explicit parameters.');
}
taskLength = params.length - 1;
}
params[taskLength] = newTask;
newTasks[key] = params;
function newTask(results, done) {
switch (taskLength) {
case 1:
task(results[params[0]], done);
break;
case 2:
task(results[params[0]], results[params[1]], done);
break;
case 3:
task(results[params[0]], results[params[1]], results[params[2]], done);
break;
default:
var i = -1;
while (++i < taskLength) {
params[i] = results[params[i]];
}
params[i] = done;
task.apply(null, params);
break;
}
}
}
}
/**
* @memberof async
* @namespace retry
* @param {integer|Object|Function} opts
* @param {Function} [task]
* @param {Function} [callback]
*/
function retry(opts, task, callback) {
var times, intervalFunc, errorFilter;
var count = 0;
if (arguments.length < 3 && typeof opts === func) {
callback = task || noop;
task = opts;
opts = null;
times = DEFAULT_TIMES;
} else {
callback = callback || noop;
switch (typeof opts) {
case 'object':
if (typeof opts.errorFilter === func) {
errorFilter = opts.errorFilter;
}
var interval = opts.interval;
switch (typeof interval) {
case func:
intervalFunc = interval;
break;
case 'string':
case 'number':
interval = +interval;
intervalFunc = interval
? function() {
return interval;
}
: function() {
return DEFAULT_INTERVAL;
};
break;
}
times = +opts.times || DEFAULT_TIMES;
break;
case 'number':
times = opts || DEFAULT_TIMES;
break;
case 'string':
times = +opts || DEFAULT_TIMES;
break;
default:
throw new Error('Invalid arguments for async.retry');
}
}
if (typeof task !== 'function') {
throw new Error('Invalid arguments for async.retry');
}
if (intervalFunc) {
task(intervalCallback);
} else {
task(simpleCallback);
}
function simpleIterator() {
task(simpleCallback);
}
function simpleCallback(err, res) {
if (++count === times || !err || (errorFilter && !errorFilter(err))) {
if (arguments.length <= 2) {
return callback(err, res);
}
var args = createArray(arguments);
return callback.apply(null, args);
}
simpleIterator();
}
function intervalIterator() {
task(intervalCallback);
}
function intervalCallback(err, res) {
if (++count === times || !err || (errorFilter && !errorFilter(err))) {
if (arguments.length <= 2) {
return callback(err, res);
}
var args = createArray(arguments);
return callback.apply(null, args);
}
setTimeout(intervalIterator, intervalFunc(count));
}
}
function retryable(opts, task) {
if (!task) {
task = opts;
opts = null;
}
return done;
function done() {
var taskFn;
var args = createArray(arguments);
var lastIndex = args.length - 1;
var callback = args[lastIndex];
switch (task.length) {
case 1:
taskFn = task1;
break;
case 2:
taskFn = task2;
break;
case 3:
taskFn = task3;
break;
default:
taskFn = task4;
}
if (opts) {
retry(opts, taskFn, callback);
} else {
retry(taskFn, callback);
}
function task1(done) {
task(done);
}
function task2(done) {
task(args[0], done);
}
function task3(done) {
task(args[0], args[1], done);
}
function task4(callback) {
args[lastIndex] = callback;
task.apply(null, args);
}
}
}
/**
* @memberof async
* @namespace iterator
*/
function iterator(tasks) {
var size = 0;
var keys = [];
if (isArray(tasks)) {
size = tasks.length;
} else {
keys = nativeKeys(tasks);
size = keys.length;
}
return makeCallback(0);
function makeCallback(index) {
var fn = function() {
if (size) {
var key = keys[index] || index;
tasks[key].apply(null, createArray(arguments));
}
return fn.next();
};
fn.next = function() {
return index < size - 1 ? makeCallback(index + 1) : null;
};
return fn;
}
}
/**
* @memberof async
* @namespace apply
*/
function apply(func) {
switch (arguments.length) {
case 0:
case 1:
return func;
case 2:
return func.bind(null, arguments[1]);
case 3:
return func.bind(null, arguments[1], arguments[2]);
case 4:
return func.bind(null, arguments[1], arguments[2], arguments[3]);
case 5:
return func.bind(null, arguments[1], arguments[2], arguments[3], arguments[4]);
default:
var size = arguments.length;
var index = 0;
var args = Array(size);
args[index] = null;
while (++index < size) {
args[index] = arguments[index];
}
return func.bind.apply(func, args);
}
}
/**
* @memberof async
* @namespace timeout
* @param {Function} func
* @param {number} millisec
* @param {*} info
*/
function timeout(func, millisec, info) {
var callback, timer;
return wrappedFunc;
function wrappedFunc() {
timer = setTimeout(timeoutCallback, millisec);
var args = createArray(arguments);
var lastIndex = args.length - 1;
callback = args[lastIndex];
args[lastIndex] = injectedCallback;
simpleApply(func, args);
}
function timeoutCallback() {
var name = func.name || 'anonymous';
var err = new Error('Callback function "' + name + '" timed out.');
err.code = 'ETIMEDOUT';
if (info) {
err.info = info;
}
timer = null;
callback(err);
}
function injectedCallback() {
if (timer !== null) {
simpleApply(callback, createArray(arguments));
clearTimeout(timer);
}
}
function simpleApply(func, args) {
switch (args.length) {
case 0:
func();
break;
case 1:
func(args[0]);
break;
case 2:
func(args[0], args[1]);
break;
default:
func.apply(null, args);
break;
}
}
}
/**
* @memberof async
* @namespace times
* @param {number} n - n >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* var iterator = function(n, done) {
* done(null, n);
* };
* async.times(4, iterator, function(err, res) {
* console.log(res); // [0, 1, 2, 3];
* });
*
*/
function times(n, iterator, callback) {
callback = callback || noop;
n = +n;
if (isNaN(n) || n < 1) {
return callback(null, []);
}
var result = Array(n);
timesSync(n, iterate);
function iterate(num) {
iterator(num, createCallback(num));
}
function createCallback(index) {
return function(err, res) {
if (index === null) {
throwError();
}
result[index] = res;
index = null;
if (err) {
callback(err);
callback = noop;
} else if (--n === 0) {
callback(null, result);
}
};
}
}
/**
* @memberof async
* @namespace timesSeries
* @param {number} n - n >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* var iterator = function(n, done) {
* done(null, n);
* };
* async.timesSeries(4, iterator, function(err, res) {
* console.log(res); // [0, 1, 2, 3];
* });
*
*/
function timesSeries(n, iterator, callback) {
callback = callback || noop;
n = +n;
if (isNaN(n) || n < 1) {
return callback(null, []);
}
var result = Array(n);
var sync = false;
var completed = 0;
iterate();
function iterate() {
iterator(completed, done);
}
function done(err, res) {
result[completed] = res;
if (err) {
callback(err);
callback = throwError;
} else if (++completed >= n) {
callback(null, result);
callback = throwError;
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* @memberof async
* @namespace timesLimit
* @param {number} n - n >= 1
* @param {number} limit - n >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* var iterator = function(n, done) {
* done(null, n);
* };
* async.timesLimit(4, 2, iterator, function(err, res) {
* console.log(res); // [0, 1, 2, 3];
* });
*
*/
function timesLimit(n, limit, iterator, callback) {
callback = callback || noop;
n = +n;
if (isNaN(n) || n < 1 || isNaN(limit) || limit < 1) {
return callback(null, []);
}
var result = Array(n);
var sync = false;
var started = 0;
var completed = 0;
timesSync(limit > n ? n : limit, iterate);
function iterate() {
var index = started++;
if (index < n) {
iterator(index, createCallback(index));
}
}
function createCallback(index) {
return function(err, res) {
if (index === null) {
throwError();
}
result[index] = res;
index = null;
if (err) {
callback(err);
callback = noop;
} else if (++completed >= n) {
callback(null, result);
callback = throwError;
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
};
}
}
/**
* @memberof async
* @namespace race
* @param {Array|Object} tasks - functions
* @param {Function} callback
* @example
*
* // array
* var called = 0;
* var tasks = [
* function(done) {
* setTimeout(function() {
* called++;
* done(null, '1');
* }, 30);
* },
* function(done) {
* setTimeout(function() {
* called++;
* done(null, '2');
* }, 20);
* },
* function(done) {
* setTimeout(function() {
* called++;
* done(null, '3');
* }, 10);
* }
* ];
* async.race(tasks, function(err, res) {
* console.log(res); // '3'
* console.log(called); // 1
* setTimeout(function() {
* console.log(called); // 3
* }, 50);
* });
*
* @example
*
* // object
* var called = 0;
* var tasks = {
* 'test1': function(done) {
* setTimeout(function() {
* called++;
* done(null, '1');
* }, 30);
* },
* 'test2': function(done) {
* setTimeout(function() {
* called++;
* done(null, '2');
* }, 20);
* },
* 'test3': function(done) {
* setTimeout(function() {
* called++;
* done(null, '3');
* }, 10);
* }
* };
* async.race(tasks, function(err, res) {
* console.log(res); // '3'
* console.log(called); // 1
* setTimeout(function() {
* console.log(called); // 3
* done();
* }, 50);
* });
*
*/
function race(tasks, callback) {
callback = once(callback || noop);
var size, keys;
var index = -1;
if (isArray(tasks)) {
size = tasks.length;
while (++index < size) {
tasks[index](callback);
}
} else if (tasks && typeof tasks === obj) {
keys = nativeKeys(tasks);
size = keys.length;
while (++index < size) {
tasks[keys[index]](callback);
}
} else {
return callback(new TypeError('First argument to race must be a collection of functions'));
}
if (!size) {
callback(null);
}
}
/**
* @memberof async
* @namespace memoize
*/
function memoize(fn, hasher) {
hasher =
hasher ||
function(hash) {
return hash;
};
var memo = {};
var queues = {};
var memoized = function() {
var args = createArray(arguments);
var callback = args.pop();
var key = hasher.apply(null, args);
if (has(memo, key)) {
nextTick(function() {
callback.apply(null, memo[key]);
});
return;
}
if (has(queues, key)) {
return queues[key].push(callback);
}
queues[key] = [callback];
args.push(done);
fn.apply(null, args);
function done(err) {
var args = createArray(arguments);
if (!err) {
memo[key] = args;
}
var q = queues[key];
delete queues[key];
var i = -1;
var size = q.length;
while (++i < size) {
q[i].apply(null, args);
}
}
};
memoized.memo = memo;
memoized.unmemoized = fn;
return memoized;
}
/**
* @memberof async
* @namespace unmemoize
*/
function unmemoize(fn) {
return function() {
return (fn.unmemoized || fn).apply(null, arguments);
};
}
/**
* @memberof async
* @namespace ensureAsync
*/
function ensureAsync(fn) {
return function(/* ...args, callback */) {
var args = createArray(arguments);
var lastIndex = args.length - 1;
var callback = args[lastIndex];
var sync = true;
args[lastIndex] = done;
fn.apply(this, args);
sync = false;
function done() {
var innerArgs = createArray(arguments);
if (sync) {
nextTick(function() {
callback.apply(null, innerArgs);
});
} else {
callback.apply(null, innerArgs);
}
}
};
}
/**
* @memberof async
* @namespace constant
*/
function constant(/* values... */) {
var args = [null].concat(createArray(arguments));
return function(callback) {
callback = arguments[arguments.length - 1];
callback.apply(this, args);
};
}
function asyncify(fn) {
return function(/* args..., callback */) {
var args = createArray(arguments);
var callback = args.pop();
var result;
try {
result = fn.apply(this, args);
} catch (e) {
return callback(e);
}
if (result && typeof result.then === func) {
result.then(
function(value) {
invokeCallback(callback, null, value);
},
function(err) {
invokeCallback(callback, err && err.message ? err : new Error(err));
}
);
} else {
callback(null, result);
}
};
}
function invokeCallback(callback, err, value) {
try {
callback(err, value);
} catch (e) {
nextTick(rethrow, e);
}
}
function rethrow(error) {
throw error;
}
/**
* @memberof async
* @namespace reflect
* @param {Function} func
* @return {Function}
*/
function reflect(func) {
return function(/* args..., callback */) {
var callback;
switch (arguments.length) {
case 1:
callback = arguments[0];
return func(done);
case 2:
callback = arguments[1];
return func(arguments[0], done);
default:
var args = createArray(arguments);
var lastIndex = args.length - 1;
callback = args[lastIndex];
args[lastIndex] = done;
func.apply(this, args);
}
function done(err, res) {
if (err) {
return callback(null, {
error: err
});
}
if (arguments.length > 2) {
res = slice(arguments, 1);
}
callback(null, {
value: res
});
}
};
}
/**
* @memberof async
* @namespace reflectAll
* @param {Array[]|Object} tasks
* @return {Function}
*/
function reflectAll(tasks) {
var newTasks, keys;
if (isArray(tasks)) {
newTasks = Array(tasks.length);
arrayEachSync(tasks, iterate);
} else if (tasks && typeof tasks === obj) {
keys = nativeKeys(tasks);
newTasks = {};
baseEachSync(tasks, iterate, keys);
}
return newTasks;
function iterate(func, key) {
newTasks[key] = reflect(func);
}
}
/**
* @memberof async
* @namespace createLogger
*/
function createLogger(name) {
return function(fn) {
var args = slice(arguments, 1);
args.push(done);
fn.apply(null, args);
};
function done(err) {
if (typeof console === obj) {
if (err) {
if (console.error) {
console.error(err);
}
return;
}
if (console[name]) {
var args = slice(arguments, 1);
arrayEachSync(args, function(arg) {
console[name](arg);
});
}
}
}
}
/**
* @memberof async
* @namespace safe
*/
function safe() {
createImmediate();
return exports;
}
/**
* @memberof async
* @namespace fast
*/
function fast() {
createImmediate(false);
return exports;
}
});
neo-async-2.6.1/dist/async.min.js 0000664 0000000 0000000 00000116517 13466145133 0016635 0 ustar 00root root 0000000 0000000 (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 {
const filepath = path.resolve(__dirname, '../..', 'lib/async.js');
const options = {
encoding: 'utf8'
};
const asyncFile = fs.readFileSync(filepath, options);
async.angelFall([
async.apply(git.fetch, 'origin', ''),
async.apply(git.checkout, 'gh-pages'),
async.apply(fs.writeFile, filepath, asyncFile, {
encoding: 'utf8'
}),
async.apply(jsdoc.create),
async.apply(git.status, {
args: '-s ./doc'
}),
(result, next) => {
if (!result) {
console.log('[skip commit]');
return checkoutMaster(done);
}
git.exec({
args: 'add ./doc ./lib/async.js'
}, next);
},
async.apply(git.exec, {
args: `commit -m "docs(jsdoc): update jsdoc [v${async.VERSION}] [ci skip]"`
}),
checkoutMaster
], done);
function checkoutMaster(next) {
git.checkout('master', next);
}
});
neo-async-2.6.1/gulp/tasks/jscs.js 0000664 0000000 0000000 00000000361 13466145133 0017016 0 ustar 00root root 0000000 0000000 'use strict';
const gulp = require('gulp');
const jscs = require('gulp-jscs');
const config = require('../config');
gulp.task('jscs', () => {
const { dirnames } = config.jscs;
return gulp.src(dirnames)
.pipe(jscs('.jscsrc'));
});
neo-async-2.6.1/gulp/tasks/jsdoc.js 0000664 0000000 0000000 00000001015 13466145133 0017153 0 ustar 00root root 0000000 0000000 'use strict';
const exec = require('child_process').exec;
const fs = require('fs');
const path = require('path');
const gulp = require('gulp');
const config = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../..', '.jsdocrc'), {
encoding: 'utf8'
}));
function createJSDoc(done) {
const dirpath = path.resolve(__dirname, '../..', config.opts.destination);
exec(`rm -rf ${dirpath}`);
exec('$(npm bin)/jsdoc -c .jsdocrc ./lib/async.js', done);
}
gulp.task('jsdoc', createJSDoc);
exports.create = createJSDoc;
neo-async-2.6.1/gulp/tasks/minify.js 0000664 0000000 0000000 00000002626 13466145133 0017355 0 ustar 00root root 0000000 0000000 'use strict';
const fs = require('fs');
const qs = require('querystring');
const path = require('path');
const http = require('http');
const { exec } = require('child_process');
const gulp = require('gulp');
const filepath = path.resolve(__dirname, '../..', 'lib', 'async.js');
const target = path.resolve(__dirname, '../..', 'lib', 'async.min.js');
gulp.task('minify:local', done => {
const compilerPath = path.resolve(__dirname, '..', 'compiler.jar');
const command = `java -jar ${compilerPath} --js ${filepath} --js_output_file ${target}`;
exec(command, done);
});
gulp.task('minify', done => {
const file = fs.readFileSync(filepath, 'utf8');
const body = qs.stringify({
js_code: file,
compilation_level: 'SIMPLE_OPTIMIZATIONS',
// compilation_level: 'ADVANCED_OPTIMIZATIONS',
output_format: 'text',
output_info: 'compiled_code'
});
const opts = {
hostname: 'closure-compiler.appspot.com',
port: 80,
path: '/compile',
method: 'POST',
headers: {
'Content-Type': 'application/x-www-form-urlencoded',
'Content_length': Buffer.byteLength(file)
}
};
let data = '';
const req = http.request(opts, res => {
res.setEncoding('utf8')
.on('data', res => {
data += res;
})
.on('error', done)
.on('end', () => {
fs.writeFile(target, data, 'utf8', done);
});
})
.on('error', done);
req.write(body);
req.end();
});
neo-async-2.6.1/gulp/tasks/npm.js 0000664 0000000 0000000 00000003327 13466145133 0016653 0 ustar 00root root 0000000 0000000 'use strict';
const path = require('path');
const _ = require('lodash');
const gulp = require('gulp');
const fs = require('fs-extra');
const argv = require('minimist')(process.argv.slice(2));
const { exec } = require('../util');
const async = require('../../lib/async');
gulp.task('npm:publish', publish);
async function publish() {
const { otp } = argv;
if (!otp) {
throw new Error('Invalid otp');
}
const rootpath = path.resolve(__dirname, '../..');
const buildpath = path.resolve(rootpath, 'build');
await exec(`rm -rf ${buildpath}`);
// make dir
!fs.existsSync(buildpath) && fs.mkdirSync(buildpath);
// copy lib
fs.copySync(path.resolve(rootpath, 'lib', 'async.js'), path.resolve(buildpath, 'async.js'));
// copy the minified file
fs.copySync(path.resolve(rootpath, 'dist', 'async.min.js'), path.resolve(buildpath, 'async.min.js'));
// copy package.json
const json = _.omit(require('../../package'), ['files', 'scripts', 'private']);
json.main = 'async.js';
json.browser = 'async.min.js';
fs.writeFileSync(path.resolve(buildpath, 'package.json'), JSON.stringify(json, null, 2), 'utf8');
// copy README
fs.copySync(path.resolve(rootpath, 'README.md'), path.resolve(buildpath, 'README.md'));
// copy LICENSE
fs.copySync(path.resolve(rootpath, 'LICENSE'), path.resolve(buildpath, 'LICENSE'));
// create all function files
const template = fs.readFileSync(path.resolve(__dirname, '../template'), 'utf8');
_.forOwn(async, (func, key) => {
if (!_.isFunction(func)) {
return;
}
const file = template.replace('', key);
fs.writeFileSync(path.resolve(buildpath, `${key}.js`), file, 'utf8');
});
await exec(`cd ${buildpath} && npm publish --otp=${otp}`);
}
neo-async-2.6.1/gulp/tasks/release.js 0000664 0000000 0000000 00000003725 13466145133 0017503 0 ustar 00root root 0000000 0000000 'use strict';
const fs = require('fs');
const path = require('path');
const _ = require('lodash');
const gulp = require('gulp');
const git = require('gulp-git');
const bump = require('gulp-bump');
const runSequence = require('run-sequence');
const tagVersion = require('gulp-tag-version');
const basepath = path.resolve(__dirname, '../../');
const packagepath = path.resolve(basepath, 'package.json');
const bowerpath = path.resolve(basepath, 'bower.json');
const types = ['patch', 'prepatch', 'minor', 'preminor', 'major', 'premajor'];
const { version: prevVersion } = require(packagepath);
_.forEach(types, type => {
gulp.task(`release:package:${type}`, updatePackageVersion(type));
gulp.task(`release:${type}`, () => runSequence(
`release:package:${type}`,
'release:async',
'minify:local',
'release:dist',
'release:commit',
'release:tag',
'gh-pages'
));
});
gulp.task('release:async', () => {
delete require.cache[packagepath];
const { version } = require(packagepath);
const asyncpath = path.resolve(basepath, 'lib', 'async.js');
const file = fs.readFileSync(asyncpath, 'utf8');
fs.writeFileSync(asyncpath, file.replace(new RegExp(prevVersion, 'g'), version), 'utf8');
});
gulp.task('release:tag', () => {
return gulp.src(packagepath)
.pipe(tagVersion());
});
gulp.task('release:dist', () => {
_.forEach(['async.js', 'async.min.js'], file => {
const filepath = path.resolve(basepath, 'lib', file);
const distpath = path.resolve(basepath, 'dist', file);
fs.createReadStream(filepath)
.pipe(fs.createWriteStream(distpath));
});
});
gulp.task('release:commit', () => {
delete require.cache[packagepath];
const { version } = require(packagepath);
return gulp.src(['./dist/*', './lib/*', packagepath, bowerpath])
.pipe(git.commit(version));
});
function updatePackageVersion(type) {
return () => {
return gulp.src([packagepath, bowerpath])
.pipe(bump({ type }))
.pipe(gulp.dest('./'));
};
}
neo-async-2.6.1/gulp/tasks/test.js 0000664 0000000 0000000 00000002576 13466145133 0017045 0 ustar 00root root 0000000 0000000 'use strict';
const fs = require('fs');
const path = require('path');
const _ = require('lodash');
const gulp = require('gulp');
const exit = require('gulp-exit');
const mocha = require('gulp-mocha');
const gutil = require('gulp-util');
const executor = require('mocha-parallel-executor');
const config = require('../../test/config');
function test() {
const filename = gutil.env.file || '*';
const delay = gulp.env.delay;
if (delay) {
config.delay = delay;
}
gulp.src([
`./test/**/test.${filename}*`
])
.pipe(mocha({
reporter: 'spec',
report: 'lcovonly',
timeout: 2000
}))
.pipe(exit());
}
function exec(name, func) {
const filepath = path.resolve(__dirname, '../..', 'lib', name);
const filename = gutil.env.file;
let files;
if (filename) {
files = _.transform(['collections', 'controlFlow', 'other', 'utils'], (result, dir) => {
const p = path.resolve(__dirname, '../../', 'test', dir, `test.${filename}.js`);
if(fs.existsSync(p)) {
result.push(p);
}
});
}
global.async = require(filepath);
global.async_path = filepath;
func({ files: files });
}
gulp.task('test', () => {
exec('async.js', test);
});
gulp.task('test:min', () => {
exec('async.min.js', test);
});
gulp.task('test:fast', () => {
exec('async.js', executor);
});
gulp.task('test:fast:min', () => {
exec('async.min.js', executor);
});
neo-async-2.6.1/gulp/template 0000664 0000000 0000000 00000000077 13466145133 0016133 0 ustar 00root root 0000000 0000000 'use strict';
module.exports = require('./async').;
neo-async-2.6.1/gulp/util.js 0000664 0000000 0000000 00000001250 13466145133 0015702 0 ustar 00root root 0000000 0000000 'use strict';
const cp = require('child_process');
const _ = require('lodash');
const Aigle = require('aigle');
module.exports = { exec, spawn };
function exec(command, args) {
command = !args ? command : _.reduce(args, (str, arg) => `${str} ${arg}`, command);
return execute(cp.exec, command);
}
function spawn(name, args) {
return execute(cp.spawn, name, args);
}
function execute(func, command, args) {
return new Aigle((resolve, reject) => {
let result = '';
const task = func(command, args);
task.on('close', err => err ? reject(err) : resolve(result));
task.on('error', reject);
task.stdout.on('data', data => result += `${data}`);
});
}
neo-async-2.6.1/gulpfile.js 0000664 0000000 0000000 00000000203 13466145133 0015562 0 ustar 00root root 0000000 0000000 'use strict';
require('./test/config');
var requireDir = require('require-dir');
requireDir('./gulp/tasks', { recurse: true });
neo-async-2.6.1/index.js 0000664 0000000 0000000 00000000071 13466145133 0015065 0 ustar 00root root 0000000 0000000 'use strict';
module.exports = require('./lib/async');
neo-async-2.6.1/lib/ 0000775 0000000 0000000 00000000000 13466145133 0014170 5 ustar 00root root 0000000 0000000 neo-async-2.6.1/lib/async.js 0000664 0000000 0000000 00000713024 13466145133 0015652 0 ustar 00root root 0000000 0000000 (function(global, factory) {
/*jshint -W030 */
'use strict';
typeof exports === 'object' && typeof module !== 'undefined'
? factory(exports)
: typeof define === 'function' && define.amd
? define(['exports'], factory)
: global.async
? factory((global.neo_async = global.neo_async || {}))
: factory((global.async = global.async || {}));
})(this, function(exports) {
'use strict';
var noop = function noop() {};
var throwError = function throwError() {
throw new Error('Callback was already called.');
};
var DEFAULT_TIMES = 5;
var DEFAULT_INTERVAL = 0;
var obj = 'object';
var func = 'function';
var isArray = Array.isArray;
var nativeKeys = Object.keys;
var nativePush = Array.prototype.push;
var iteratorSymbol = typeof Symbol === func && Symbol.iterator;
var nextTick, asyncNextTick, asyncSetImmediate;
createImmediate();
/**
* @memberof async
* @namespace each
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done();
* }, num * 10);
* };
* async.each(array, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done();
* }, num * 10);
* };
* async.each(array, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [[1, 0], [2, 2], [3, 1]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done();
* }, num * 10);
* };
* async.each(object, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done();
* }, num * 10);
* };
* async.each(object, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
* });
*
* @example
*
* // break
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num !== 2);
* }, num * 10);
* };
* async.each(array, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [1, 2]
* });
*
*/
var each = createEach(arrayEach, baseEach, symbolEach);
/**
* @memberof async
* @namespace map
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.map(array, iterator, function(err, res) {
* console.log(res); // [1, 3, 2];
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num);
* }, num * 10);
* };
* async.map(array, iterator, function(err, res) {
* console.log(res); // [1, 3, 2]
* console.log(order); // [[1, 0], [2, 2], [3, 1]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.map(object, iterator, function(err, res) {
* console.log(res); // [1, 3, 2]
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num);
* }, num * 10);
* };
* async.map(object, iterator, function(err, res) {
* console.log(res); // [1, 3, 2]
* console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
* });
*
*/
var map = createMap(arrayEachIndex, baseEachIndex, symbolEachIndex, true);
/**
* @memberof async
* @namespace mapValues
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.mapValues(array, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 3, '2': 2 }
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num);
* }, num * 10);
* };
* async.mapValues(array, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 3, '2': 2 }
* console.log(order); // [[1, 0], [2, 2], [3, 1]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.mapValues(object, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 3, c: 2 }
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num);
* }, num * 10);
* };
* async.mapValues(object, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 3, c: 2 }
* console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
* });
*
*/
var mapValues = createMap(arrayEachIndex, baseEachKey, symbolEachKey, false);
/**
* @memberof async
* @namespace filter
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.filter(array, iterator, function(err, res) {
* console.log(res); // [1, 3];
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.filter(array, iterator, function(err, res) {
* console.log(res); // [1, 3];
* console.log(order); // [[1, 0], [2, 2], [3, 1]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.filter(object, iterator, function(err, res) {
* console.log(res); // [1, 3];
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.filter(object, iterator, function(err, res) {
* console.log(res); // [1, 3];
* console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
* });
*
*/
var filter = createFilter(arrayEachIndexValue, baseEachIndexValue, symbolEachIndexValue, true);
/**
* @memberof async
* @namespace filterSeries
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.filterSeries(array, iterator, function(err, res) {
* console.log(res); // [1, 3];
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.filterSeries(array, iterator, function(err, res) {
* console.log(res); // [1, 3]
* console.log(order); // [[1, 0], [3, 1], [2, 2]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.filterSeries(object, iterator, function(err, res) {
* console.log(res); // [1, 3]
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.filterSeries(object, iterator, function(err, res) {
* console.log(res); // [1, 3]
* console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]
* });
*
*/
var filterSeries = createFilterSeries(true);
/**
* @memberof async
* @namespace filterLimit
* @param {Array|Object} collection
* @param {number} limit - limit >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.filterLimit(array, 2, iterator, function(err, res) {
* console.log(res); // [1, 5, 3]
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.filterLimit(array, 2, iterator, function(err, res) {
* console.log(res); // [1, 5, 3]
* console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.filterLimit(object, 2, iterator, function(err, res) {
* console.log(res); // [1, 5, 3]
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.filterLimit(object, 2, iterator, function(err, res) {
* console.log(res); // [1, 5, 3]
* console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
* });
*
*/
var filterLimit = createFilterLimit(true);
/**
* @memberof async
* @namespace reject
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.reject(array, iterator, function(err, res) {
* console.log(res); // [2];
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.reject(array, iterator, function(err, res) {
* console.log(res); // [2];
* console.log(order); // [[1, 0], [2, 2], [3, 1]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.reject(object, iterator, function(err, res) {
* console.log(res); // [2];
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.reject(object, iterator, function(err, res) {
* console.log(res); // [2];
* console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
* });
*
*/
var reject = createFilter(arrayEachIndexValue, baseEachIndexValue, symbolEachIndexValue, false);
/**
* @memberof async
* @namespace rejectSeries
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.rejectSeries(array, iterator, function(err, res) {
* console.log(res); // [2];
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.rejectSeries(object, iterator, function(err, res) {
* console.log(res); // [2];
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.rejectSeries(object, iterator, function(err, res) {
* console.log(res); // [2];
* console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]
* });
*
*/
var rejectSeries = createFilterSeries(false);
/**
* @memberof async
* @namespace rejectLimit
* @param {Array|Object} collection
* @param {number} limit - limit >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.rejectLimit(array, 2, iterator, function(err, res) {
* console.log(res); // [4, 2]
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.rejectLimit(array, 2, iterator, function(err, res) {
* console.log(res); // [4, 2]
* console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.rejectLimit(object, 2, iterator, function(err, res) {
* console.log(res); // [4, 2]
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.rejectLimit(object, 2, iterator, function(err, res) {
* console.log(res); // [4, 2]
* console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
* });
*
*/
var rejectLimit = createFilterLimit(false);
/**
* @memberof async
* @namespace detect
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.detect(array, iterator, function(err, res) {
* console.log(res); // 1
* console.log(order); // [1]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.detect(array, iterator, function(err, res) {
* console.log(res); // 1
* console.log(order); // [[1, 0]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.detect(object, iterator, function(err, res) {
* console.log(res); // 1
* console.log(order); // [1]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.detect(object, iterator, function(err, res) {
* console.log(res); // 1
* console.log(order); // [[1, 'a']]
* });
*
*/
var detect = createDetect(arrayEachValue, baseEachValue, symbolEachValue, true);
/**
* @memberof async
* @namespace detectSeries
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.detectSeries(array, iterator, function(err, res) {
* console.log(res); // 1
* console.log(order); // [1]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.detectSeries(array, iterator, function(err, res) {
* console.log(res); // 1
* console.log(order); // [[1, 0]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.detectSeries(object, iterator, function(err, res) {
* console.log(res); // 1
* console.log(order); // [1]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.detectSeries(object, iterator, function(err, res) {
* console.log(res); // 1
* console.log(order); // [[1, 'a']]
* });
*
*/
var detectSeries = createDetectSeries(true);
/**
* @memberof async
* @namespace detectLimit
* @param {Array|Object} collection
* @param {number} limit - limit >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.detectLimit(array, 2, iterator, function(err, res) {
* console.log(res); // 1
* console.log(order); // [1]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.detectLimit(array, 2, iterator, function(err, res) {
* console.log(res); // 1
* console.log(order); // [[1, 0]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.detectLimit(object, 2, iterator, function(err, res) {
* console.log(res); // 1
* console.log(order); // [1]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.detectLimit(object, 2, iterator, function(err, res) {
* console.log(res); // 1
* console.log(order); // [[1, 'a']]
* });
*
*/
var detectLimit = createDetectLimit(true);
/**
* @memberof async
* @namespace every
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.every(array, iterator, function(err, res) {
* console.log(res); // false
* console.log(order); // [1, 2]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.every(array, iterator, function(err, res) {
* console.log(res); // false
* console.log(order); // [[1, 0], [2, 2]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.every(object, iterator, function(err, res) {
* console.log(res); // false
* console.log(order); // [1, 2]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.every(object, iterator, function(err, res) {
* console.log(res); // false
* console.log(order); // [[1, 'a'], [2, 'c']]
* });
*
*/
var every = createEvery(arrayEachValue, baseEachValue, symbolEachValue);
/**
* @memberof async
* @namespace everySeries
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.everySeries(array, iterator, function(err, res) {
* console.log(res); // false
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.everySeries(array, iterator, function(err, res) {
* console.log(res); // false
* console.log(order); // [[1, 0], [3, 1], [2, 2]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.everySeries(object, iterator, function(err, res) {
* console.log(res); // false
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.everySeries(object, iterator, function(err, res) {
* console.log(res); // false
* console.log(order); // [[1, 'a'], [3, 'b'] [2, 'c']]
* });
*
*/
var everySeries = createEverySeries();
/**
* @memberof async
* @namespace everyLimit
* @param {Array|Object} collection
* @param {number} limit - limit >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.everyLimit(array, 2, iterator, function(err, res) {
* console.log(res); // false
* console.log(order); // [1, 3, 5, 2]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.everyLimit(array, 2, iterator, function(err, res) {
* console.log(res); // false
* console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.everyLimit(object, 2, iterator, function(err, res) {
* console.log(res); // false
* console.log(order); // [1, 3, 5, 2]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.everyLimit(object, 2, iterator, function(err, res) {
* console.log(res); // false
* console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e']]
* });
*
*/
var everyLimit = createEveryLimit();
/**
* @memberof async
* @namespace pick
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2, 4];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.pick(array, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 3 }
* console.log(order); // [1, 2, 3, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2, 4];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.pick(array, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 3 }
* console.log(order); // [[0, 1], [2, 2], [3, 1], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.pick(object, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 3 }
* console.log(order); // [1, 2, 3, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.pick(object, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 3 }
* console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b'], [4, 'd']]
* });
*
*/
var pick = createPick(arrayEachIndexValue, baseEachKeyValue, symbolEachKeyValue, true);
/**
* @memberof async
* @namespace pickSeries
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2, 4];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.pickSeries(array, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 3 }
* console.log(order); // [1, 3, 2, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2, 4];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.pickSeries(array, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 3 }
* console.log(order); // [[0, 1], [3, 1], [2, 2], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.pickSeries(object, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 3 }
* console.log(order); // [1, 3, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.pickSeries(object, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 3 }
* console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c'], [4, 'd']]
* });
*
*/
var pickSeries = createPickSeries(true);
/**
* @memberof async
* @namespace pickLimit
* @param {Array|Object} collection
* @param {number} limit - limit >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.pickLimit(array, 2, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 5, '2': 3 }
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.pickLimit(array, 2, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 5, '2': 3 }
* console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.pickLimit(object, 2, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 5, c: 3 }
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.pickLimit(object, 2, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 5, c: 3 }
* console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
* });
*
*/
var pickLimit = createPickLimit(true);
/**
* @memberof async
* @namespace omit
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2, 4];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.omit(array, iterator, function(err, res) {
* console.log(res); // { '2': 2, '3': 4 }
* console.log(order); // [1, 2, 3, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2, 4];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.omit(array, iterator, function(err, res) {
* console.log(res); // { '2': 2, '3': 4 }
* console.log(order); // [[0, 1], [2, 2], [3, 1], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.omit(object, iterator, function(err, res) {
* console.log(res); // { c: 2, d: 4 }
* console.log(order); // [1, 2, 3, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.omit(object, iterator, function(err, res) {
* console.log(res); // { c: 2, d: 4 }
* console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b'], [4, 'd']]
* });
*
*/
var omit = createPick(arrayEachIndexValue, baseEachKeyValue, symbolEachKeyValue, false);
/**
* @memberof async
* @namespace omitSeries
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2, 4];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.omitSeries(array, iterator, function(err, res) {
* console.log(res); // { '2': 2, '3': 4 }
* console.log(order); // [1, 3, 2, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2, 4];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.omitSeries(array, iterator, function(err, res) {
* console.log(res); // { '2': 2, '3': 4 }
* console.log(order); // [[0, 1], [3, 1], [2, 2], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.omitSeries(object, iterator, function(err, res) {
* console.log(res); // { c: 2, d: 4 }
* console.log(order); // [1, 3, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.omitSeries(object, iterator, function(err, res) {
* console.log(res); // { c: 2, d: 4 }
* console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c'], [4, 'd']]
* });
*
*/
var omitSeries = createPickSeries(false);
/**
* @memberof async
* @namespace omitLimit
* @param {Array|Object} collection
* @param {number} limit - limit >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.omitLimit(array, 2, iterator, function(err, res) {
* console.log(res); // { '3': 4, '4': 2 }
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.omitLimit(array, 2, iterator, function(err, res) {
* console.log(res); // { '3': 4, '4': 2 }
* console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.omitLimit(object, 2, iterator, function(err, res) {
* console.log(res); // { d: 4, e: 2 }
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.omitLimit(object, 2, iterator, function(err, res) {
* console.log(res); // { d: 4, e: 2 }
* console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
* });
*
*/
var omitLimit = createPickLimit(false);
/**
* @memberof async
* @namespace transform
* @param {Array|Object} collection
* @param {Array|Object|Function} [accumulator]
* @param {Function} [iterator]
* @param {Function} [callback]
* @example
*
* // array
* var order = [];
* var collection = [1, 3, 2, 4];
* var iterator = function(result, num, done) {
* setTimeout(function() {
* order.push(num);
* result.push(num)
* done();
* }, num * 10);
* };
* async.transform(collection, iterator, function(err, res) {
* console.log(res); // [1, 2, 3, 4]
* console.log(order); // [1, 2, 3, 4]
* });
*
* @example
*
* // array with index and accumulator
* var order = [];
* var collection = [1, 3, 2, 4];
* var iterator = function(result, num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* result[index] = num;
* done();
* }, num * 10);
* };
* async.transform(collection, {}, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 3, '2': 2, '3': 4 }
* console.log(order); // [[1, 0], [2, 2], [3, 1], [4, 3]]
* });
*
* @example
*
* // object with accumulator
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(result, num, done) {
* setTimeout(function() {
* order.push(num);
* result.push(num);
* done();
* }, num * 10);
* };
* async.transform(collection, [], iterator, function(err, res) {
* console.log(res); // [1, 2, 3, 4]
* console.log(order); // [1, 2, 3, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(result, num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* result[key] = num;
* done();
* }, num * 10);
* };
* async.transform(collection, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 3, c: 2, d: 4 }
* console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b'], [4, 'd']]
* });
*
*/
var transform = createTransform(arrayEachResult, baseEachResult, symbolEachResult);
/**
* @memberof async
* @namespace sortBy
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.sortBy(array, iterator, function(err, res) {
* console.log(res); // [1, 2, 3];
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num);
* }, num * 10);
* };
* async.sortBy(array, iterator, function(err, res) {
* console.log(res); // [1, 2, 3]
* console.log(order); // [[1, 0], [2, 2], [3, 1]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.sortBy(object, iterator, function(err, res) {
* console.log(res); // [1, 2, 3]
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num);
* }, num * 10);
* };
* async.sortBy(object, iterator, function(err, res) {
* console.log(res); // [1, 2, 3]
* console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
* });
*
*/
var sortBy = createSortBy(arrayEachIndexValue, baseEachIndexValue, symbolEachIndexValue);
/**
* @memberof async
* @namespace concat
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, [num]);
* }, num * 10);
* };
* async.concat(array, iterator, function(err, res) {
* console.log(res); // [1, 2, 3];
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, [num]);
* }, num * 10);
* };
* async.concat(array, iterator, function(err, res) {
* console.log(res); // [1, 2, 3]
* console.log(order); // [[1, 0], [2, 2], [3, 1]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, [num]);
* }, num * 10);
* };
* async.concat(object, iterator, function(err, res) {
* console.log(res); // [1, 2, 3]
* console.log(order); // [1, 2, 3]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, [num]);
* }, num * 10);
* };
* async.concat(object, iterator, function(err, res) {
* console.log(res); // [1, 2, 3]
* console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
* });
*
*/
var concat = createConcat(arrayEachIndex, baseEachIndex, symbolEachIndex);
/**
* @memberof async
* @namespace groupBy
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [4.2, 6.4, 6.1];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, Math.floor(num));
* }, num * 10);
* };
* async.groupBy(array, iterator, function(err, res) {
* console.log(res); // { '4': [4.2], '6': [6.1, 6.4] }
* console.log(order); // [4.2, 6.1, 6.4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [4.2, 6.4, 6.1];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, Math.floor(num));
* }, num * 10);
* };
* async.groupBy(array, iterator, function(err, res) {
* console.log(res); // { '4': [4.2], '6': [6.1, 6.4] }
* console.log(order); // [[4.2, 0], [6.1, 2], [6.4, 1]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 4.2, b: 6.4, c: 6.1 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, Math.floor(num));
* }, num * 10);
* };
* async.groupBy(object, iterator, function(err, res) {
* console.log(res); // { '4': [4.2], '6': [6.1, 6.4] }
* console.log(order); // [4.2, 6.1, 6.4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 4.2, b: 6.4, c: 6.1 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, Math.floor(num));
* }, num * 10);
* };
* async.groupBy(object, iterator, function(err, res) {
* console.log(res); // { '4': [4.2], '6': [6.1, 6.4] }
* console.log(order); // [[4.2, 'a'], [6.1, 'c'], [6.4, 'b']]
* });
*
*/
var groupBy = createGroupBy(arrayEachValue, baseEachValue, symbolEachValue);
/**
* @memberof async
* @namespace parallel
* @param {Array|Object} tasks - functions
* @param {Function} callback
* @example
*
* var order = [];
* var tasks = [
* function(done) {
* setTimeout(function() {
* order.push(1);
* done(null, 1);
* }, 10);
* },
* function(done) {
* setTimeout(function() {
* order.push(2);
* done(null, 2);
* }, 30);
* },
* function(done) {
* setTimeout(function() {
* order.push(3);
* done(null, 3);
* }, 40);
* },
* function(done) {
* setTimeout(function() {
* order.push(4);
* done(null, 4);
* }, 20);
* }
* ];
* async.parallel(tasks, function(err, res) {
* console.log(res); // [1, 2, 3, 4];
* console.log(order); // [1, 4, 2, 3]
* });
*
* @example
*
* var order = [];
* var tasks = {
* 'a': function(done) {
* setTimeout(function() {
* order.push(1);
* done(null, 1);
* }, 10);
* },
* 'b': function(done) {
* setTimeout(function() {
* order.push(2);
* done(null, 2);
* }, 30);
* },
* 'c': function(done) {
* setTimeout(function() {
* order.push(3);
* done(null, 3);
* }, 40);
* },
* 'd': function(done) {
* setTimeout(function() {
* order.push(4);
* done(null, 4);
* }, 20);
* }
* };
* async.parallel(tasks, function(err, res) {
* console.log(res); // { a: 1, b: 2, c: 3, d:4 }
* console.log(order); // [1, 4, 2, 3]
* });
*
*/
var parallel = createParallel(arrayEachFunc, baseEachFunc);
/**
* @memberof async
* @namespace applyEach
*/
var applyEach = createApplyEach(map);
/**
* @memberof async
* @namespace applyEachSeries
*/
var applyEachSeries = createApplyEach(mapSeries);
/**
* @memberof async
* @namespace log
*/
var log = createLogger('log');
/**
* @memberof async
* @namespace dir
*/
var dir = createLogger('dir');
/**
* @version 2.6.1
* @namespace async
*/
var index = {
VERSION: '2.6.1',
// Collections
each: each,
eachSeries: eachSeries,
eachLimit: eachLimit,
forEach: each,
forEachSeries: eachSeries,
forEachLimit: eachLimit,
eachOf: each,
eachOfSeries: eachSeries,
eachOfLimit: eachLimit,
forEachOf: each,
forEachOfSeries: eachSeries,
forEachOfLimit: eachLimit,
map: map,
mapSeries: mapSeries,
mapLimit: mapLimit,
mapValues: mapValues,
mapValuesSeries: mapValuesSeries,
mapValuesLimit: mapValuesLimit,
filter: filter,
filterSeries: filterSeries,
filterLimit: filterLimit,
select: filter,
selectSeries: filterSeries,
selectLimit: filterLimit,
reject: reject,
rejectSeries: rejectSeries,
rejectLimit: rejectLimit,
detect: detect,
detectSeries: detectSeries,
detectLimit: detectLimit,
find: detect,
findSeries: detectSeries,
findLimit: detectLimit,
pick: pick,
pickSeries: pickSeries,
pickLimit: pickLimit,
omit: omit,
omitSeries: omitSeries,
omitLimit: omitLimit,
reduce: reduce,
inject: reduce,
foldl: reduce,
reduceRight: reduceRight,
foldr: reduceRight,
transform: transform,
transformSeries: transformSeries,
transformLimit: transformLimit,
sortBy: sortBy,
sortBySeries: sortBySeries,
sortByLimit: sortByLimit,
some: some,
someSeries: someSeries,
someLimit: someLimit,
any: some,
anySeries: someSeries,
anyLimit: someLimit,
every: every,
everySeries: everySeries,
everyLimit: everyLimit,
all: every,
allSeries: everySeries,
allLimit: everyLimit,
concat: concat,
concatSeries: concatSeries,
concatLimit: concatLimit,
groupBy: groupBy,
groupBySeries: groupBySeries,
groupByLimit: groupByLimit,
// Control Flow
parallel: parallel,
series: series,
parallelLimit: parallelLimit,
tryEach: tryEach,
waterfall: waterfall,
angelFall: angelFall,
angelfall: angelFall,
whilst: whilst,
doWhilst: doWhilst,
until: until,
doUntil: doUntil,
during: during,
doDuring: doDuring,
forever: forever,
compose: compose,
seq: seq,
applyEach: applyEach,
applyEachSeries: applyEachSeries,
queue: queue,
priorityQueue: priorityQueue,
cargo: cargo,
auto: auto,
autoInject: autoInject,
retry: retry,
retryable: retryable,
iterator: iterator,
times: times,
timesSeries: timesSeries,
timesLimit: timesLimit,
race: race,
// Utils
apply: apply,
nextTick: asyncNextTick,
setImmediate: asyncSetImmediate,
memoize: memoize,
unmemoize: unmemoize,
ensureAsync: ensureAsync,
constant: constant,
asyncify: asyncify,
wrapSync: asyncify,
log: log,
dir: dir,
reflect: reflect,
reflectAll: reflectAll,
timeout: timeout,
createLogger: createLogger,
// Mode
safe: safe,
fast: fast
};
exports['default'] = index;
baseEachSync(
index,
function(func, key) {
exports[key] = func;
},
nativeKeys(index)
);
/**
* @private
*/
function createImmediate(safeMode) {
var delay = function delay(fn) {
var args = slice(arguments, 1);
setTimeout(function() {
fn.apply(null, args);
});
};
asyncSetImmediate = typeof setImmediate === func ? setImmediate : delay;
if (typeof process === obj && typeof process.nextTick === func) {
nextTick = /^v0.10/.test(process.version) ? asyncSetImmediate : process.nextTick;
asyncNextTick = /^v0/.test(process.version) ? asyncSetImmediate : process.nextTick;
} else {
asyncNextTick = nextTick = asyncSetImmediate;
}
if (safeMode === false) {
nextTick = function(cb) {
cb();
};
}
}
/* sync functions based on lodash */
/**
* Converts `arguments` to an array.
*
* @private
* @param {Array} array = The array to slice.
*/
function createArray(array) {
var index = -1;
var size = array.length;
var result = Array(size);
while (++index < size) {
result[index] = array[index];
}
return result;
}
/**
* Create an array from `start`
*
* @private
* @param {Array} array - The array to slice.
* @param {number} start - The start position.
*/
function slice(array, start) {
var end = array.length;
var index = -1;
var size = end - start;
if (size <= 0) {
return [];
}
var result = Array(size);
while (++index < size) {
result[index] = array[index + start];
}
return result;
}
/**
* @private
* @param {Object} object
*/
function objectClone(object) {
var keys = nativeKeys(object);
var size = keys.length;
var index = -1;
var result = {};
while (++index < size) {
var key = keys[index];
result[key] = object[key];
}
return result;
}
/**
* Create an array with all falsey values removed.
*
* @private
* @param {Array} array - The array to compact.
*/
function compact(array) {
var index = -1;
var size = array.length;
var result = [];
while (++index < size) {
var value = array[index];
if (value) {
result[result.length] = value;
}
}
return result;
}
/**
* Create an array of reverse sequence.
*
* @private
* @param {Array} array - The array to reverse.
*/
function reverse(array) {
var index = -1;
var size = array.length;
var result = Array(size);
var resIndex = size;
while (++index < size) {
result[--resIndex] = array[index];
}
return result;
}
/**
* Checks if key exists in object property.
*
* @private
* @param {Object} object - The object to inspect.
* @param {string} key - The key to check.
*/
function has(object, key) {
return object.hasOwnProperty(key);
}
/**
* Check if target exists in array.
* @private
* @param {Array} array
* @param {*} target
*/
function notInclude(array, target) {
var index = -1;
var size = array.length;
while (++index < size) {
if (array[index] === target) {
return false;
}
}
return true;
}
/**
* @private
* @param {Array} array - The array to iterate over.
* @param {Function} iterator - The function invoked per iteration.
*/
function arrayEachSync(array, iterator) {
var index = -1;
var size = array.length;
while (++index < size) {
iterator(array[index], index);
}
return array;
}
/**
* @private
* @param {Object} object - The object to iterate over.
* @param {Function} iterator - The function invoked per iteration.
* @param {Array} keys
*/
function baseEachSync(object, iterator, keys) {
var index = -1;
var size = keys.length;
while (++index < size) {
var key = keys[index];
iterator(object[key], key);
}
return object;
}
/**
* @private
* @param {number} n
* @param {Function} iterator
*/
function timesSync(n, iterator) {
var index = -1;
while (++index < n) {
iterator(index);
}
}
/**
* @private
* @param {Array} array
* @param {number[]} criteria
*/
function sortByCriteria(array, criteria) {
var l = array.length;
var indices = Array(l);
var i;
for (i = 0; i < l; i++) {
indices[i] = i;
}
quickSort(criteria, 0, l - 1, indices);
var result = Array(l);
for (var n = 0; n < l; n++) {
i = indices[n];
result[n] = i === undefined ? array[n] : array[i];
}
return result;
}
function partition(array, i, j, mid, indices) {
var l = i;
var r = j;
while (l <= r) {
i = l;
while (l < r && array[l] < mid) {
l++;
}
while (r >= i && array[r] >= mid) {
r--;
}
if (l > r) {
break;
}
swap(array, indices, l++, r--);
}
return l;
}
function swap(array, indices, l, r) {
var n = array[l];
array[l] = array[r];
array[r] = n;
var i = indices[l];
indices[l] = indices[r];
indices[r] = i;
}
function quickSort(array, i, j, indices) {
if (i === j) {
return;
}
var k = i;
while (++k <= j && array[i] === array[k]) {
var l = k - 1;
if (indices[l] > indices[k]) {
var index = indices[l];
indices[l] = indices[k];
indices[k] = index;
}
}
if (k > j) {
return;
}
var p = array[i] > array[k] ? i : k;
k = partition(array, i, j, array[p], indices);
quickSort(array, i, k - 1, indices);
quickSort(array, k, j, indices);
}
/**
* @Private
*/
function makeConcatResult(array) {
var result = [];
arrayEachSync(array, function(value) {
if (value === noop) {
return;
}
if (isArray(value)) {
nativePush.apply(result, value);
} else {
result.push(value);
}
});
return result;
}
/* async functions */
/**
* @private
*/
function arrayEach(array, iterator, callback) {
var index = -1;
var size = array.length;
if (iterator.length === 3) {
while (++index < size) {
iterator(array[index], index, onlyOnce(callback));
}
} else {
while (++index < size) {
iterator(array[index], onlyOnce(callback));
}
}
}
/**
* @private
*/
function baseEach(object, iterator, callback, keys) {
var key;
var index = -1;
var size = keys.length;
if (iterator.length === 3) {
while (++index < size) {
key = keys[index];
iterator(object[key], key, onlyOnce(callback));
}
} else {
while (++index < size) {
iterator(object[keys[index]], onlyOnce(callback));
}
}
}
/**
* @private
*/
function symbolEach(collection, iterator, callback) {
var iter = collection[iteratorSymbol]();
var index = 0;
var item;
if (iterator.length === 3) {
while ((item = iter.next()).done === false) {
iterator(item.value, index++, onlyOnce(callback));
}
} else {
while ((item = iter.next()).done === false) {
index++;
iterator(item.value, onlyOnce(callback));
}
}
return index;
}
/**
* @private
*/
function arrayEachResult(array, result, iterator, callback) {
var index = -1;
var size = array.length;
if (iterator.length === 4) {
while (++index < size) {
iterator(result, array[index], index, onlyOnce(callback));
}
} else {
while (++index < size) {
iterator(result, array[index], onlyOnce(callback));
}
}
}
/**
* @private
*/
function baseEachResult(object, result, iterator, callback, keys) {
var key;
var index = -1;
var size = keys.length;
if (iterator.length === 4) {
while (++index < size) {
key = keys[index];
iterator(result, object[key], key, onlyOnce(callback));
}
} else {
while (++index < size) {
iterator(result, object[keys[index]], onlyOnce(callback));
}
}
}
/**
* @private
*/
function symbolEachResult(collection, result, iterator, callback) {
var item;
var index = 0;
var iter = collection[iteratorSymbol]();
if (iterator.length === 4) {
while ((item = iter.next()).done === false) {
iterator(result, item.value, index++, onlyOnce(callback));
}
} else {
while ((item = iter.next()).done === false) {
index++;
iterator(result, item.value, onlyOnce(callback));
}
}
return index;
}
/**
* @private
*/
function arrayEachFunc(array, createCallback) {
var index = -1;
var size = array.length;
while (++index < size) {
array[index](createCallback(index));
}
}
/**
* @private
*/
function baseEachFunc(object, createCallback, keys) {
var key;
var index = -1;
var size = keys.length;
while (++index < size) {
key = keys[index];
object[key](createCallback(key));
}
}
/**
* @private
*/
function arrayEachIndex(array, iterator, createCallback) {
var index = -1;
var size = array.length;
if (iterator.length === 3) {
while (++index < size) {
iterator(array[index], index, createCallback(index));
}
} else {
while (++index < size) {
iterator(array[index], createCallback(index));
}
}
}
/**
* @private
*/
function baseEachIndex(object, iterator, createCallback, keys) {
var key;
var index = -1;
var size = keys.length;
if (iterator.length === 3) {
while (++index < size) {
key = keys[index];
iterator(object[key], key, createCallback(index));
}
} else {
while (++index < size) {
iterator(object[keys[index]], createCallback(index));
}
}
}
/**
* @private
*/
function symbolEachIndex(collection, iterator, createCallback) {
var item;
var index = 0;
var iter = collection[iteratorSymbol]();
if (iterator.length === 3) {
while ((item = iter.next()).done === false) {
iterator(item.value, index, createCallback(index++));
}
} else {
while ((item = iter.next()).done === false) {
iterator(item.value, createCallback(index++));
}
}
return index;
}
/**
* @private
*/
function baseEachKey(object, iterator, createCallback, keys) {
var key;
var index = -1;
var size = keys.length;
if (iterator.length === 3) {
while (++index < size) {
key = keys[index];
iterator(object[key], key, createCallback(key));
}
} else {
while (++index < size) {
key = keys[index];
iterator(object[key], createCallback(key));
}
}
}
/**
* @private
*/
function symbolEachKey(collection, iterator, createCallback) {
var item;
var index = 0;
var iter = collection[iteratorSymbol]();
if (iterator.length === 3) {
while ((item = iter.next()).done === false) {
iterator(item.value, index, createCallback(index++));
}
} else {
while ((item = iter.next()).done === false) {
iterator(item.value, createCallback(index++));
}
}
return index;
}
/**
* @private
*/
function arrayEachValue(array, iterator, createCallback) {
var value;
var index = -1;
var size = array.length;
if (iterator.length === 3) {
while (++index < size) {
value = array[index];
iterator(value, index, createCallback(value));
}
} else {
while (++index < size) {
value = array[index];
iterator(value, createCallback(value));
}
}
}
/**
* @private
*/
function baseEachValue(object, iterator, createCallback, keys) {
var key, value;
var index = -1;
var size = keys.length;
if (iterator.length === 3) {
while (++index < size) {
key = keys[index];
value = object[key];
iterator(value, key, createCallback(value));
}
} else {
while (++index < size) {
value = object[keys[index]];
iterator(value, createCallback(value));
}
}
}
/**
* @private
*/
function symbolEachValue(collection, iterator, createCallback) {
var value, item;
var index = 0;
var iter = collection[iteratorSymbol]();
if (iterator.length === 3) {
while ((item = iter.next()).done === false) {
value = item.value;
iterator(value, index++, createCallback(value));
}
} else {
while ((item = iter.next()).done === false) {
index++;
value = item.value;
iterator(value, createCallback(value));
}
}
return index;
}
/**
* @private
*/
function arrayEachIndexValue(array, iterator, createCallback) {
var value;
var index = -1;
var size = array.length;
if (iterator.length === 3) {
while (++index < size) {
value = array[index];
iterator(value, index, createCallback(index, value));
}
} else {
while (++index < size) {
value = array[index];
iterator(value, createCallback(index, value));
}
}
}
/**
* @private
*/
function baseEachIndexValue(object, iterator, createCallback, keys) {
var key, value;
var index = -1;
var size = keys.length;
if (iterator.length === 3) {
while (++index < size) {
key = keys[index];
value = object[key];
iterator(value, key, createCallback(index, value));
}
} else {
while (++index < size) {
value = object[keys[index]];
iterator(value, createCallback(index, value));
}
}
}
/**
* @private
*/
function symbolEachIndexValue(collection, iterator, createCallback) {
var value, item;
var index = 0;
var iter = collection[iteratorSymbol]();
if (iterator.length === 3) {
while ((item = iter.next()).done === false) {
value = item.value;
iterator(value, index, createCallback(index++, value));
}
} else {
while ((item = iter.next()).done === false) {
value = item.value;
iterator(value, createCallback(index++, value));
}
}
return index;
}
/**
* @private
*/
function baseEachKeyValue(object, iterator, createCallback, keys) {
var key, value;
var index = -1;
var size = keys.length;
if (iterator.length === 3) {
while (++index < size) {
key = keys[index];
value = object[key];
iterator(value, key, createCallback(key, value));
}
} else {
while (++index < size) {
key = keys[index];
value = object[key];
iterator(value, createCallback(key, value));
}
}
}
/**
* @private
*/
function symbolEachKeyValue(collection, iterator, createCallback) {
var value, item;
var index = 0;
var iter = collection[iteratorSymbol]();
if (iterator.length === 3) {
while ((item = iter.next()).done === false) {
value = item.value;
iterator(value, index, createCallback(index++, value));
}
} else {
while ((item = iter.next()).done === false) {
value = item.value;
iterator(value, createCallback(index++, value));
}
}
return index;
}
/**
* @private
* @param {Function} func
*/
function onlyOnce(func) {
return function(err, res) {
var fn = func;
func = throwError;
fn(err, res);
};
}
/**
* @private
* @param {Function} func
*/
function once(func) {
return function(err, res) {
var fn = func;
func = noop;
fn(err, res);
};
}
/**
* @private
* @param {Function} arrayEach
* @param {Function} baseEach
*/
function createEach(arrayEach, baseEach, symbolEach) {
return function each(collection, iterator, callback) {
callback = once(callback || noop);
var size, keys;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
arrayEach(collection, iterator, done);
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = symbolEach(collection, iterator, done);
size && size === completed && callback(null);
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
baseEach(collection, iterator, done, keys);
}
if (!size) {
callback(null);
}
function done(err, bool) {
if (err) {
callback = once(callback);
callback(err);
} else if (++completed === size) {
callback(null);
} else if (bool === false) {
callback = once(callback);
callback(null);
}
}
};
}
/**
* @private
* @param {Function} arrayEach
* @param {Function} baseEach
* @param {Function} symbolEach
*/
function createMap(arrayEach, baseEach, symbolEach, useArray) {
var init, clone;
if (useArray) {
init = Array;
clone = createArray;
} else {
init = function() {
return {};
};
clone = objectClone;
}
return function(collection, iterator, callback) {
callback = callback || noop;
var size, keys, result;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
result = init(size);
arrayEach(collection, iterator, createCallback);
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
// TODO: size could be changed
result = init(0);
size = symbolEach(collection, iterator, createCallback);
size && size === completed && callback(null, result);
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
result = init(size);
baseEach(collection, iterator, createCallback, keys);
}
if (!size) {
callback(null, init());
}
function createCallback(key) {
return function done(err, res) {
if (key === null) {
throwError();
}
if (err) {
key = null;
callback = once(callback);
callback(err, clone(result));
return;
}
result[key] = res;
key = null;
if (++completed === size) {
callback(null, result);
}
};
}
};
}
/**
* @private
* @param {Function} arrayEach
* @param {Function} baseEach
* @param {Function} symbolEach
* @param {boolean} bool
*/
function createFilter(arrayEach, baseEach, symbolEach, bool) {
return function(collection, iterator, callback) {
callback = callback || noop;
var size, keys, result;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
result = Array(size);
arrayEach(collection, iterator, createCallback);
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
result = [];
size = symbolEach(collection, iterator, createCallback);
size && size === completed && callback(null, compact(result));
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
result = Array(size);
baseEach(collection, iterator, createCallback, keys);
}
if (!size) {
return callback(null, []);
}
function createCallback(index, value) {
return function done(err, res) {
if (index === null) {
throwError();
}
if (err) {
index = null;
callback = once(callback);
callback(err);
return;
}
if (!!res === bool) {
result[index] = value;
}
index = null;
if (++completed === size) {
callback(null, compact(result));
}
};
}
};
}
/**
* @private
* @param {boolean} bool
*/
function createFilterSeries(bool) {
return function(collection, iterator, callback) {
callback = onlyOnce(callback || noop);
var size, key, value, keys, iter, item, iterate;
var sync = false;
var completed = 0;
var result = [];
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size) {
return callback(null, []);
}
iterate();
function arrayIterator() {
value = collection[completed];
iterator(value, done);
}
function arrayIteratorWithIndex() {
value = collection[completed];
iterator(value, completed, done);
}
function symbolIterator() {
item = iter.next();
value = item.value;
item.done ? callback(null, result) : iterator(value, done);
}
function symbolIteratorWithKey() {
item = iter.next();
value = item.value;
item.done ? callback(null, result) : iterator(value, completed, done);
}
function objectIterator() {
key = keys[completed];
value = collection[key];
iterator(value, done);
}
function objectIteratorWithKey() {
key = keys[completed];
value = collection[key];
iterator(value, key, done);
}
function done(err, res) {
if (err) {
callback(err);
return;
}
if (!!res === bool) {
result[result.length] = value;
}
if (++completed === size) {
iterate = throwError;
callback(null, result);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
};
}
/**
* @private
* @param {boolean} bool
*/
function createFilterLimit(bool) {
return function(collection, limit, iterator, callback) {
callback = callback || noop;
var size, index, key, value, keys, iter, item, iterate, result;
var sync = false;
var started = 0;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
result = [];
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size || isNaN(limit) || limit < 1) {
return callback(null, []);
}
result = result || Array(size);
timesSync(limit > size ? size : limit, iterate);
function arrayIterator() {
index = started++;
if (index < size) {
value = collection[index];
iterator(value, createCallback(value, index));
}
}
function arrayIteratorWithIndex() {
index = started++;
if (index < size) {
value = collection[index];
iterator(value, index, createCallback(value, index));
}
}
function symbolIterator() {
item = iter.next();
if (item.done === false) {
value = item.value;
iterator(value, createCallback(value, started++));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, compact(result));
}
}
function symbolIteratorWithKey() {
item = iter.next();
if (item.done === false) {
value = item.value;
iterator(value, started, createCallback(value, started++));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, compact(result));
}
}
function objectIterator() {
index = started++;
if (index < size) {
value = collection[keys[index]];
iterator(value, createCallback(value, index));
}
}
function objectIteratorWithKey() {
index = started++;
if (index < size) {
key = keys[index];
value = collection[key];
iterator(value, key, createCallback(value, index));
}
}
function createCallback(value, index) {
return function(err, res) {
if (index === null) {
throwError();
}
if (err) {
index = null;
iterate = noop;
callback = once(callback);
callback(err);
return;
}
if (!!res === bool) {
result[index] = value;
}
index = null;
if (++completed === size) {
callback = onlyOnce(callback);
callback(null, compact(result));
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
};
}
};
}
/**
* @memberof async
* @namespace eachSeries
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done();
* }, num * 10);
* };
* async.eachSeries(array, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done();
* }, num * 10);
* };
* async.eachSeries(array, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [[1, 0], [3, 1], [2, 2]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done();
* }, num * 10);
* };
* async.eachSeries(object, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done();
* }, num * 10);
* };
* async.eachSeries(object, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [[1, 'a'], [3, 'b'], [2, 'b']]
* });
*
* @example
*
* // break
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num !== 3);
* }, num * 10);
* };
* async.eachSeries(array, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [1, 3]
* });
*/
function eachSeries(collection, iterator, callback) {
callback = onlyOnce(callback || noop);
var size, key, keys, iter, item, iterate;
var sync = false;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size) {
return callback(null);
}
iterate();
function arrayIterator() {
iterator(collection[completed], done);
}
function arrayIteratorWithIndex() {
iterator(collection[completed], completed, done);
}
function symbolIterator() {
item = iter.next();
item.done ? callback(null) : iterator(item.value, done);
}
function symbolIteratorWithKey() {
item = iter.next();
item.done ? callback(null) : iterator(item.value, completed, done);
}
function objectIterator() {
iterator(collection[keys[completed]], done);
}
function objectIteratorWithKey() {
key = keys[completed];
iterator(collection[key], key, done);
}
function done(err, bool) {
if (err) {
callback(err);
} else if (++completed === size || bool === false) {
iterate = throwError;
callback(null);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* @memberof async
* @namespace eachLimit
* @param {Array|Object} collection
* @param {number} limit - limit >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done();
* }, num * 10);
* };
* async.eachLimit(array, 2, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done();
* }, num * 10);
* };
* async.eachLimit(array, 2, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done();
* }, num * 10);
* };
* async.eachLimit(object, 2, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done();
* }, num * 10);
* };
* async.eachLimit(object, 2, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
* });
*
* @example
*
* // break
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num !== 5);
* }, num * 10);
* };
* async.eachLimit(array, 2, iterator, function(err, res) {
* console.log(res); // undefined
* console.log(order); // [1, 3, 5]
* });
*
*/
function eachLimit(collection, limit, iterator, callback) {
callback = callback || noop;
var size, index, key, keys, iter, item, iterate;
var sync = false;
var started = 0;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
} else {
return callback(null);
}
if (!size || isNaN(limit) || limit < 1) {
return callback(null);
}
timesSync(limit > size ? size : limit, iterate);
function arrayIterator() {
if (started < size) {
iterator(collection[started++], done);
}
}
function arrayIteratorWithIndex() {
index = started++;
if (index < size) {
iterator(collection[index], index, done);
}
}
function symbolIterator() {
item = iter.next();
if (item.done === false) {
started++;
iterator(item.value, done);
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null);
}
}
function symbolIteratorWithKey() {
item = iter.next();
if (item.done === false) {
iterator(item.value, started++, done);
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null);
}
}
function objectIterator() {
if (started < size) {
iterator(collection[keys[started++]], done);
}
}
function objectIteratorWithKey() {
index = started++;
if (index < size) {
key = keys[index];
iterator(collection[key], key, done);
}
}
function done(err, bool) {
if (err || bool === false) {
iterate = noop;
callback = once(callback);
callback(err);
} else if (++completed === size) {
iterator = noop;
iterate = throwError;
callback = onlyOnce(callback);
callback(null);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* @memberof async
* @namespace mapSeries
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.mapSeries(array, iterator, function(err, res) {
* console.log(res); // [1, 3, 2];
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num);
* }, num * 10);
* };
* async.mapSeries(array, iterator, function(err, res) {
* console.log(res); // [1, 3, 2]
* console.log(order); // [[1, 0], [3, 1], [2, 2]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.mapSeries(object, iterator, function(err, res) {
* console.log(res); // [1, 3, 2]
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num);
* }, num * 10);
* };
* async.mapSeries(object, iterator, function(err, res) {
* console.log(res); // [1, 3, 2]
* console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]
* });
*
*/
function mapSeries(collection, iterator, callback) {
callback = callback || noop;
var size, key, keys, iter, item, result, iterate;
var sync = false;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
result = [];
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size) {
return callback(null, []);
}
result = result || Array(size);
iterate();
function arrayIterator() {
iterator(collection[completed], done);
}
function arrayIteratorWithIndex() {
iterator(collection[completed], completed, done);
}
function symbolIterator() {
item = iter.next();
item.done ? callback(null, result) : iterator(item.value, done);
}
function symbolIteratorWithKey() {
item = iter.next();
item.done ? callback(null, result) : iterator(item.value, completed, done);
}
function objectIterator() {
iterator(collection[keys[completed]], done);
}
function objectIteratorWithKey() {
key = keys[completed];
iterator(collection[key], key, done);
}
function done(err, res) {
if (err) {
iterate = throwError;
callback = onlyOnce(callback);
callback(err, createArray(result));
return;
}
result[completed] = res;
if (++completed === size) {
iterate = throwError;
callback(null, result);
callback = throwError;
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* @memberof async
* @namespace mapLimit
* @param {Array|Object} collection
* @param {number} limit - limit >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.mapLimit(array, 2, iterator, function(err, res) {
* console.log(res); // [1, 5, 3, 4, 2]
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num);
* }, num * 10);
* };
* async.mapLimit(array, 2, iterator, function(err, res) {
* console.log(res); // [1, 5, 3, 4, 2]
* console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.mapLimit(object, 2, iterator, function(err, res) {
* console.log(res); // [1, 5, 3, 4, 2]
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num);
* }, num * 10);
* };
* async.mapLimit(object, 2, iterator, function(err, res) {
* console.log(res); // [1, 5, 3, 4, 2]
* console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
* });
*
*/
function mapLimit(collection, limit, iterator, callback) {
callback = callback || noop;
var size, index, key, keys, iter, item, result, iterate;
var sync = false;
var started = 0;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
result = [];
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size || isNaN(limit) || limit < 1) {
return callback(null, []);
}
result = result || Array(size);
timesSync(limit > size ? size : limit, iterate);
function arrayIterator() {
index = started++;
if (index < size) {
iterator(collection[index], createCallback(index));
}
}
function arrayIteratorWithIndex() {
index = started++;
if (index < size) {
iterator(collection[index], index, createCallback(index));
}
}
function symbolIterator() {
item = iter.next();
if (item.done === false) {
iterator(item.value, createCallback(started++));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, result);
}
}
function symbolIteratorWithKey() {
item = iter.next();
if (item.done === false) {
iterator(item.value, started, createCallback(started++));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, result);
}
}
function objectIterator() {
index = started++;
if (index < size) {
iterator(collection[keys[index]], createCallback(index));
}
}
function objectIteratorWithKey() {
index = started++;
if (index < size) {
key = keys[index];
iterator(collection[key], key, createCallback(index));
}
}
function createCallback(index) {
return function(err, res) {
if (index === null) {
throwError();
}
if (err) {
index = null;
iterate = noop;
callback = once(callback);
callback(err, createArray(result));
return;
}
result[index] = res;
index = null;
if (++completed === size) {
iterate = throwError;
callback(null, result);
callback = throwError;
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
};
}
}
/**
* @memberof async
* @namespace mapValuesSeries
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.mapValuesSeries(array, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 3, '2': 2 }
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num);
* }, num * 10);
* };
* async.mapValuesSeries(array, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 3, '2': 2 }
* console.log(order); // [[1, 0], [3, 1], [2, 2]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.mapValuesSeries(object, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 3, c: 2 }
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num);
* }, num * 10);
* };
* async.mapValuesSeries(object, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 3, c: 2 }
* console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]
* });
*
*/
function mapValuesSeries(collection, iterator, callback) {
callback = callback || noop;
var size, key, keys, iter, item, iterate;
var sync = false;
var result = {};
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size) {
return callback(null, result);
}
iterate();
function arrayIterator() {
key = completed;
iterator(collection[completed], done);
}
function arrayIteratorWithIndex() {
key = completed;
iterator(collection[completed], completed, done);
}
function symbolIterator() {
key = completed;
item = iter.next();
item.done ? callback(null, result) : iterator(item.value, done);
}
function symbolIteratorWithKey() {
key = completed;
item = iter.next();
item.done ? callback(null, result) : iterator(item.value, completed, done);
}
function objectIterator() {
key = keys[completed];
iterator(collection[key], done);
}
function objectIteratorWithKey() {
key = keys[completed];
iterator(collection[key], key, done);
}
function done(err, res) {
if (err) {
iterate = throwError;
callback = onlyOnce(callback);
callback(err, objectClone(result));
return;
}
result[key] = res;
if (++completed === size) {
iterate = throwError;
callback(null, result);
callback = throwError;
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* @memberof async
* @namespace mapValuesLimit
* @param {Array|Object} collection
* @param {number} limit - limit >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.mapValuesLimit(array, 2, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 5, '2': 3, '3': 4, '4': 2 }
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num);
* }, num * 10);
* };
* async.mapValuesLimit(array, 2, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 5, '2': 3, '3': 4, '4': 2 }
* console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.mapValuesLimit(object, 2, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 5, c: 3, d: 4, e: 2 }
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num);
* }, num * 10);
* };
* async.mapValuesLimit(object, 2, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 5, c: 3, d: 4, e: 2 }
* console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
* });
*
*/
function mapValuesLimit(collection, limit, iterator, callback) {
callback = callback || noop;
var size, index, key, keys, iter, item, iterate;
var sync = false;
var result = {};
var started = 0;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size || isNaN(limit) || limit < 1) {
return callback(null, result);
}
timesSync(limit > size ? size : limit, iterate);
function arrayIterator() {
index = started++;
if (index < size) {
iterator(collection[index], createCallback(index));
}
}
function arrayIteratorWithIndex() {
index = started++;
if (index < size) {
iterator(collection[index], index, createCallback(index));
}
}
function symbolIterator() {
item = iter.next();
if (item.done === false) {
iterator(item.value, createCallback(started++));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, result);
}
}
function symbolIteratorWithKey() {
item = iter.next();
if (item.done === false) {
iterator(item.value, started, createCallback(started++));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, result);
}
}
function objectIterator() {
index = started++;
if (index < size) {
key = keys[index];
iterator(collection[key], createCallback(key));
}
}
function objectIteratorWithKey() {
index = started++;
if (index < size) {
key = keys[index];
iterator(collection[key], key, createCallback(key));
}
}
function createCallback(key) {
return function(err, res) {
if (key === null) {
throwError();
}
if (err) {
key = null;
iterate = noop;
callback = once(callback);
callback(err, objectClone(result));
return;
}
result[key] = res;
key = null;
if (++completed === size) {
callback(null, result);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
};
}
}
/**
* @private
* @param {Function} arrayEach
* @param {Function} baseEach
* @param {Function} symbolEach
* @param {boolean} bool
*/
function createDetect(arrayEach, baseEach, symbolEach, bool) {
return function(collection, iterator, callback) {
callback = callback || noop;
var size, keys;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
arrayEach(collection, iterator, createCallback);
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = symbolEach(collection, iterator, createCallback);
size && size === completed && callback(null);
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
baseEach(collection, iterator, createCallback, keys);
}
if (!size) {
callback(null);
}
function createCallback(value) {
var called = false;
return function done(err, res) {
if (called) {
throwError();
}
called = true;
if (err) {
callback = once(callback);
callback(err);
} else if (!!res === bool) {
callback = once(callback);
callback(null, value);
} else if (++completed === size) {
callback(null);
}
};
}
};
}
/**
* @private
* @param {boolean} bool
*/
function createDetectSeries(bool) {
return function(collection, iterator, callback) {
callback = onlyOnce(callback || noop);
var size, key, value, keys, iter, item, iterate;
var sync = false;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size) {
return callback(null);
}
iterate();
function arrayIterator() {
value = collection[completed];
iterator(value, done);
}
function arrayIteratorWithIndex() {
value = collection[completed];
iterator(value, completed, done);
}
function symbolIterator() {
item = iter.next();
value = item.value;
item.done ? callback(null) : iterator(value, done);
}
function symbolIteratorWithKey() {
item = iter.next();
value = item.value;
item.done ? callback(null) : iterator(value, completed, done);
}
function objectIterator() {
value = collection[keys[completed]];
iterator(value, done);
}
function objectIteratorWithKey() {
key = keys[completed];
value = collection[key];
iterator(value, key, done);
}
function done(err, res) {
if (err) {
callback(err);
} else if (!!res === bool) {
iterate = throwError;
callback(null, value);
} else if (++completed === size) {
iterate = throwError;
callback(null);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
};
}
/**
* @private
* @param {boolean} bool
*/
function createDetectLimit(bool) {
return function(collection, limit, iterator, callback) {
callback = callback || noop;
var size, index, key, value, keys, iter, item, iterate;
var sync = false;
var started = 0;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size || isNaN(limit) || limit < 1) {
return callback(null);
}
timesSync(limit > size ? size : limit, iterate);
function arrayIterator() {
index = started++;
if (index < size) {
value = collection[index];
iterator(value, createCallback(value));
}
}
function arrayIteratorWithIndex() {
index = started++;
if (index < size) {
value = collection[index];
iterator(value, index, createCallback(value));
}
}
function symbolIterator() {
item = iter.next();
if (item.done === false) {
started++;
value = item.value;
iterator(value, createCallback(value));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null);
}
}
function symbolIteratorWithKey() {
item = iter.next();
if (item.done === false) {
value = item.value;
iterator(value, started++, createCallback(value));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null);
}
}
function objectIterator() {
index = started++;
if (index < size) {
value = collection[keys[index]];
iterator(value, createCallback(value));
}
}
function objectIteratorWithKey() {
if (started < size) {
key = keys[started++];
value = collection[key];
iterator(value, key, createCallback(value));
}
}
function createCallback(value) {
var called = false;
return function(err, res) {
if (called) {
throwError();
}
called = true;
if (err) {
iterate = noop;
callback = once(callback);
callback(err);
} else if (!!res === bool) {
iterate = noop;
callback = once(callback);
callback(null, value);
} else if (++completed === size) {
callback(null);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
};
}
};
}
/**
* @private
* @param {Function} arrayEach
* @param {Function} baseEach
* @param {Function} symbolEach
* @param {boolean} bool
*/
function createPick(arrayEach, baseEach, symbolEach, bool) {
return function(collection, iterator, callback) {
callback = callback || noop;
var size, keys;
var completed = 0;
var result = {};
if (isArray(collection)) {
size = collection.length;
arrayEach(collection, iterator, createCallback);
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = symbolEach(collection, iterator, createCallback);
size && size === completed && callback(null, result);
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
baseEach(collection, iterator, createCallback, keys);
}
if (!size) {
return callback(null, {});
}
function createCallback(key, value) {
return function done(err, res) {
if (key === null) {
throwError();
}
if (err) {
key = null;
callback = once(callback);
callback(err, objectClone(result));
return;
}
if (!!res === bool) {
result[key] = value;
}
key = null;
if (++completed === size) {
callback(null, result);
}
};
}
};
}
/**
* @private
* @param {boolean} bool
*/
function createPickSeries(bool) {
return function(collection, iterator, callback) {
callback = onlyOnce(callback || noop);
var size, key, value, keys, iter, item, iterate;
var sync = false;
var result = {};
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size) {
return callback(null, {});
}
iterate();
function arrayIterator() {
key = completed;
value = collection[completed];
iterator(value, done);
}
function arrayIteratorWithIndex() {
key = completed;
value = collection[completed];
iterator(value, completed, done);
}
function symbolIterator() {
key = completed;
item = iter.next();
value = item.value;
item.done ? callback(null, result) : iterator(value, done);
}
function symbolIteratorWithKey() {
key = completed;
item = iter.next();
value = item.value;
item.done ? callback(null, result) : iterator(value, key, done);
}
function objectIterator() {
key = keys[completed];
value = collection[key];
iterator(value, done);
}
function objectIteratorWithKey() {
key = keys[completed];
value = collection[key];
iterator(value, key, done);
}
function done(err, res) {
if (err) {
callback(err, result);
return;
}
if (!!res === bool) {
result[key] = value;
}
if (++completed === size) {
iterate = throwError;
callback(null, result);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
};
}
/**
* @private
* @param {boolean} bool
*/
function createPickLimit(bool) {
return function(collection, limit, iterator, callback) {
callback = callback || noop;
var size, index, key, value, keys, iter, item, iterate;
var sync = false;
var result = {};
var started = 0;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size || isNaN(limit) || limit < 1) {
return callback(null, {});
}
timesSync(limit > size ? size : limit, iterate);
function arrayIterator() {
index = started++;
if (index < size) {
value = collection[index];
iterator(value, createCallback(value, index));
}
}
function arrayIteratorWithIndex() {
index = started++;
if (index < size) {
value = collection[index];
iterator(value, index, createCallback(value, index));
}
}
function symbolIterator() {
item = iter.next();
if (item.done === false) {
value = item.value;
iterator(value, createCallback(value, started++));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, result);
}
}
function symbolIteratorWithKey() {
item = iter.next();
if (item.done === false) {
value = item.value;
iterator(value, started, createCallback(value, started++));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, result);
}
}
function objectIterator() {
if (started < size) {
key = keys[started++];
value = collection[key];
iterator(value, createCallback(value, key));
}
}
function objectIteratorWithKey() {
if (started < size) {
key = keys[started++];
value = collection[key];
iterator(value, key, createCallback(value, key));
}
}
function createCallback(value, key) {
return function(err, res) {
if (key === null) {
throwError();
}
if (err) {
key = null;
iterate = noop;
callback = once(callback);
callback(err, objectClone(result));
return;
}
if (!!res === bool) {
result[key] = value;
}
key = null;
if (++completed === size) {
iterate = throwError;
callback = onlyOnce(callback);
callback(null, result);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
};
}
};
}
/**
* @memberof async
* @namespace reduce
* @param {Array|Object} collection
* @param {*} result
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var collection = [1, 3, 2, 4];
* var iterator = function(result, num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, result + num);
* }, num * 10);
* };
* async.reduce(collection, 0, iterator, function(err, res) {
* console.log(res); // 10
* console.log(order); // [1, 3, 2, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var collection = [1, 3, 2, 4];
* var iterator = function(result, num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, result + num);
* }, num * 10);
* };
* async.reduce(collection, '', iterator, function(err, res) {
* console.log(res); // '1324'
* console.log(order); // [[1, 0], [3, 1], [2, 2], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(result, num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, result + num);
* }, num * 10);
* };
* async.reduce(collection, '', iterator, function(err, res) {
* console.log(res); // '1324'
* console.log(order); // [1, 3, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(result, num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, result + num);
* }, num * 10);
* };
* async.reduce(collection, 0, iterator, function(err, res) {
* console.log(res); // 10
* console.log(order); // [[1, 'a'], [3, 'b'], [2, 'b'], [4, 'd']]
* });
*
*/
function reduce(collection, result, iterator, callback) {
callback = onlyOnce(callback || noop);
var size, key, keys, iter, item, iterate;
var sync = false;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
iterate = iterator.length === 4 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 4 ? objectIteratorWithKey : objectIterator;
}
if (!size) {
return callback(null, result);
}
iterate(result);
function arrayIterator(result) {
iterator(result, collection[completed], done);
}
function arrayIteratorWithIndex(result) {
iterator(result, collection[completed], completed, done);
}
function symbolIterator(result) {
item = iter.next();
item.done ? callback(null, result) : iterator(result, item.value, done);
}
function symbolIteratorWithKey(result) {
item = iter.next();
item.done ? callback(null, result) : iterator(result, item.value, completed, done);
}
function objectIterator(result) {
iterator(result, collection[keys[completed]], done);
}
function objectIteratorWithKey(result) {
key = keys[completed];
iterator(result, collection[key], key, done);
}
function done(err, result) {
if (err) {
callback(err, result);
} else if (++completed === size) {
iterator = throwError;
callback(null, result);
} else if (sync) {
nextTick(function() {
iterate(result);
});
} else {
sync = true;
iterate(result);
}
sync = false;
}
}
/**
* @memberof async
* @namespace reduceRight
* @param {Array|Object} collection
* @param {*} result
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var collection = [1, 3, 2, 4];
* var iterator = function(result, num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, result + num);
* }, num * 10);
* };
* async.reduceRight(collection, 0, iterator, function(err, res) {
* console.log(res); // 10
* console.log(order); // [4, 2, 3, 1]
* });
*
* @example
*
* // array with index
* var order = [];
* var collection = [1, 3, 2, 4];
* var iterator = function(result, num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, result + num);
* }, num * 10);
* };
* async.reduceRight(collection, '', iterator, function(err, res) {
* console.log(res); // '4231'
* console.log(order); // [[4, 3], [2, 2], [3, 1], [1, 0]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(result, num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, result + num);
* }, num * 10);
* };
* async.reduceRight(collection, '', iterator, function(err, res) {
* console.log(res); // '4231'
* console.log(order); // [4, 2, 3, 1]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(result, num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, result + num);
* }, num * 10);
* };
* async.reduceRight(collection, 0, iterator, function(err, res) {
* console.log(res); // 10
* console.log(order); // [[4, 3], [2, 2], [3, 1], [1, 0]]
* });
*
*/
function reduceRight(collection, result, iterator, callback) {
callback = onlyOnce(callback || noop);
var resIndex, index, key, keys, iter, item, col, iterate;
var sync = false;
if (isArray(collection)) {
resIndex = collection.length;
iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
col = [];
iter = collection[iteratorSymbol]();
index = -1;
while ((item = iter.next()).done === false) {
col[++index] = item.value;
}
collection = col;
resIndex = col.length;
iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
resIndex = keys.length;
iterate = iterator.length === 4 ? objectIteratorWithKey : objectIterator;
}
if (!resIndex) {
return callback(null, result);
}
iterate(result);
function arrayIterator(result) {
iterator(result, collection[--resIndex], done);
}
function arrayIteratorWithIndex(result) {
iterator(result, collection[--resIndex], resIndex, done);
}
function objectIterator(result) {
iterator(result, collection[keys[--resIndex]], done);
}
function objectIteratorWithKey(result) {
key = keys[--resIndex];
iterator(result, collection[key], key, done);
}
function done(err, result) {
if (err) {
callback(err, result);
} else if (resIndex === 0) {
iterate = throwError;
callback(null, result);
} else if (sync) {
nextTick(function() {
iterate(result);
});
} else {
sync = true;
iterate(result);
}
sync = false;
}
}
/**
* @private
* @param {Function} arrayEach
* @param {Function} baseEach
* @param {Function} symbolEach
*/
function createTransform(arrayEach, baseEach, symbolEach) {
return function transform(collection, accumulator, iterator, callback) {
if (arguments.length === 3) {
callback = iterator;
iterator = accumulator;
accumulator = undefined;
}
callback = callback || noop;
var size, keys, result;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
result = accumulator !== undefined ? accumulator : [];
arrayEach(collection, result, iterator, done);
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
result = accumulator !== undefined ? accumulator : {};
size = symbolEach(collection, result, iterator, done);
size && size === completed && callback(null, result);
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
result = accumulator !== undefined ? accumulator : {};
baseEach(collection, result, iterator, done, keys);
}
if (!size) {
callback(null, accumulator !== undefined ? accumulator : result || {});
}
function done(err, bool) {
if (err) {
callback = once(callback);
callback(err, isArray(result) ? createArray(result) : objectClone(result));
} else if (++completed === size) {
callback(null, result);
} else if (bool === false) {
callback = once(callback);
callback(null, isArray(result) ? createArray(result) : objectClone(result));
}
}
};
}
/**
* @memberof async
* @namespace transformSeries
* @param {Array|Object} collection
* @param {Array|Object|Function} [accumulator]
* @param {Function} [iterator]
* @param {Function} [callback]
* @example
*
* // array
* var order = [];
* var collection = [1, 3, 2, 4];
* var iterator = function(result, num, done) {
* setTimeout(function() {
* order.push(num);
* result.push(num)
* done();
* }, num * 10);
* };
* async.transformSeries(collection, iterator, function(err, res) {
* console.log(res); // [1, 3, 2, 4]
* console.log(order); // [1, 3, 2, 4]
* });
*
* @example
*
* // array with index and accumulator
* var order = [];
* var collection = [1, 3, 2, 4];
* var iterator = function(result, num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* result[index] = num;
* done();
* }, num * 10);
* };
* async.transformSeries(collection, {}, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 3, '2': 2, '3': 4 }
* console.log(order); // [[1, 0], [3, 1], [2, 2], [4, 3]]
* });
*
* @example
*
* // object with accumulator
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(result, num, done) {
* setTimeout(function() {
* order.push(num);
* result.push(num);
* done();
* }, num * 10);
* };
* async.transformSeries(collection, [], iterator, function(err, res) {
* console.log(res); // [1, 3, 2, 4]
* console.log(order); // [1, 3, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2, d: 4 };
* var iterator = function(result, num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* result[key] = num;
* done();
* }, num * 10);
* };
* async.transformSeries(collection, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 3, c: 2, d: 4 }
* console.log(order); // [[1, 'a'], [3, 'b'], [2, 'b'], [4, 'd']]
* });
*
*/
function transformSeries(collection, accumulator, iterator, callback) {
if (arguments.length === 3) {
callback = iterator;
iterator = accumulator;
accumulator = undefined;
}
callback = onlyOnce(callback || noop);
var size, key, keys, iter, item, iterate, result;
var sync = false;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
result = accumulator !== undefined ? accumulator : [];
iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
result = accumulator !== undefined ? accumulator : {};
iterate = iterator.length === 4 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
result = accumulator !== undefined ? accumulator : {};
iterate = iterator.length === 4 ? objectIteratorWithKey : objectIterator;
}
if (!size) {
return callback(null, accumulator !== undefined ? accumulator : result || {});
}
iterate();
function arrayIterator() {
iterator(result, collection[completed], done);
}
function arrayIteratorWithIndex() {
iterator(result, collection[completed], completed, done);
}
function symbolIterator() {
item = iter.next();
item.done ? callback(null, result) : iterator(result, item.value, done);
}
function symbolIteratorWithKey() {
item = iter.next();
item.done ? callback(null, result) : iterator(result, item.value, completed, done);
}
function objectIterator() {
iterator(result, collection[keys[completed]], done);
}
function objectIteratorWithKey() {
key = keys[completed];
iterator(result, collection[key], key, done);
}
function done(err, bool) {
if (err) {
callback(err, result);
} else if (++completed === size || bool === false) {
iterate = throwError;
callback(null, result);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* @memberof async
* @namespace transformLimit
* @param {Array|Object} collection
* @param {number} limit - limit >= 1
* @param {Array|Object|Function} [accumulator]
* @param {Function} [iterator]
* @param {Function} [callback]
* @example
*
* // array
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(result, num, done) {
* setTimeout(function() {
* order.push(num);
* result.push(num);
* done();
* }, num * 10);
* };
* async.transformLimit(array, 2, iterator, function(err, res) {
* console.log(res); // [1, 3, 5, 2, 4]
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // array with index and accumulator
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(result, num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* result[index] = key;
* done();
* }, num * 10);
* };
* async.transformLimit(array, 2, {}, iterator, function(err, res) {
* console.log(res); // { '0': 1, '1': 5, '2': 3, '3': 4, '4': 2 }
* console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
* });
*
* @example
*
* // object with accumulator
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(result, num, done) {
* setTimeout(function() {
* order.push(num);
* result.push(num);
* done();
* }, num * 10);
* };
* async.transformLimit(object, 2, [], iterator, function(err, res) {
* console.log(res); // [1, 3, 5, 2, 4]
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(result, num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* result[key] = num;
* done();
* }, num * 10);
* };
* async.transformLimit(object, 2, iterator, function(err, res) {
* console.log(res); // { a: 1, b: 5, c: 3, d: 4, e: 2 };
* console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
* });
*
*/
function transformLimit(collection, limit, accumulator, iterator, callback) {
if (arguments.length === 4) {
callback = iterator;
iterator = accumulator;
accumulator = undefined;
}
callback = callback || noop;
var size, index, key, keys, iter, item, iterate, result;
var sync = false;
var started = 0;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
result = accumulator !== undefined ? accumulator : [];
iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
result = accumulator !== undefined ? accumulator : {};
iterate = iterator.length === 4 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
result = accumulator !== undefined ? accumulator : {};
iterate = iterator.length === 4 ? objectIteratorWithKey : objectIterator;
}
if (!size || isNaN(limit) || limit < 1) {
return callback(null, accumulator !== undefined ? accumulator : result || {});
}
timesSync(limit > size ? size : limit, iterate);
function arrayIterator() {
index = started++;
if (index < size) {
iterator(result, collection[index], onlyOnce(done));
}
}
function arrayIteratorWithIndex() {
index = started++;
if (index < size) {
iterator(result, collection[index], index, onlyOnce(done));
}
}
function symbolIterator() {
item = iter.next();
if (item.done === false) {
started++;
iterator(result, item.value, onlyOnce(done));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, result);
}
}
function symbolIteratorWithKey() {
item = iter.next();
if (item.done === false) {
iterator(result, item.value, started++, onlyOnce(done));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, result);
}
}
function objectIterator() {
index = started++;
if (index < size) {
iterator(result, collection[keys[index]], onlyOnce(done));
}
}
function objectIteratorWithKey() {
index = started++;
if (index < size) {
key = keys[index];
iterator(result, collection[key], key, onlyOnce(done));
}
}
function done(err, bool) {
if (err || bool === false) {
iterate = noop;
callback(err || null, isArray(result) ? createArray(result) : objectClone(result));
callback = noop;
} else if (++completed === size) {
iterator = noop;
callback(null, result);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* @private
* @param {function} arrayEach
* @param {function} baseEach
* @param {function} symbolEach
*/
function createSortBy(arrayEach, baseEach, symbolEach) {
return function sortBy(collection, iterator, callback) {
callback = callback || noop;
var size, array, criteria;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
array = Array(size);
criteria = Array(size);
arrayEach(collection, iterator, createCallback);
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
array = [];
criteria = [];
size = symbolEach(collection, iterator, createCallback);
size && size === completed && callback(null, sortByCriteria(array, criteria));
} else if (typeof collection === obj) {
var keys = nativeKeys(collection);
size = keys.length;
array = Array(size);
criteria = Array(size);
baseEach(collection, iterator, createCallback, keys);
}
if (!size) {
callback(null, []);
}
function createCallback(index, value) {
var called = false;
array[index] = value;
return function done(err, criterion) {
if (called) {
throwError();
}
called = true;
criteria[index] = criterion;
if (err) {
callback = once(callback);
callback(err);
} else if (++completed === size) {
callback(null, sortByCriteria(array, criteria));
}
};
}
};
}
/**
* @memberof async
* @namespace sortBySeries
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.sortBySeries(array, iterator, function(err, res) {
* console.log(res); // [1, 2, 3];
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num);
* }, num * 10);
* };
* async.sortBySeries(array, iterator, function(err, res) {
* console.log(res); // [1, 2, 3]
* console.log(order); // [[1, 0], [3, 1], [2, 2]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.sortBySeries(object, iterator, function(err, res) {
* console.log(res); // [1, 2, 3]
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num);
* }, num * 10);
* };
* async.sortBySeries(object, iterator, function(err, res) {
* console.log(res); // [1, 2, 3]
* console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]
* });
*
*/
function sortBySeries(collection, iterator, callback) {
callback = onlyOnce(callback || noop);
var size, key, value, keys, iter, item, array, criteria, iterate;
var sync = false;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
array = collection;
criteria = Array(size);
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
array = [];
criteria = [];
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
array = Array(size);
criteria = Array(size);
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size) {
return callback(null, []);
}
iterate();
function arrayIterator() {
value = collection[completed];
iterator(value, done);
}
function arrayIteratorWithIndex() {
value = collection[completed];
iterator(value, completed, done);
}
function symbolIterator() {
item = iter.next();
if (item.done) {
return callback(null, sortByCriteria(array, criteria));
}
value = item.value;
array[completed] = value;
iterator(value, done);
}
function symbolIteratorWithKey() {
item = iter.next();
if (item.done) {
return callback(null, sortByCriteria(array, criteria));
}
value = item.value;
array[completed] = value;
iterator(value, completed, done);
}
function objectIterator() {
value = collection[keys[completed]];
array[completed] = value;
iterator(value, done);
}
function objectIteratorWithKey() {
key = keys[completed];
value = collection[key];
array[completed] = value;
iterator(value, key, done);
}
function done(err, criterion) {
criteria[completed] = criterion;
if (err) {
callback(err);
} else if (++completed === size) {
iterate = throwError;
callback(null, sortByCriteria(array, criteria));
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* @memberof async
* @namespace sortByLimit
* @param {Array|Object} collection
* @param {number} limit - limit >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.sortByLimit(array, 2, iterator, function(err, res) {
* console.log(res); // [1, 2, 3, 4, 5]
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num);
* }, num * 10);
* };
* async.sortByLimit(array, 2, iterator, function(err, res) {
* console.log(res); // [1, 2, 3, 4, 5]
* console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num);
* }, num * 10);
* };
* async.sortByLimit(object, 2, iterator, function(err, res) {
* console.log(res); // [1, 2, 3, 4, 5]
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num);
* }, num * 10);
* };
* async.sortByLimit(object, 2, iterator, function(err, res) {
* console.log(res); // [1, 2, 3, 4, 5]
* console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
* });
*
*/
function sortByLimit(collection, limit, iterator, callback) {
callback = callback || noop;
var size, index, key, value, array, keys, iter, item, criteria, iterate;
var sync = false;
var started = 0;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
array = collection;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
array = [];
criteria = [];
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
array = Array(size);
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size || isNaN(limit) || limit < 1) {
return callback(null, []);
}
criteria = criteria || Array(size);
timesSync(limit > size ? size : limit, iterate);
function arrayIterator() {
if (started < size) {
value = collection[started];
iterator(value, createCallback(value, started++));
}
}
function arrayIteratorWithIndex() {
index = started++;
if (index < size) {
value = collection[index];
iterator(value, index, createCallback(value, index));
}
}
function symbolIterator() {
item = iter.next();
if (item.done === false) {
value = item.value;
array[started] = value;
iterator(value, createCallback(value, started++));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, sortByCriteria(array, criteria));
}
}
function symbolIteratorWithKey() {
item = iter.next();
if (item.done === false) {
value = item.value;
array[started] = value;
iterator(value, started, createCallback(value, started++));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, sortByCriteria(array, criteria));
}
}
function objectIterator() {
if (started < size) {
value = collection[keys[started]];
array[started] = value;
iterator(value, createCallback(value, started++));
}
}
function objectIteratorWithKey() {
if (started < size) {
key = keys[started];
value = collection[key];
array[started] = value;
iterator(value, key, createCallback(value, started++));
}
}
function createCallback(value, index) {
var called = false;
return function(err, criterion) {
if (called) {
throwError();
}
called = true;
criteria[index] = criterion;
if (err) {
iterate = noop;
callback(err);
callback = noop;
} else if (++completed === size) {
callback(null, sortByCriteria(array, criteria));
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
};
}
}
/**
* @memberof async
* @namespace some
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.some(array, iterator, function(err, res) {
* console.log(res); // true
* console.log(order); // [1]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.some(array, iterator, function(err, res) {
* console.log(res); // true
* console.log(order); // [[1, 0]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.some(object, iterator, function(err, res) {
* console.log(res); // true
* console.log(order); // [1]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.some(object, iterator, function(err, res) {
* console.log(res); // true
* console.log(order); // [[1, 'a']]
* });
*
*/
function some(collection, iterator, callback) {
callback = callback || noop;
detect(collection, iterator, done);
function done(err, res) {
if (err) {
return callback(err);
}
callback(null, !!res);
}
}
/**
* @memberof async
* @namespace someSeries
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.someSeries(array, iterator, function(err, res) {
* console.log(res); // true
* console.log(order); // [1]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.someSeries(array, iterator, function(err, res) {
* console.log(res); // true
* console.log(order); // [[1, 0]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.someSeries(object, iterator, function(err, res) {
* console.log(res); // true
* console.log(order); // [1]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.someSeries(object, iterator, function(err, res) {
* console.log(res); // true
* console.log(order); // [[1, 'a']]
* });
*
*/
function someSeries(collection, iterator, callback) {
callback = callback || noop;
detectSeries(collection, iterator, done);
function done(err, res) {
if (err) {
return callback(err);
}
callback(null, !!res);
}
}
/**
* @memberof async
* @namespace someLimit
* @param {Array|Object} collection
* @param {number} limit - limit >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.someLimit(array, 2, iterator, function(err, res) {
* console.log(res); // true
* console.log(order); // [1]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, num % 2);
* }, num * 10);
* };
* async.someLimit(array, 2, iterator, function(err, res) {
* console.log(res); // true
* console.log(order); // [[1, 0]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, num % 2);
* }, num * 10);
* };
* async.someLimit(object, 2, iterator, function(err, res) {
* console.log(res); // true
* console.log(order); // [1]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num % 2);
* }, num * 10);
* };
* async.someLimit(object, 2, iterator, function(err, res) {
* console.log(res); // true
* console.log(order); // [[1, 'a']]
* });
*
*/
function someLimit(collection, limit, iterator, callback) {
callback = callback || noop;
detectLimit(collection, limit, iterator, done);
function done(err, res) {
if (err) {
return callback(err);
}
callback(null, !!res);
}
}
/**
* @private
* @param {Function} arrayEach
* @param {Function} baseEach
* @param {Function} symbolEach
*/
function createEvery(arrayEach, baseEach, symbolEach) {
var deny = createDetect(arrayEach, baseEach, symbolEach, false);
return function every(collection, iterator, callback) {
callback = callback || noop;
deny(collection, iterator, done);
function done(err, res) {
if (err) {
return callback(err);
}
callback(null, !res);
}
};
}
/**
* @private
*/
function createEverySeries() {
var denySeries = createDetectSeries(false);
return function everySeries(collection, iterator, callback) {
callback = callback || noop;
denySeries(collection, iterator, done);
function done(err, res) {
if (err) {
return callback(err);
}
callback(null, !res);
}
};
}
/**
* @private
*/
function createEveryLimit() {
var denyLimit = createDetectLimit(false);
return function everyLimit(collection, limit, iterator, callback) {
callback = callback || noop;
denyLimit(collection, limit, iterator, done);
function done(err, res) {
if (err) {
return callback(err);
}
callback(null, !res);
}
};
}
/**
* @private
* @param {Function} arrayEach
* @param {Function} baseEach
* @param {Function} symbolEach
*/
function createConcat(arrayEach, baseEach, symbolEach) {
return function concat(collection, iterator, callback) {
callback = callback || noop;
var size, result;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
result = Array(size);
arrayEach(collection, iterator, createCallback);
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
result = [];
size = symbolEach(collection, iterator, createCallback);
size && size === completed && callback(null, result);
} else if (typeof collection === obj) {
var keys = nativeKeys(collection);
size = keys.length;
result = Array(size);
baseEach(collection, iterator, createCallback, keys);
}
if (!size) {
callback(null, []);
}
function createCallback(index) {
return function done(err, res) {
if (index === null) {
throwError();
}
if (err) {
index = null;
callback = once(callback);
arrayEachSync(result, function(array, index) {
if (array === undefined) {
result[index] = noop;
}
});
callback(err, makeConcatResult(result));
return;
}
switch (arguments.length) {
case 0:
case 1:
result[index] = noop;
break;
case 2:
result[index] = res;
break;
default:
result[index] = slice(arguments, 1);
break;
}
index = null;
if (++completed === size) {
callback(null, makeConcatResult(result));
}
};
}
};
}
/**
* @memberof async
* @namespace concatSeries
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, [num]);
* }, num * 10);
* };
* async.concatSeries(array, iterator, function(err, res) {
* console.log(res); // [1, 3, 2];
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 3, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, [num]);
* }, num * 10);
* };
* async.concatSeries(array, iterator, function(err, res) {
* console.log(res); // [1, 3, 2]
* console.log(order); // [[1, 0], [3, 1], [2, 2]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, [num]);
* }, num * 10);
* };
* async.concatSeries(object, iterator, function(err, res) {
* console.log(res); // [1, 3, 2]
* console.log(order); // [1, 3, 2]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 3, c: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, [num]);
* }, num * 10);
* };
* async.concatSeries(object, iterator, function(err, res) {
* console.log(res); // [1, 3, 2]
* console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]
* });
*
*/
function concatSeries(collection, iterator, callback) {
callback = onlyOnce(callback || noop);
var size, key, keys, iter, item, iterate;
var sync = false;
var result = [];
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size) {
return callback(null, result);
}
iterate();
function arrayIterator() {
iterator(collection[completed], done);
}
function arrayIteratorWithIndex() {
iterator(collection[completed], completed, done);
}
function symbolIterator() {
item = iter.next();
item.done ? callback(null, result) : iterator(item.value, done);
}
function symbolIteratorWithKey() {
item = iter.next();
item.done ? callback(null, result) : iterator(item.value, completed, done);
}
function objectIterator() {
iterator(collection[keys[completed]], done);
}
function objectIteratorWithKey() {
key = keys[completed];
iterator(collection[key], key, done);
}
function done(err, array) {
if (isArray(array)) {
nativePush.apply(result, array);
} else if (arguments.length >= 2) {
nativePush.apply(result, slice(arguments, 1));
}
if (err) {
callback(err, result);
} else if (++completed === size) {
iterate = throwError;
callback(null, result);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* @memberof async
* @namespace concatLimit
* @param {Array|Object} collection
* @param {number} limit - limit >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, [num]);
* }, num * 10);
* };
* async.concatLimit(array, 2, iterator, function(err, res) {
* console.log(res); // [1, 3, 5, 2, 4]
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1, 5, 3, 4, 2];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, [num]);
* }, num * 10);
* };
* async.cocnatLimit(array, 2, iterator, function(err, res) {
* console.log(res); // [1, 3, 5, 2, 4]
* console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, [num]);
* }, num * 10);
* };
* async.concatLimit(object, 2, iterator, function(err, res) {
* console.log(res); // [1, 3, 5, 2, 4]
* console.log(order); // [1, 3, 5, 2, 4]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, num);
* }, num * 10);
* };
* async.cocnatLimit(object, 2, iterator, function(err, res) {
* console.log(res); // [1, 3, 5, 2, 4]
* console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
* });
*
*/
function concatLimit(collection, limit, iterator, callback) {
callback = callback || noop;
var size, key, iter, item, iterate, result;
var sync = false;
var started = 0;
var completed = 0;
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
result = [];
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
var keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size || isNaN(limit) || limit < 1) {
return callback(null, []);
}
result = result || Array(size);
timesSync(limit > size ? size : limit, iterate);
function arrayIterator() {
if (started < size) {
iterator(collection[started], createCallback(started++));
}
}
function arrayIteratorWithIndex() {
if (started < size) {
iterator(collection[started], started, createCallback(started++));
}
}
function symbolIterator() {
item = iter.next();
if (item.done === false) {
iterator(item.value, createCallback(started++));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, makeConcatResult(result));
}
}
function symbolIteratorWithKey() {
item = iter.next();
if (item.done === false) {
iterator(item.value, started, createCallback(started++));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, makeConcatResult(result));
}
}
function objectIterator() {
if (started < size) {
iterator(collection[keys[started]], createCallback(started++));
}
}
function objectIteratorWithKey() {
if (started < size) {
key = keys[started];
iterator(collection[key], key, createCallback(started++));
}
}
function createCallback(index) {
return function(err, res) {
if (index === null) {
throwError();
}
if (err) {
index = null;
iterate = noop;
callback = once(callback);
arrayEachSync(result, function(array, index) {
if (array === undefined) {
result[index] = noop;
}
});
callback(err, makeConcatResult(result));
return;
}
switch (arguments.length) {
case 0:
case 1:
result[index] = noop;
break;
case 2:
result[index] = res;
break;
default:
result[index] = slice(arguments, 1);
break;
}
index = null;
if (++completed === size) {
iterate = throwError;
callback(null, makeConcatResult(result));
callback = throwError;
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
};
}
}
/**
* @private
* @param {Function} arrayEach
* @param {Function} baseEach
* @param {Function} symbolEach
*/
function createGroupBy(arrayEach, baseEach, symbolEach) {
return function groupBy(collection, iterator, callback) {
callback = callback || noop;
var size;
var completed = 0;
var result = {};
if (isArray(collection)) {
size = collection.length;
arrayEach(collection, iterator, createCallback);
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = symbolEach(collection, iterator, createCallback);
size && size === completed && callback(null, result);
} else if (typeof collection === obj) {
var keys = nativeKeys(collection);
size = keys.length;
baseEach(collection, iterator, createCallback, keys);
}
if (!size) {
callback(null, {});
}
function createCallback(value) {
var called = false;
return function done(err, key) {
if (called) {
throwError();
}
called = true;
if (err) {
callback = once(callback);
callback(err, objectClone(result));
return;
}
var array = result[key];
if (!array) {
result[key] = [value];
} else {
array.push(value);
}
if (++completed === size) {
callback(null, result);
}
};
}
};
}
/**
* @memberof async
* @namespace groupBySeries
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [4.2, 6.4, 6.1];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, Math.floor(num));
* }, num * 10);
* };
* async.groupBySeries(array, iterator, function(err, res) {
* console.log(res); // { '4': [4.2], '6': [6.4, 6.1] }
* console.log(order); // [4.2, 6.4, 6.1]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [4.2, 6.4, 6.1];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, Math.floor(num));
* }, num * 10);
* };
* async.groupBySeries(array, iterator, function(err, res) {
* console.log(res); // { '4': [4.2], '6': [6.4, 6.1] }
* console.log(order); // [[4.2, 0], [6.4, 1], [6.1, 2]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 4.2, b: 6.4, c: 6.1 };
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, Math.floor(num));
* }, num * 10);
* };
* async.groupBySeries(object, iterator, function(err, res) {
* console.log(res); // { '4': [4.2], '6': [6.4, 6.1] }
* console.log(order); // [4.2, 6.4, 6.1]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 4.2, b: 6.4, c: 6.1 };
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, Math.floor(num));
* }, num * 10);
* };
* async.groupBySeries(object, iterator, function(err, res) {
* console.log(res); // { '4': [4.2], '6': [6.4, 6.1] }
* console.log(order); // [[4.2, 'a'], [6.4, 'b'], [6.1, 'c']]
* });
*
*/
function groupBySeries(collection, iterator, callback) {
callback = onlyOnce(callback || noop);
var size, key, value, keys, iter, item, iterate;
var sync = false;
var completed = 0;
var result = {};
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size) {
return callback(null, result);
}
iterate();
function arrayIterator() {
value = collection[completed];
iterator(value, done);
}
function arrayIteratorWithIndex() {
value = collection[completed];
iterator(value, completed, done);
}
function symbolIterator() {
item = iter.next();
value = item.value;
item.done ? callback(null, result) : iterator(value, done);
}
function symbolIteratorWithKey() {
item = iter.next();
value = item.value;
item.done ? callback(null, result) : iterator(value, completed, done);
}
function objectIterator() {
value = collection[keys[completed]];
iterator(value, done);
}
function objectIteratorWithKey() {
key = keys[completed];
value = collection[key];
iterator(value, key, done);
}
function done(err, key) {
if (err) {
iterate = throwError;
callback = onlyOnce(callback);
callback(err, objectClone(result));
return;
}
var array = result[key];
if (!array) {
result[key] = [value];
} else {
array.push(value);
}
if (++completed === size) {
iterate = throwError;
callback(null, result);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* @memberof async
* @namespace groupByLimit
* @param {Array|Object} collection
* @param {Function} iterator
* @param {Function} callback
* @example
*
* // array
* var order = [];
* var array = [1.1, 5.9, 3.2, 3.9, 2.1];
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, Math.floor(num));
* }, num * 10);
* };
* async.groupByLimit(array, 2, iterator, function(err, res) {
* console.log(res); // { '1': [1.1], '3': [3.2, 3.9], '5': [5.9], '2': [2.1] }
* console.log(order); // [1.1, 3.2, 5.9, 2.1, 3.9]
* });
*
* @example
*
* // array with index
* var order = [];
* var array = [1.1, 5.9, 3.2, 3.9, 2.1];
* var iterator = function(num, index, done) {
* setTimeout(function() {
* order.push([num, index]);
* done(null, Math.floor(num));
* }, num * 10);
* };
* async.groupByLimit(array, 2, iterator, function(err, res) {
* console.log(res); // { '1': [1.1], '3': [3.2, 3.9], '5': [5.9], '2': [2.1] }
* console.log(order); // [[1.1, 0], [3.2, 2], [5.9, 1], [2.1, 4], [3.9, 3]]
* });
*
* @example
*
* // object
* var order = [];
* var object = { a: 1.1, b: 5.9, c: 3.2, d: 3.9, e: 2.1 }
* var iterator = function(num, done) {
* setTimeout(function() {
* order.push(num);
* done(null, Math.floor(num));
* }, num * 10);
* };
* async.groupByLimit(object, 2, iterator, function(err, res) {
* console.log(res); // { '1': [1.1], '3': [3.2, 3.9], '5': [5.9], '2': [2.1] }
* console.log(order); // [1.1, 3.2, 5.9, 2.1, 3.9]
* });
*
* @example
*
* // object with key
* var order = [];
* var object = { a: 1.1, b: 5.9, c: 3.2, d: 3.9, e: 2.1 }
* var iterator = function(num, key, done) {
* setTimeout(function() {
* order.push([num, key]);
* done(null, Math.floor(num));
* }, num * 10);
* };
* async.groupByLimit(object, 2, iterator, function(err, res) {
* console.log(res); // { '1': [1.1], '3': [3.2, 3.9], '5': [5.9], '2': [2.1] }
* console.log(order); // [[1.1, 'a'], [3.2, 'c'], [5.9, 'b'], [2.1, 'e'], [3.9, 'd']]
* });
*
*/
function groupByLimit(collection, limit, iterator, callback) {
callback = callback || noop;
var size, index, key, value, keys, iter, item, iterate;
var sync = false;
var started = 0;
var completed = 0;
var result = {};
if (isArray(collection)) {
size = collection.length;
iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
} else if (!collection) {
} else if (iteratorSymbol && collection[iteratorSymbol]) {
size = Infinity;
iter = collection[iteratorSymbol]();
iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
} else if (typeof collection === obj) {
keys = nativeKeys(collection);
size = keys.length;
iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
}
if (!size || isNaN(limit) || limit < 1) {
return callback(null, result);
}
timesSync(limit > size ? size : limit, iterate);
function arrayIterator() {
if (started < size) {
value = collection[started++];
iterator(value, createCallback(value));
}
}
function arrayIteratorWithIndex() {
index = started++;
if (index < size) {
value = collection[index];
iterator(value, index, createCallback(value));
}
}
function symbolIterator() {
item = iter.next();
if (item.done === false) {
started++;
value = item.value;
iterator(value, createCallback(value));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, result);
}
}
function symbolIteratorWithKey() {
item = iter.next();
if (item.done === false) {
value = item.value;
iterator(value, started++, createCallback(value));
} else if (completed === started && iterator !== noop) {
iterator = noop;
callback(null, result);
}
}
function objectIterator() {
if (started < size) {
value = collection[keys[started++]];
iterator(value, createCallback(value));
}
}
function objectIteratorWithKey() {
if (started < size) {
key = keys[started++];
value = collection[key];
iterator(value, key, createCallback(value));
}
}
function createCallback(value) {
var called = false;
return function(err, key) {
if (called) {
throwError();
}
called = true;
if (err) {
iterate = noop;
callback = once(callback);
callback(err, objectClone(result));
return;
}
var array = result[key];
if (!array) {
result[key] = [value];
} else {
array.push(value);
}
if (++completed === size) {
callback(null, result);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
};
}
}
/**
* @private
* @param {Function} arrayEach
* @param {Function} baseEach
*/
function createParallel(arrayEach, baseEach) {
return function parallel(tasks, callback) {
callback = callback || noop;
var size, keys, result;
var completed = 0;
if (isArray(tasks)) {
size = tasks.length;
result = Array(size);
arrayEach(tasks, createCallback);
} else if (tasks && typeof tasks === obj) {
keys = nativeKeys(tasks);
size = keys.length;
result = {};
baseEach(tasks, createCallback, keys);
}
if (!size) {
callback(null, result);
}
function createCallback(key) {
return function(err, res) {
if (key === null) {
throwError();
}
if (err) {
key = null;
callback = once(callback);
callback(err, result);
return;
}
result[key] = arguments.length <= 2 ? res : slice(arguments, 1);
key = null;
if (++completed === size) {
callback(null, result);
}
};
}
};
}
/**
* @memberof async
* @namespace series
* @param {Array|Object} tasks - functions
* @param {Function} callback
* @example
*
* var order = [];
* var tasks = [
* function(done) {
* setTimeout(function() {
* order.push(1);
* done(null, 1);
* }, 10);
* },
* function(done) {
* setTimeout(function() {
* order.push(2);
* done(null, 2);
* }, 30);
* },
* function(done) {
* setTimeout(function() {
* order.push(3);
* done(null, 3);
* }, 40);
* },
* function(done) {
* setTimeout(function() {
* order.push(4);
* done(null, 4);
* }, 20);
* }
* ];
* async.series(tasks, function(err, res) {
* console.log(res); // [1, 2, 3, 4];
* console.log(order); // [1, 2, 3, 4]
* });
*
* @example
*
* var order = [];
* var tasks = {
* 'a': function(done) {
* setTimeout(function() {
* order.push(1);
* done(null, 1);
* }, 10);
* },
* 'b': function(done) {
* setTimeout(function() {
* order.push(2);
* done(null, 2);
* }, 30);
* },
* 'c': function(done) {
* setTimeout(function() {
* order.push(3);
* done(null, 3);
* }, 40);
* },
* 'd': function(done) {
* setTimeout(function() {
* order.push(4);
* done(null, 4);
* }, 20);
* }
* };
* async.series(tasks, function(err, res) {
* console.log(res); // { a: 1, b: 2, c: 3, d:4 }
* console.log(order); // [1, 4, 2, 3]
* });
*
*/
function series(tasks, callback) {
callback = callback || noop;
var size, key, keys, result, iterate;
var sync = false;
var completed = 0;
if (isArray(tasks)) {
size = tasks.length;
result = Array(size);
iterate = arrayIterator;
} else if (tasks && typeof tasks === obj) {
keys = nativeKeys(tasks);
size = keys.length;
result = {};
iterate = objectIterator;
} else {
return callback(null);
}
if (!size) {
return callback(null, result);
}
iterate();
function arrayIterator() {
key = completed;
tasks[completed](done);
}
function objectIterator() {
key = keys[completed];
tasks[key](done);
}
function done(err, res) {
if (err) {
iterate = throwError;
callback = onlyOnce(callback);
callback(err, result);
return;
}
result[key] = arguments.length <= 2 ? res : slice(arguments, 1);
if (++completed === size) {
iterate = throwError;
callback(null, result);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* @memberof async
* @namespace parallelLimit
* @param {Array|Object} tasks - functions
* @param {number} limit - limit >= 1
* @param {Function} callback
* @example
*
* var order = [];
* var tasks = [
* function(done) {
* setTimeout(function() {
* order.push(1);
* done(null, 1);
* }, 10);
* },
* function(done) {
* setTimeout(function() {
* order.push(2);
* done(null, 2);
* }, 50);
* },
* function(done) {
* setTimeout(function() {
* order.push(3);
* done(null, 3);
* }, 30);
* },
* function(done) {
* setTimeout(function() {
* order.push(4);
* done(null, 4);
* }, 40);
* }
* ];
* async.parallelLimit(tasks, 2, function(err, res) {
* console.log(res); // [1, 2, 3, 4];
* console.log(order); // [1, 3, 2, 4]
* });
*
* @example
*
* var order = [];
* var tasks = {
* 'a': function(done) {
* setTimeout(function() {
* order.push(1);
* done(null, 1);
* }, 10);
* },
* 'b': function(done) {
* setTimeout(function() {
* order.push(2);
* done(null, 2);
* }, 50);
* },
* 'c': function(done) {
* setTimeout(function() {
* order.push(3);
* done(null, 3);
* }, 20);
* },
* 'd': function(done) {
* setTimeout(function() {
* order.push(4);
* done(null, 4);
* }, 40);
* }
* };
* async.parallelLimit(tasks, 2, function(err, res) {
* console.log(res); // { a: 1, b: 2, c: 3, d:4 }
* console.log(order); // [1, 3, 2, 4]
* });
*
*/
function parallelLimit(tasks, limit, callback) {
callback = callback || noop;
var size, index, key, keys, result, iterate;
var sync = false;
var started = 0;
var completed = 0;
if (isArray(tasks)) {
size = tasks.length;
result = Array(size);
iterate = arrayIterator;
} else if (tasks && typeof tasks === obj) {
keys = nativeKeys(tasks);
size = keys.length;
result = {};
iterate = objectIterator;
}
if (!size || isNaN(limit) || limit < 1) {
return callback(null, result);
}
timesSync(limit > size ? size : limit, iterate);
function arrayIterator() {
index = started++;
if (index < size) {
tasks[index](createCallback(index));
}
}
function objectIterator() {
if (started < size) {
key = keys[started++];
tasks[key](createCallback(key));
}
}
function createCallback(key) {
return function(err, res) {
if (key === null) {
throwError();
}
if (err) {
key = null;
iterate = noop;
callback = once(callback);
callback(err, result);
return;
}
result[key] = arguments.length <= 2 ? res : slice(arguments, 1);
key = null;
if (++completed === size) {
callback(null, result);
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
};
}
}
/**
* @memberof async
* @namespace tryEach
* @param {Array|Object} tasks - functions
* @param {Function} callback
* @example
*
* var tasks = [
* function(done) {
* setTimeout(function() {
* done(new Error('error'));
* }, 10);
* },
* function(done) {
* setTimeout(function() {
* done(null, 2);
* }, 10);
* }
* ];
* async.tryEach(tasks, function(err, res) {
* console.log(res); // 2
* });
*
* @example
*
* var tasks = [
* function(done) {
* setTimeout(function() {
* done(new Error('error1'));
* }, 10);
* },
* function(done) {
* setTimeout(function() {
* done(new Error('error2');
* }, 10);
* }
* ];
* async.tryEach(tasks, function(err, res) {
* console.log(err); // error2
* console.log(res); // undefined
* });
*
*/
function tryEach(tasks, callback) {
callback = callback || noop;
var size, keys, iterate;
var sync = false;
var completed = 0;
if (isArray(tasks)) {
size = tasks.length;
iterate = arrayIterator;
} else if (tasks && typeof tasks === obj) {
keys = nativeKeys(tasks);
size = keys.length;
iterate = objectIterator;
}
if (!size) {
return callback(null);
}
iterate();
function arrayIterator() {
tasks[completed](done);
}
function objectIterator() {
tasks[keys[completed]](done);
}
function done(err, res) {
if (!err) {
if (arguments.length <= 2) {
callback(null, res);
} else {
callback(null, slice(arguments, 1));
}
} else if (++completed === size) {
callback(err);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* check for waterfall tasks
* @private
* @param {Array} tasks
* @param {Function} callback
* @return {boolean}
*/
function checkWaterfallTasks(tasks, callback) {
if (!isArray(tasks)) {
callback(new Error('First argument to waterfall must be an array of functions'));
return false;
}
if (tasks.length === 0) {
callback(null);
return false;
}
return true;
}
/**
* check for waterfall tasks
* @private
* @param {function} func
* @param {Array|Object} args - arguments
* @return {function} next
*/
function waterfallIterator(func, args, next) {
switch (args.length) {
case 0:
case 1:
return func(next);
case 2:
return func(args[1], next);
case 3:
return func(args[1], args[2], next);
case 4:
return func(args[1], args[2], args[3], next);
case 5:
return func(args[1], args[2], args[3], args[4], next);
case 6:
return func(args[1], args[2], args[3], args[4], args[5], next);
default:
args = slice(args, 1);
args.push(next);
return func.apply(null, args);
}
}
/**
* @memberof async
* @namespace waterfall
* @param {Array} tasks - functions
* @param {Function} callback
* @example
*
* var order = [];
* var tasks = [
* function(next) {
* setTimeout(function() {
* order.push(1);
* next(null, 1);
* }, 10);
* },
* function(arg1, next) {
* setTimeout(function() {
* order.push(2);
* next(null, 1, 2);
* }, 30);
* },
* function(arg1, arg2, next) {
* setTimeout(function() {
* order.push(3);
* next(null, 3);
* }, 20);
* },
* function(arg1, next) {
* setTimeout(function() {
* order.push(4);
* next(null, 1, 2, 3, 4);
* }, 40);
* }
* ];
* async.waterfall(tasks, function(err, arg1, arg2, arg3, arg4) {
* console.log(arg1, arg2, arg3, arg4); // 1 2 3 4
* });
*
*/
function waterfall(tasks, callback) {
callback = callback || noop;
if (!checkWaterfallTasks(tasks, callback)) {
return;
}
var func, args, done, sync;
var completed = 0;
var size = tasks.length;
waterfallIterator(tasks[0], [], createCallback(0));
function iterate() {
waterfallIterator(func, args, createCallback(func));
}
function createCallback(index) {
return function next(err, res) {
if (index === undefined) {
callback = noop;
throwError();
}
index = undefined;
if (err) {
done = callback;
callback = throwError;
done(err);
return;
}
if (++completed === size) {
done = callback;
callback = throwError;
if (arguments.length <= 2) {
done(err, res);
} else {
done.apply(null, createArray(arguments));
}
return;
}
if (sync) {
args = arguments;
func = tasks[completed] || throwError;
nextTick(iterate);
} else {
sync = true;
waterfallIterator(tasks[completed] || throwError, arguments, createCallback(completed));
}
sync = false;
};
}
}
/**
* `angelFall` is like `waterfall` and inject callback to last argument of next task.
*
* @memberof async
* @namespace angelFall
* @param {Array} tasks - functions
* @param {Function} callback
* @example
*
* var order = [];
* var tasks = [
* function(next) {
* setTimeout(function() {
* order.push(1);
* next(null, 1);
* }, 10);
* },
* function(arg1, empty, next) {
* setTimeout(function() {
* order.push(2);
* next(null, 1, 2);
* }, 30);
* },
* function(next) {
* setTimeout(function() {
* order.push(3);
* next(null, 3);
* }, 20);
* },
* function(arg1, empty1, empty2, empty3, next) {
* setTimeout(function() {
* order.push(4);
* next(null, 1, 2, 3, 4);
* }, 40);
* }
* ];
* async.angelFall(tasks, function(err, arg1, arg2, arg3, arg4) {
* console.log(arg1, arg2, arg3, arg4); // 1 2 3 4
* });
*
*/
function angelFall(tasks, callback) {
callback = callback || noop;
if (!checkWaterfallTasks(tasks, callback)) {
return;
}
var completed = 0;
var sync = false;
var size = tasks.length;
var func = tasks[completed];
var args = [];
var iterate = function() {
switch (func.length) {
case 0:
try {
next(null, func());
} catch (e) {
next(e);
}
return;
case 1:
return func(next);
case 2:
return func(args[1], next);
case 3:
return func(args[1], args[2], next);
case 4:
return func(args[1], args[2], args[3], next);
case 5:
return func(args[1], args[2], args[3], args[4], next);
default:
args = slice(args, 1);
args[func.length - 1] = next;
return func.apply(null, args);
}
};
iterate();
function next(err, res) {
if (err) {
iterate = throwError;
callback = onlyOnce(callback);
callback(err);
return;
}
if (++completed === size) {
iterate = throwError;
var done = callback;
callback = throwError;
if (arguments.length === 2) {
done(err, res);
} else {
done.apply(null, createArray(arguments));
}
return;
}
func = tasks[completed];
args = arguments;
if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* @memberof async
* @namespace whilst
* @param {Function} test
* @param {Function} iterator
* @param {Function} callback
*/
function whilst(test, iterator, callback) {
callback = callback || noop;
var sync = false;
if (test()) {
iterate();
} else {
callback(null);
}
function iterate() {
if (sync) {
nextTick(next);
} else {
sync = true;
iterator(done);
}
sync = false;
}
function next() {
iterator(done);
}
function done(err, arg) {
if (err) {
return callback(err);
}
if (arguments.length <= 2) {
if (test(arg)) {
iterate();
} else {
callback(null, arg);
}
return;
}
arg = slice(arguments, 1);
if (test.apply(null, arg)) {
iterate();
} else {
callback.apply(null, [null].concat(arg));
}
}
}
/**
* @memberof async
* @namespace doWhilst
* @param {Function} iterator
* @param {Function} test
* @param {Function} callback
*/
function doWhilst(iterator, test, callback) {
callback = callback || noop;
var sync = false;
next();
function iterate() {
if (sync) {
nextTick(next);
} else {
sync = true;
iterator(done);
}
sync = false;
}
function next() {
iterator(done);
}
function done(err, arg) {
if (err) {
return callback(err);
}
if (arguments.length <= 2) {
if (test(arg)) {
iterate();
} else {
callback(null, arg);
}
return;
}
arg = slice(arguments, 1);
if (test.apply(null, arg)) {
iterate();
} else {
callback.apply(null, [null].concat(arg));
}
}
}
/**
* @memberof async
* @namespace until
* @param {Function} test
* @param {Function} iterator
* @param {Function} callback
*/
function until(test, iterator, callback) {
callback = callback || noop;
var sync = false;
if (!test()) {
iterate();
} else {
callback(null);
}
function iterate() {
if (sync) {
nextTick(next);
} else {
sync = true;
iterator(done);
}
sync = false;
}
function next() {
iterator(done);
}
function done(err, arg) {
if (err) {
return callback(err);
}
if (arguments.length <= 2) {
if (!test(arg)) {
iterate();
} else {
callback(null, arg);
}
return;
}
arg = slice(arguments, 1);
if (!test.apply(null, arg)) {
iterate();
} else {
callback.apply(null, [null].concat(arg));
}
}
}
/**
* @memberof async
* @namespace doUntil
* @param {Function} iterator
* @param {Function} test
* @param {Function} callback
*/
function doUntil(iterator, test, callback) {
callback = callback || noop;
var sync = false;
next();
function iterate() {
if (sync) {
nextTick(next);
} else {
sync = true;
iterator(done);
}
sync = false;
}
function next() {
iterator(done);
}
function done(err, arg) {
if (err) {
return callback(err);
}
if (arguments.length <= 2) {
if (!test(arg)) {
iterate();
} else {
callback(null, arg);
}
return;
}
arg = slice(arguments, 1);
if (!test.apply(null, arg)) {
iterate();
} else {
callback.apply(null, [null].concat(arg));
}
}
}
/**
* @memberof async
* @namespace during
* @param {Function} test
* @param {Function} iterator
* @param {Function} callback
*/
function during(test, iterator, callback) {
callback = callback || noop;
_test();
function _test() {
test(iterate);
}
function iterate(err, truth) {
if (err) {
return callback(err);
}
if (truth) {
iterator(done);
} else {
callback(null);
}
}
function done(err) {
if (err) {
return callback(err);
}
_test();
}
}
/**
* @memberof async
* @namespace doDuring
* @param {Function} test
* @param {Function} iterator
* @param {Function} callback
*/
function doDuring(iterator, test, callback) {
callback = callback || noop;
iterate(null, true);
function iterate(err, truth) {
if (err) {
return callback(err);
}
if (truth) {
iterator(done);
} else {
callback(null);
}
}
function done(err, res) {
if (err) {
return callback(err);
}
switch (arguments.length) {
case 0:
case 1:
test(iterate);
break;
case 2:
test(res, iterate);
break;
default:
var args = slice(arguments, 1);
args.push(iterate);
test.apply(null, args);
break;
}
}
}
/**
* @memberof async
* @namespace forever
*/
function forever(iterator, callback) {
var sync = false;
iterate();
function iterate() {
iterator(next);
}
function next(err) {
if (err) {
if (callback) {
return callback(err);
}
throw err;
}
if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* @memberof async
* @namespace compose
*/
function compose() {
return seq.apply(null, reverse(arguments));
}
/**
* @memberof async
* @namespace seq
*/
function seq(/* functions... */) {
var fns = createArray(arguments);
return function() {
var self = this;
var args = createArray(arguments);
var callback = args[args.length - 1];
if (typeof callback === func) {
args.pop();
} else {
callback = noop;
}
reduce(fns, args, iterator, done);
function iterator(newargs, fn, callback) {
var func = function(err) {
var nextargs = slice(arguments, 1);
callback(err, nextargs);
};
newargs.push(func);
fn.apply(self, newargs);
}
function done(err, res) {
res = isArray(res) ? res : [res];
res.unshift(err);
callback.apply(self, res);
}
};
}
function createApplyEach(func) {
return function applyEach(fns /* arguments */) {
var go = function() {
var self = this;
var args = createArray(arguments);
var callback = args.pop() || noop;
return func(fns, iterator, callback);
function iterator(fn, done) {
fn.apply(self, args.concat([done]));
}
};
if (arguments.length > 1) {
var args = slice(arguments, 1);
return go.apply(this, args);
} else {
return go;
}
};
}
/**
* @see https://github.com/caolan/async/blob/master/lib/internal/DoublyLinkedList.js
*/
function DLL() {
this.head = null;
this.tail = null;
this.length = 0;
}
DLL.prototype._removeLink = function(node) {
var prev = node.prev;
var next = node.next;
if (prev) {
prev.next = next;
} else {
this.head = next;
}
if (next) {
next.prev = prev;
} else {
this.tail = prev;
}
node.prev = null;
node.next = null;
this.length--;
return node;
};
DLL.prototype.empty = DLL;
DLL.prototype._setInitial = function(node) {
this.length = 1;
this.head = this.tail = node;
};
DLL.prototype.insertBefore = function(node, newNode) {
newNode.prev = node.prev;
newNode.next = node;
if (node.prev) {
node.prev.next = newNode;
} else {
this.head = newNode;
}
node.prev = newNode;
this.length++;
};
DLL.prototype.unshift = function(node) {
if (this.head) {
this.insertBefore(this.head, node);
} else {
this._setInitial(node);
}
};
DLL.prototype.push = function(node) {
var tail = this.tail;
if (tail) {
node.prev = tail;
node.next = tail.next;
this.tail = node;
tail.next = node;
this.length++;
} else {
this._setInitial(node);
}
};
DLL.prototype.shift = function() {
return this.head && this._removeLink(this.head);
};
DLL.prototype.splice = function(end) {
var task;
var tasks = [];
while (end-- && (task = this.shift())) {
tasks.push(task);
}
return tasks;
};
DLL.prototype.remove = function(test) {
var node = this.head;
while (node) {
if (test(node)) {
this._removeLink(node);
}
node = node.next;
}
return this;
};
/**
* @private
*/
function baseQueue(isQueue, worker, concurrency, payload) {
if (concurrency === undefined) {
concurrency = 1;
} else if (isNaN(concurrency) || concurrency < 1) {
throw new Error('Concurrency must not be zero');
}
var workers = 0;
var workersList = [];
var _callback, _unshift;
var q = {
_tasks: new DLL(),
concurrency: concurrency,
payload: payload,
saturated: noop,
unsaturated: noop,
buffer: concurrency / 4,
empty: noop,
drain: noop,
error: noop,
started: false,
paused: false,
push: push,
kill: kill,
unshift: unshift,
remove: remove,
process: isQueue ? runQueue : runCargo,
length: getLength,
running: running,
workersList: getWorkersList,
idle: idle,
pause: pause,
resume: resume,
_worker: worker
};
return q;
function push(tasks, callback) {
_insert(tasks, callback);
}
function unshift(tasks, callback) {
_insert(tasks, callback, true);
}
function _exec(task) {
var item = {
data: task,
callback: _callback
};
if (_unshift) {
q._tasks.unshift(item);
} else {
q._tasks.push(item);
}
nextTick(q.process);
}
function _insert(tasks, callback, unshift) {
if (callback == null) {
callback = noop;
} else if (typeof callback !== 'function') {
throw new Error('task callback must be a function');
}
q.started = true;
var _tasks = isArray(tasks) ? tasks : [tasks];
if (tasks === undefined || !_tasks.length) {
if (q.idle()) {
nextTick(q.drain);
}
return;
}
_unshift = unshift;
_callback = callback;
arrayEachSync(_tasks, _exec);
}
function kill() {
q.drain = noop;
q._tasks.empty();
}
function _next(q, tasks) {
var called = false;
return function done(err, res) {
if (called) {
throwError();
}
called = true;
workers--;
var task;
var index = -1;
var size = workersList.length;
var taskIndex = -1;
var taskSize = tasks.length;
var useApply = arguments.length > 2;
var args = useApply && createArray(arguments);
while (++taskIndex < taskSize) {
task = tasks[taskIndex];
while (++index < size) {
if (workersList[index] === task) {
if (index === 0) {
workersList.shift();
} else {
workersList.splice(index, 1);
}
index = size;
size--;
}
}
index = -1;
if (useApply) {
task.callback.apply(task, args);
} else {
task.callback(err, res);
}
if (err) {
q.error(err, task.data);
}
}
if (workers <= q.concurrency - q.buffer) {
q.unsaturated();
}
if (q._tasks.length + workers === 0) {
q.drain();
}
q.process();
};
}
function runQueue() {
while (!q.paused && workers < q.concurrency && q._tasks.length) {
var task = q._tasks.shift();
workers++;
workersList.push(task);
if (q._tasks.length === 0) {
q.empty();
}
if (workers === q.concurrency) {
q.saturated();
}
var done = _next(q, [task]);
worker(task.data, done);
}
}
function runCargo() {
while (!q.paused && workers < q.concurrency && q._tasks.length) {
var tasks = q._tasks.splice(q.payload || q._tasks.length);
var index = -1;
var size = tasks.length;
var data = Array(size);
while (++index < size) {
data[index] = tasks[index].data;
}
workers++;
nativePush.apply(workersList, tasks);
if (q._tasks.length === 0) {
q.empty();
}
if (workers === q.concurrency) {
q.saturated();
}
var done = _next(q, tasks);
worker(data, done);
}
}
function getLength() {
return q._tasks.length;
}
function running() {
return workers;
}
function getWorkersList() {
return workersList;
}
function idle() {
return q.length() + workers === 0;
}
function pause() {
q.paused = true;
}
function _resume() {
nextTick(q.process);
}
function resume() {
if (q.paused === false) {
return;
}
q.paused = false;
var count = q.concurrency < q._tasks.length ? q.concurrency : q._tasks.length;
timesSync(count, _resume);
}
/**
* @param {Function} test
*/
function remove(test) {
q._tasks.remove(test);
}
}
/**
* @memberof async
* @namespace queue
*/
function queue(worker, concurrency) {
return baseQueue(true, worker, concurrency);
}
/**
* @memberof async
* @namespace priorityQueue
*/
function priorityQueue(worker, concurrency) {
var q = baseQueue(true, worker, concurrency);
q.push = push;
delete q.unshift;
return q;
function push(tasks, priority, callback) {
q.started = true;
priority = priority || 0;
var _tasks = isArray(tasks) ? tasks : [tasks];
var taskSize = _tasks.length;
if (tasks === undefined || taskSize === 0) {
if (q.idle()) {
nextTick(q.drain);
}
return;
}
callback = typeof callback === func ? callback : noop;
var nextNode = q._tasks.head;
while (nextNode && priority >= nextNode.priority) {
nextNode = nextNode.next;
}
while (taskSize--) {
var item = {
data: _tasks[taskSize],
priority: priority,
callback: callback
};
if (nextNode) {
q._tasks.insertBefore(nextNode, item);
} else {
q._tasks.push(item);
}
nextTick(q.process);
}
}
}
/**
* @memberof async
* @namespace cargo
*/
function cargo(worker, payload) {
return baseQueue(false, worker, 1, payload);
}
/**
* @memberof async
* @namespace auto
* @param {Object} tasks
* @param {number} [concurrency]
* @param {Function} [callback]
*/
function auto(tasks, concurrency, callback) {
if (typeof concurrency === func) {
callback = concurrency;
concurrency = null;
}
var keys = nativeKeys(tasks);
var rest = keys.length;
var results = {};
if (rest === 0) {
return callback(null, results);
}
var runningTasks = 0;
var readyTasks = [];
var listeners = Object.create(null);
callback = onlyOnce(callback || noop);
concurrency = concurrency || rest;
baseEachSync(tasks, iterator, keys);
proceedQueue();
function iterator(task, key) {
// no dependencies
var _task, _taskSize;
if (!isArray(task)) {
_task = task;
_taskSize = 0;
readyTasks.push([_task, _taskSize, done]);
return;
}
var dependencySize = task.length - 1;
_task = task[dependencySize];
_taskSize = dependencySize;
if (dependencySize === 0) {
readyTasks.push([_task, _taskSize, done]);
return;
}
// dependencies
var index = -1;
while (++index < dependencySize) {
var dependencyName = task[index];
if (notInclude(keys, dependencyName)) {
var msg =
'async.auto task `' +
key +
'` has non-existent dependency `' +
dependencyName +
'` in ' +
task.join(', ');
throw new Error(msg);
}
var taskListeners = listeners[dependencyName];
if (!taskListeners) {
taskListeners = listeners[dependencyName] = [];
}
taskListeners.push(taskListener);
}
function done(err, arg) {
if (key === null) {
throwError();
}
arg = arguments.length <= 2 ? arg : slice(arguments, 1);
if (err) {
rest = 0;
runningTasks = 0;
readyTasks.length = 0;
var safeResults = objectClone(results);
safeResults[key] = arg;
key = null;
var _callback = callback;
callback = noop;
_callback(err, safeResults);
return;
}
runningTasks--;
rest--;
results[key] = arg;
taskComplete(key);
key = null;
}
function taskListener() {
if (--dependencySize === 0) {
readyTasks.push([_task, _taskSize, done]);
}
}
}
function proceedQueue() {
if (readyTasks.length === 0 && runningTasks === 0) {
if (rest !== 0) {
throw new Error('async.auto task has cyclic dependencies');
}
return callback(null, results);
}
while (readyTasks.length && runningTasks < concurrency && callback !== noop) {
runningTasks++;
var array = readyTasks.shift();
if (array[1] === 0) {
array[0](array[2]);
} else {
array[0](results, array[2]);
}
}
}
function taskComplete(key) {
var taskListeners = listeners[key] || [];
arrayEachSync(taskListeners, function(task) {
task();
});
proceedQueue();
}
}
var FN_ARGS = /^(function)?\s*[^\(]*\(\s*([^\)]*)\)/m;
var FN_ARG_SPLIT = /,/;
var FN_ARG = /(=.+)?(\s*)$/;
var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
/**
* parse function arguments for `autoInject`
*
* @private
*/
function parseParams(func) {
func = func.toString().replace(STRIP_COMMENTS, '');
func = func.match(FN_ARGS)[2].replace(' ', '');
func = func ? func.split(FN_ARG_SPLIT) : [];
func = func.map(function(arg) {
return arg.replace(FN_ARG, '').trim();
});
return func;
}
/**
* @memberof async
* @namespace autoInject
* @param {Object} tasks
* @param {number} [concurrency]
* @param {Function} [callback]
*/
function autoInject(tasks, concurrency, callback) {
var newTasks = {};
baseEachSync(tasks, iterator, nativeKeys(tasks));
auto(newTasks, concurrency, callback);
function iterator(task, key) {
var params;
var taskLength = task.length;
if (isArray(task)) {
if (taskLength === 0) {
throw new Error('autoInject task functions require explicit parameters.');
}
params = createArray(task);
taskLength = params.length - 1;
task = params[taskLength];
if (taskLength === 0) {
newTasks[key] = task;
return;
}
} else if (taskLength === 1) {
newTasks[key] = task;
return;
} else {
params = parseParams(task);
if (taskLength === 0 && params.length === 0) {
throw new Error('autoInject task functions require explicit parameters.');
}
taskLength = params.length - 1;
}
params[taskLength] = newTask;
newTasks[key] = params;
function newTask(results, done) {
switch (taskLength) {
case 1:
task(results[params[0]], done);
break;
case 2:
task(results[params[0]], results[params[1]], done);
break;
case 3:
task(results[params[0]], results[params[1]], results[params[2]], done);
break;
default:
var i = -1;
while (++i < taskLength) {
params[i] = results[params[i]];
}
params[i] = done;
task.apply(null, params);
break;
}
}
}
}
/**
* @memberof async
* @namespace retry
* @param {integer|Object|Function} opts
* @param {Function} [task]
* @param {Function} [callback]
*/
function retry(opts, task, callback) {
var times, intervalFunc, errorFilter;
var count = 0;
if (arguments.length < 3 && typeof opts === func) {
callback = task || noop;
task = opts;
opts = null;
times = DEFAULT_TIMES;
} else {
callback = callback || noop;
switch (typeof opts) {
case 'object':
if (typeof opts.errorFilter === func) {
errorFilter = opts.errorFilter;
}
var interval = opts.interval;
switch (typeof interval) {
case func:
intervalFunc = interval;
break;
case 'string':
case 'number':
interval = +interval;
intervalFunc = interval
? function() {
return interval;
}
: function() {
return DEFAULT_INTERVAL;
};
break;
}
times = +opts.times || DEFAULT_TIMES;
break;
case 'number':
times = opts || DEFAULT_TIMES;
break;
case 'string':
times = +opts || DEFAULT_TIMES;
break;
default:
throw new Error('Invalid arguments for async.retry');
}
}
if (typeof task !== 'function') {
throw new Error('Invalid arguments for async.retry');
}
if (intervalFunc) {
task(intervalCallback);
} else {
task(simpleCallback);
}
function simpleIterator() {
task(simpleCallback);
}
function simpleCallback(err, res) {
if (++count === times || !err || (errorFilter && !errorFilter(err))) {
if (arguments.length <= 2) {
return callback(err, res);
}
var args = createArray(arguments);
return callback.apply(null, args);
}
simpleIterator();
}
function intervalIterator() {
task(intervalCallback);
}
function intervalCallback(err, res) {
if (++count === times || !err || (errorFilter && !errorFilter(err))) {
if (arguments.length <= 2) {
return callback(err, res);
}
var args = createArray(arguments);
return callback.apply(null, args);
}
setTimeout(intervalIterator, intervalFunc(count));
}
}
function retryable(opts, task) {
if (!task) {
task = opts;
opts = null;
}
return done;
function done() {
var taskFn;
var args = createArray(arguments);
var lastIndex = args.length - 1;
var callback = args[lastIndex];
switch (task.length) {
case 1:
taskFn = task1;
break;
case 2:
taskFn = task2;
break;
case 3:
taskFn = task3;
break;
default:
taskFn = task4;
}
if (opts) {
retry(opts, taskFn, callback);
} else {
retry(taskFn, callback);
}
function task1(done) {
task(done);
}
function task2(done) {
task(args[0], done);
}
function task3(done) {
task(args[0], args[1], done);
}
function task4(callback) {
args[lastIndex] = callback;
task.apply(null, args);
}
}
}
/**
* @memberof async
* @namespace iterator
*/
function iterator(tasks) {
var size = 0;
var keys = [];
if (isArray(tasks)) {
size = tasks.length;
} else {
keys = nativeKeys(tasks);
size = keys.length;
}
return makeCallback(0);
function makeCallback(index) {
var fn = function() {
if (size) {
var key = keys[index] || index;
tasks[key].apply(null, createArray(arguments));
}
return fn.next();
};
fn.next = function() {
return index < size - 1 ? makeCallback(index + 1) : null;
};
return fn;
}
}
/**
* @memberof async
* @namespace apply
*/
function apply(func) {
switch (arguments.length) {
case 0:
case 1:
return func;
case 2:
return func.bind(null, arguments[1]);
case 3:
return func.bind(null, arguments[1], arguments[2]);
case 4:
return func.bind(null, arguments[1], arguments[2], arguments[3]);
case 5:
return func.bind(null, arguments[1], arguments[2], arguments[3], arguments[4]);
default:
var size = arguments.length;
var index = 0;
var args = Array(size);
args[index] = null;
while (++index < size) {
args[index] = arguments[index];
}
return func.bind.apply(func, args);
}
}
/**
* @memberof async
* @namespace timeout
* @param {Function} func
* @param {number} millisec
* @param {*} info
*/
function timeout(func, millisec, info) {
var callback, timer;
return wrappedFunc;
function wrappedFunc() {
timer = setTimeout(timeoutCallback, millisec);
var args = createArray(arguments);
var lastIndex = args.length - 1;
callback = args[lastIndex];
args[lastIndex] = injectedCallback;
simpleApply(func, args);
}
function timeoutCallback() {
var name = func.name || 'anonymous';
var err = new Error('Callback function "' + name + '" timed out.');
err.code = 'ETIMEDOUT';
if (info) {
err.info = info;
}
timer = null;
callback(err);
}
function injectedCallback() {
if (timer !== null) {
simpleApply(callback, createArray(arguments));
clearTimeout(timer);
}
}
function simpleApply(func, args) {
switch (args.length) {
case 0:
func();
break;
case 1:
func(args[0]);
break;
case 2:
func(args[0], args[1]);
break;
default:
func.apply(null, args);
break;
}
}
}
/**
* @memberof async
* @namespace times
* @param {number} n - n >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* var iterator = function(n, done) {
* done(null, n);
* };
* async.times(4, iterator, function(err, res) {
* console.log(res); // [0, 1, 2, 3];
* });
*
*/
function times(n, iterator, callback) {
callback = callback || noop;
n = +n;
if (isNaN(n) || n < 1) {
return callback(null, []);
}
var result = Array(n);
timesSync(n, iterate);
function iterate(num) {
iterator(num, createCallback(num));
}
function createCallback(index) {
return function(err, res) {
if (index === null) {
throwError();
}
result[index] = res;
index = null;
if (err) {
callback(err);
callback = noop;
} else if (--n === 0) {
callback(null, result);
}
};
}
}
/**
* @memberof async
* @namespace timesSeries
* @param {number} n - n >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* var iterator = function(n, done) {
* done(null, n);
* };
* async.timesSeries(4, iterator, function(err, res) {
* console.log(res); // [0, 1, 2, 3];
* });
*
*/
function timesSeries(n, iterator, callback) {
callback = callback || noop;
n = +n;
if (isNaN(n) || n < 1) {
return callback(null, []);
}
var result = Array(n);
var sync = false;
var completed = 0;
iterate();
function iterate() {
iterator(completed, done);
}
function done(err, res) {
result[completed] = res;
if (err) {
callback(err);
callback = throwError;
} else if (++completed >= n) {
callback(null, result);
callback = throwError;
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
}
}
/**
* @memberof async
* @namespace timesLimit
* @param {number} n - n >= 1
* @param {number} limit - n >= 1
* @param {Function} iterator
* @param {Function} callback
* @example
*
* var iterator = function(n, done) {
* done(null, n);
* };
* async.timesLimit(4, 2, iterator, function(err, res) {
* console.log(res); // [0, 1, 2, 3];
* });
*
*/
function timesLimit(n, limit, iterator, callback) {
callback = callback || noop;
n = +n;
if (isNaN(n) || n < 1 || isNaN(limit) || limit < 1) {
return callback(null, []);
}
var result = Array(n);
var sync = false;
var started = 0;
var completed = 0;
timesSync(limit > n ? n : limit, iterate);
function iterate() {
var index = started++;
if (index < n) {
iterator(index, createCallback(index));
}
}
function createCallback(index) {
return function(err, res) {
if (index === null) {
throwError();
}
result[index] = res;
index = null;
if (err) {
callback(err);
callback = noop;
} else if (++completed >= n) {
callback(null, result);
callback = throwError;
} else if (sync) {
nextTick(iterate);
} else {
sync = true;
iterate();
}
sync = false;
};
}
}
/**
* @memberof async
* @namespace race
* @param {Array|Object} tasks - functions
* @param {Function} callback
* @example
*
* // array
* var called = 0;
* var tasks = [
* function(done) {
* setTimeout(function() {
* called++;
* done(null, '1');
* }, 30);
* },
* function(done) {
* setTimeout(function() {
* called++;
* done(null, '2');
* }, 20);
* },
* function(done) {
* setTimeout(function() {
* called++;
* done(null, '3');
* }, 10);
* }
* ];
* async.race(tasks, function(err, res) {
* console.log(res); // '3'
* console.log(called); // 1
* setTimeout(function() {
* console.log(called); // 3
* }, 50);
* });
*
* @example
*
* // object
* var called = 0;
* var tasks = {
* 'test1': function(done) {
* setTimeout(function() {
* called++;
* done(null, '1');
* }, 30);
* },
* 'test2': function(done) {
* setTimeout(function() {
* called++;
* done(null, '2');
* }, 20);
* },
* 'test3': function(done) {
* setTimeout(function() {
* called++;
* done(null, '3');
* }, 10);
* }
* };
* async.race(tasks, function(err, res) {
* console.log(res); // '3'
* console.log(called); // 1
* setTimeout(function() {
* console.log(called); // 3
* done();
* }, 50);
* });
*
*/
function race(tasks, callback) {
callback = once(callback || noop);
var size, keys;
var index = -1;
if (isArray(tasks)) {
size = tasks.length;
while (++index < size) {
tasks[index](callback);
}
} else if (tasks && typeof tasks === obj) {
keys = nativeKeys(tasks);
size = keys.length;
while (++index < size) {
tasks[keys[index]](callback);
}
} else {
return callback(new TypeError('First argument to race must be a collection of functions'));
}
if (!size) {
callback(null);
}
}
/**
* @memberof async
* @namespace memoize
*/
function memoize(fn, hasher) {
hasher =
hasher ||
function(hash) {
return hash;
};
var memo = {};
var queues = {};
var memoized = function() {
var args = createArray(arguments);
var callback = args.pop();
var key = hasher.apply(null, args);
if (has(memo, key)) {
nextTick(function() {
callback.apply(null, memo[key]);
});
return;
}
if (has(queues, key)) {
return queues[key].push(callback);
}
queues[key] = [callback];
args.push(done);
fn.apply(null, args);
function done(err) {
var args = createArray(arguments);
if (!err) {
memo[key] = args;
}
var q = queues[key];
delete queues[key];
var i = -1;
var size = q.length;
while (++i < size) {
q[i].apply(null, args);
}
}
};
memoized.memo = memo;
memoized.unmemoized = fn;
return memoized;
}
/**
* @memberof async
* @namespace unmemoize
*/
function unmemoize(fn) {
return function() {
return (fn.unmemoized || fn).apply(null, arguments);
};
}
/**
* @memberof async
* @namespace ensureAsync
*/
function ensureAsync(fn) {
return function(/* ...args, callback */) {
var args = createArray(arguments);
var lastIndex = args.length - 1;
var callback = args[lastIndex];
var sync = true;
args[lastIndex] = done;
fn.apply(this, args);
sync = false;
function done() {
var innerArgs = createArray(arguments);
if (sync) {
nextTick(function() {
callback.apply(null, innerArgs);
});
} else {
callback.apply(null, innerArgs);
}
}
};
}
/**
* @memberof async
* @namespace constant
*/
function constant(/* values... */) {
var args = [null].concat(createArray(arguments));
return function(callback) {
callback = arguments[arguments.length - 1];
callback.apply(this, args);
};
}
function asyncify(fn) {
return function(/* args..., callback */) {
var args = createArray(arguments);
var callback = args.pop();
var result;
try {
result = fn.apply(this, args);
} catch (e) {
return callback(e);
}
if (result && typeof result.then === func) {
result.then(
function(value) {
invokeCallback(callback, null, value);
},
function(err) {
invokeCallback(callback, err && err.message ? err : new Error(err));
}
);
} else {
callback(null, result);
}
};
}
function invokeCallback(callback, err, value) {
try {
callback(err, value);
} catch (e) {
nextTick(rethrow, e);
}
}
function rethrow(error) {
throw error;
}
/**
* @memberof async
* @namespace reflect
* @param {Function} func
* @return {Function}
*/
function reflect(func) {
return function(/* args..., callback */) {
var callback;
switch (arguments.length) {
case 1:
callback = arguments[0];
return func(done);
case 2:
callback = arguments[1];
return func(arguments[0], done);
default:
var args = createArray(arguments);
var lastIndex = args.length - 1;
callback = args[lastIndex];
args[lastIndex] = done;
func.apply(this, args);
}
function done(err, res) {
if (err) {
return callback(null, {
error: err
});
}
if (arguments.length > 2) {
res = slice(arguments, 1);
}
callback(null, {
value: res
});
}
};
}
/**
* @memberof async
* @namespace reflectAll
* @param {Array[]|Object} tasks
* @return {Function}
*/
function reflectAll(tasks) {
var newTasks, keys;
if (isArray(tasks)) {
newTasks = Array(tasks.length);
arrayEachSync(tasks, iterate);
} else if (tasks && typeof tasks === obj) {
keys = nativeKeys(tasks);
newTasks = {};
baseEachSync(tasks, iterate, keys);
}
return newTasks;
function iterate(func, key) {
newTasks[key] = reflect(func);
}
}
/**
* @memberof async
* @namespace createLogger
*/
function createLogger(name) {
return function(fn) {
var args = slice(arguments, 1);
args.push(done);
fn.apply(null, args);
};
function done(err) {
if (typeof console === obj) {
if (err) {
if (console.error) {
console.error(err);
}
return;
}
if (console[name]) {
var args = slice(arguments, 1);
arrayEachSync(args, function(arg) {
console[name](arg);
});
}
}
}
}
/**
* @memberof async
* @namespace safe
*/
function safe() {
createImmediate();
return exports;
}
/**
* @memberof async
* @namespace fast
*/
function fast() {
createImmediate(false);
return exports;
}
});
neo-async-2.6.1/lib/async.min.js 0000664 0000000 0000000 00000116517 13466145133 0016440 0 ustar 00root root 0000000 0000000 (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.0.0"
}
},
"comment-parser": {
"version": "0.3.1",
"resolved": "https://registry.npmjs.org/comment-parser/-/comment-parser-0.3.1.tgz",
"integrity": "sha1-/WV6rIwUktMIyaYQD8m0nSQ1q6E=",
"dev": true,
"requires": {
"readable-stream": "^2.0.4"
},
"dependencies": {
"isarray": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
"integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=",
"dev": true
},
"readable-stream": {
"version": "2.2.9",
"resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.2.9.tgz",
"integrity": "sha1-z3jsb0ptHrQ9JkiMrJfwQudLf8g=",
"dev": true,
"requires": {
"buffer-shims": "~1.0.0",
"core-util-is": "~1.0.0",
"inherits": "~2.0.1",
"isarray": "~1.0.0",
"process-nextick-args": "~1.0.6",
"string_decoder": "~1.0.0",
"util-deprecate": "~1.0.1"
}
},
"string_decoder": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.0.1.tgz",
"integrity": "sha1-YuIA8DmVWmgQ2N8KM//A8BNmLZg=",
"dev": true,
"requires": {
"safe-buffer": "^5.0.1"
}
}
}
},
"component-emitter": {
"version": "1.2.1",
"resolved": "https://registry.npmjs.org/component-emitter/-/component-emitter-1.2.1.tgz",
"integrity": "sha1-E3kY1teCg/ffemt8WmPhQOaUJeY=",
"dev": true
},
"concat-map": {
"version": "0.0.1",
"resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
"integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=",
"dev": true
},
"console-browserify": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/console-browserify/-/console-browserify-1.1.0.tgz",
"integrity": "sha1-8CQcRXMKn8YyOyBtvzjtx0HQuxA=",
"dev": true,
"requires": {
"date-now": "^0.1.4"
}
},
"copy-descriptor": {
"version": "0.1.1",
"resolved": "https://registry.npmjs.org/copy-descriptor/-/copy-descriptor-0.1.1.tgz",
"integrity": "sha1-Z29us8OZl8LuGsOpJP1hJHSPV40=",
"dev": true
},
"core-js": {
"version": "2.4.1",
"resolved": "https://registry.npmjs.org/core-js/-/core-js-2.4.1.tgz",
"integrity": "sha1-TekR5mew6ukSTjQlS1OupvxhjT4=",
"dev": true
},
"core-util-is": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz",
"integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=",
"dev": true
},
"cosmiconfig": {
"version": "5.0.7",
"resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-5.0.7.tgz",
"integrity": "sha512-PcLqxTKiDmNT6pSpy4N6KtuPwb53W+2tzNvwOZw0WH9N6O0vLIBq0x8aj8Oj75ere4YcGi48bDFCL+3fRJdlNA==",
"dev": true,
"requires": {
"import-fresh": "^2.0.0",
"is-directory": "^0.3.1",
"js-yaml": "^3.9.0",
"parse-json": "^4.0.0"
},
"dependencies": {
"esprima": {
"version": "4.0.1",
"resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
"integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
"dev": true
},
"js-yaml": {
"version": "3.12.0",
"resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.12.0.tgz",
"integrity": "sha512-PIt2cnwmPfL4hKNwqeiuz4bKfnzHTBv6HyVgjahA6mPLwPDzjDWrplJBMjHUFxku/N3FlmrbyPclad+I+4mJ3A==",
"dev": true,
"requires": {
"argparse": "^1.0.7",
"esprima": "^4.0.0"
}
},
"parse-json": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/parse-json/-/parse-json-4.0.0.tgz",
"integrity": "sha1-vjX1Qlvh9/bHRxhPmKeIy5lHfuA=",
"dev": true,
"requires": {
"error-ex": "^1.3.1",
"json-parse-better-errors": "^1.0.1"
}
}
}
},
"cross-spawn": {
"version": "5.1.0",
"resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-5.1.0.tgz",
"integrity": "sha1-6L0O/uWPz/b4+UUQoKVUu/ojVEk=",
"dev": true,
"requires": {
"lru-cache": "^4.0.1",
"shebang-command": "^1.2.0",
"which": "^1.2.9"
},
"dependencies": {
"lru-cache": {
"version": "4.0.2",
"resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-4.0.2.tgz",
"integrity": "sha1-HRdnnAac2l0ECZGgnbwsDbN35V4=",
"dev": true,
"requires": {
"pseudomap": "^1.0.1",
"yallist": "^2.0.0"
}
}
}
},
"cryptiles": {
"version": "0.2.2",
"resolved": "https://registry.npmjs.org/cryptiles/-/cryptiles-0.2.2.tgz",
"integrity": "sha1-7ZH/HxetE9N0gohZT4pIoNJvMlw=",
"dev": true,
"optional": true,
"requires": {
"boom": "0.4.x"
}
},
"cst": {
"version": "0.4.9",
"resolved": "https://registry.npmjs.org/cst/-/cst-0.4.9.tgz",
"integrity": "sha1-Ua8UITv1+OjnFZZqxkXh4qVsaDQ=",
"dev": true,
"requires": {
"babel-runtime": "^6.9.2",
"babylon": "^6.8.1",
"source-map-support": "^0.4.0"
}
},
"ctype": {
"version": "0.5.3",
"resolved": "https://registry.npmjs.org/ctype/-/ctype-0.5.3.tgz",
"integrity": "sha1-gsGMJGH3QRTvFsE1IkrQuRRMoS8=",
"dev": true,
"optional": true
},
"currently-unhandled": {
"version": "0.4.1",
"resolved": "https://registry.npmjs.org/currently-unhandled/-/currently-unhandled-0.4.1.tgz",
"integrity": "sha1-mI3zP+qxke95mmE2nddsF635V+o=",
"dev": true,
"requires": {
"array-find-index": "^1.0.1"
}
},
"cycle": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/cycle/-/cycle-1.0.3.tgz",
"integrity": "sha1-IegLK+hYD5i0aPN5QwZisEbDStI=",
"dev": true
},
"dargs": {
"version": "5.1.0",
"resolved": "https://registry.npmjs.org/dargs/-/dargs-5.1.0.tgz",
"integrity": "sha1-7H6lDHhWTNNsnV7Bj2Yyn63ieCk=",
"dev": true
},
"date-fns": {
"version": "1.29.0",
"resolved": "https://registry.npmjs.org/date-fns/-/date-fns-1.29.0.tgz",
"integrity": "sha512-lbTXWZ6M20cWH8N9S6afb0SBm6tMk+uUg6z3MqHPKE9atmsY3kJkTm8vKe93izJ2B2+q5MV990sM2CHgtAZaOw==",
"dev": true
},
"date-now": {
"version": "0.1.4",
"resolved": "https://registry.npmjs.org/date-now/-/date-now-0.1.4.tgz",
"integrity": "sha1-6vQ5/U1ISK105cx9vvIAZyueNFs=",
"dev": true
},
"dateformat": {
"version": "1.0.12",
"resolved": "https://registry.npmjs.org/dateformat/-/dateformat-1.0.12.tgz",
"integrity": "sha1-nxJLZ1lMk3/3BpMuSmQsyo27/uk=",
"dev": true,
"requires": {
"get-stdin": "^4.0.1",
"meow": "^3.3.0"
}
},
"dcp": {
"version": "0.1.3",
"resolved": "https://registry.npmjs.org/dcp/-/dcp-0.1.3.tgz",
"integrity": "sha1-FUi5zSWwNsHs9vfi2sjivUV5W+s=",
"dev": true
},
"debug": {
"version": "2.6.8",
"resolved": "https://registry.npmjs.org/debug/-/debug-2.6.8.tgz",
"integrity": "sha1-5zFTHKLt4n0YgiJCfaF4IdaP9Pw=",
"dev": true,
"requires": {
"ms": "2.0.0"
}
},
"decamelize": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz",
"integrity": "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=",
"dev": true
},
"decode-uri-component": {
"version": "0.2.0",
"resolved": "https://registry.npmjs.org/decode-uri-component/-/decode-uri-component-0.2.0.tgz",
"integrity": "sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU=",
"dev": true
},
"dedent": {
"version": "0.7.0",
"resolved": "https://registry.npmjs.org/dedent/-/dedent-0.7.0.tgz",
"integrity": "sha1-JJXduvbrh0q7Dhvp3yLS5aVEMmw=",
"dev": true
},
"deep-equal": {
"version": "0.1.2",
"resolved": "https://registry.npmjs.org/deep-equal/-/deep-equal-0.1.2.tgz",
"integrity": "sha1-skbCuApXCkfBG+HZvRBw7IeLh84=",
"dev": true
},
"deep-is": {
"version": "0.1.3",
"resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.3.tgz",
"integrity": "sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ=",
"dev": true
},
"defaults": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/defaults/-/defaults-1.0.3.tgz",
"integrity": "sha1-xlYFHpgX2f8I7YgUd/P+QBnz730=",
"dev": true,
"requires": {
"clone": "^1.0.2"
}
},
"define-property": {
"version": "2.0.2",
"resolved": "https://registry.npmjs.org/define-property/-/define-property-2.0.2.tgz",
"integrity": "sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==",
"dev": true,
"requires": {
"is-descriptor": "^1.0.2",
"isobject": "^3.0.1"
},
"dependencies": {
"is-accessor-descriptor": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz",
"integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==",
"dev": true,
"requires": {
"kind-of": "^6.0.0"
}
},
"is-data-descriptor": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz",
"integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==",
"dev": true,
"requires": {
"kind-of": "^6.0.0"
}
},
"is-descriptor": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz",
"integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==",
"dev": true,
"requires": {
"is-accessor-descriptor": "^1.0.0",
"is-data-descriptor": "^1.0.0",
"kind-of": "^6.0.2"
}
},
"isobject": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz",
"integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=",
"dev": true
},
"kind-of": {
"version": "6.0.2",
"resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.2.tgz",
"integrity": "sha512-s5kLOcnH0XqDO+FvuaLX8DDjZ18CGFk7VygH40QoKPUQhW4e2rvM0rwUq0t8IQDOwYSeLK01U90OjzBTme2QqA==",
"dev": true
}
}
},
"defined": {
"version": "0.0.0",
"resolved": "https://registry.npmjs.org/defined/-/defined-0.0.0.tgz",
"integrity": "sha1-817qfXBekzuvE7LwOz+D2SFAOz4=",
"dev": true
},
"del": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/del/-/del-3.0.0.tgz",
"integrity": "sha1-U+z2mf/LyzljdpGrE7rxYIGXZuU=",
"dev": true,
"requires": {
"globby": "^6.1.0",
"is-path-cwd": "^1.0.0",
"is-path-in-cwd": "^1.0.0",
"p-map": "^1.1.1",
"pify": "^3.0.0",
"rimraf": "^2.2.8"
},
"dependencies": {
"pify": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz",
"integrity": "sha1-5aSs0sEB/fPZpNB/DbxNtJ3SgXY=",
"dev": true
}
}
},
"delayed-stream": {
"version": "0.0.5",
"resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-0.0.5.tgz",
"integrity": "sha1-1LH0OpPoKW3+AmlPRoC8N6MTxz8=",
"dev": true,
"optional": true
},
"deprecated": {
"version": "0.0.1",
"resolved": "https://registry.npmjs.org/deprecated/-/deprecated-0.0.1.tgz",
"integrity": "sha1-+cmvVGSvoeepcUWKi97yqpTVuxk=",
"dev": true
},
"detect-file": {
"version": "0.1.0",
"resolved": "https://registry.npmjs.org/detect-file/-/detect-file-0.1.0.tgz",
"integrity": "sha1-STXe39lIhkjgBrASlWbpOGcR6mM=",
"dev": true,
"requires": {
"fs-exists-sync": "^0.1.0"
}
},
"diff": {
"version": "3.2.0",
"resolved": "https://registry.npmjs.org/diff/-/diff-3.2.0.tgz",
"integrity": "sha1-yc45Okt8vQsFinJck98pkCeGj/k=",
"dev": true
},
"dom-serializer": {
"version": "0.1.0",
"resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-0.1.0.tgz",
"integrity": "sha1-BzxpdUbOB4DOI75KKOKT5AvDDII=",
"dev": true,
"requires": {
"domelementtype": "~1.1.1",
"entities": "~1.1.1"
},
"dependencies": {
"domelementtype": {
"version": "1.1.3",
"resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-1.1.3.tgz",
"integrity": "sha1-vSh3PiZCiBrsUVRJJCmcXNgiGFs=",
"dev": true
},
"entities": {
"version": "1.1.1",
"resolved": "https://registry.npmjs.org/entities/-/entities-1.1.1.tgz",
"integrity": "sha1-blwtClYhtdra7O+AuQ7ftc13cvA=",
"dev": true
}
}
},
"domelementtype": {
"version": "1.3.0",
"resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-1.3.0.tgz",
"integrity": "sha1-sXrtguirWeUt2cGbF1bg/BhyBMI=",
"dev": true
},
"domhandler": {
"version": "2.3.0",
"resolved": "https://registry.npmjs.org/domhandler/-/domhandler-2.3.0.tgz",
"integrity": "sha1-LeWaCCLVAn+r/28DLCsloqir5zg=",
"dev": true,
"requires": {
"domelementtype": "1"
}
},
"domutils": {
"version": "1.5.1",
"resolved": "https://registry.npmjs.org/domutils/-/domutils-1.5.1.tgz",
"integrity": "sha1-3NhIiib1Y9YQeeSMn3t+Mjc2gs8=",
"dev": true,
"requires": {
"dom-serializer": "0",
"domelementtype": "1"
}
},
"duplexer": {
"version": "0.1.1",
"resolved": "https://registry.npmjs.org/duplexer/-/duplexer-0.1.1.tgz",
"integrity": "sha1-rOb/gIwc5mtX0ev5eXessCM0z8E=",
"dev": true
},
"duplexer2": {
"version": "0.0.2",
"resolved": "https://registry.npmjs.org/duplexer2/-/duplexer2-0.0.2.tgz",
"integrity": "sha1-xhTc9n4vsUmVqRcR5aYX6KYKMds=",
"dev": true,
"requires": {
"readable-stream": "~1.1.9"
},
"dependencies": {
"readable-stream": {
"version": "1.1.14",
"resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz",
"integrity": "sha1-fPTFTvZI44EwhMY23SB54WbAgdk=",
"dev": true,
"requires": {
"core-util-is": "~1.0.0",
"inherits": "~2.0.1",
"isarray": "0.0.1",
"string_decoder": "~0.10.x"
}
}
}
},
"elegant-spinner": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/elegant-spinner/-/elegant-spinner-1.0.1.tgz",
"integrity": "sha1-2wQ1IcldfjA/2PNFvtwzSc+wcp4=",
"dev": true
},
"end-of-stream": {
"version": "0.1.5",
"resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-0.1.5.tgz",
"integrity": "sha1-jhdyBsPICDfYVjLouTWd/osvbq8=",
"dev": true,
"requires": {
"once": "~1.3.0"
}
},
"entities": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/entities/-/entities-1.0.0.tgz",
"integrity": "sha1-sph6o4ITR/zeZCsk/fyeT7cSvyY=",
"dev": true
},
"error-ex": {
"version": "1.3.1",
"resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.1.tgz",
"integrity": "sha1-+FWobOYa3E6GIcPNoh56dhLDqNw=",
"dev": true,
"requires": {
"is-arrayish": "^0.2.1"
}
},
"escape-string-regexp": {
"version": "1.0.5",
"resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
"integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=",
"dev": true
},
"escodegen": {
"version": "1.8.1",
"resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.8.1.tgz",
"integrity": "sha1-WltTr0aTEQvrsIZ6o0MN07cKEBg=",
"dev": true,
"requires": {
"esprima": "^2.7.1",
"estraverse": "^1.9.1",
"esutils": "^2.0.2",
"optionator": "^0.8.1",
"source-map": "~0.2.0"
},
"dependencies": {
"estraverse": {
"version": "1.9.3",
"resolved": "https://registry.npmjs.org/estraverse/-/estraverse-1.9.3.tgz",
"integrity": "sha1-r2fy3JIlgkFZUJJgkaQAXSnJu0Q=",
"dev": true
},
"source-map": {
"version": "0.2.0",
"resolved": "https://registry.npmjs.org/source-map/-/source-map-0.2.0.tgz",
"integrity": "sha1-2rc/vPwrqBm03gO9b26qSBZLP50=",
"dev": true,
"optional": true,
"requires": {
"amdefine": ">=0.0.4"
}
}
}
},
"esprima": {
"version": "2.7.3",
"resolved": "https://registry.npmjs.org/esprima/-/esprima-2.7.3.tgz",
"integrity": "sha1-luO3DVd59q1JzQMmc9HDEnZ7pYE=",
"dev": true
},
"estraverse": {
"version": "4.2.0",
"resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.2.0.tgz",
"integrity": "sha1-De4/7TH81GlhjOc0IJn8GvoL2xM=",
"dev": true
},
"esutils": {
"version": "2.0.2",
"resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.2.tgz",
"integrity": "sha1-Cr9PHKpbyx96nYrMbepPqqBLrJs=",
"dev": true
},
"execa": {
"version": "0.6.3",
"resolved": "https://registry.npmjs.org/execa/-/execa-0.6.3.tgz",
"integrity": "sha1-V7aaWU8IF1nGnlNw8NF7nLEWWP4=",
"dev": true,
"requires": {
"cross-spawn": "^5.0.1",
"get-stream": "^3.0.0",
"is-stream": "^1.1.0",
"npm-run-path": "^2.0.0",
"p-finally": "^1.0.0",
"signal-exit": "^3.0.0",
"strip-eof": "^1.0.0"
}
},
"exit": {
"version": "0.1.2",
"resolved": "https://registry.npmjs.org/exit/-/exit-0.1.2.tgz",
"integrity": "sha1-BjJjj42HfMghB9MKD/8aF8uhzQw=",
"dev": true
},
"expand-brackets": {
"version": "0.1.5",
"resolved": "https://registry.npmjs.org/expand-brackets/-/expand-brackets-0.1.5.tgz",
"integrity": "sha1-3wcoTjQqgHzXM6xa9yQR5YHRF3s=",
"dev": true,
"requires": {
"is-posix-bracket": "^0.1.0"
}
},
"expand-range": {
"version": "1.8.2",
"resolved": "https://registry.npmjs.org/expand-range/-/expand-range-1.8.2.tgz",
"integrity": "sha1-opnv/TNf4nIeuujiV+x5ZE/IUzc=",
"dev": true,
"requires": {
"fill-range": "^2.1.0"
}
},
"expand-tilde": {
"version": "1.2.2",
"resolved": "https://registry.npmjs.org/expand-tilde/-/expand-tilde-1.2.2.tgz",
"integrity": "sha1-C4HrqJflo9MdHD0QL48BRB5VlEk=",
"dev": true,
"requires": {
"os-homedir": "^1.0.1"
}
},
"extend": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/extend/-/extend-3.0.1.tgz",
"integrity": "sha1-p1Xqe8Gt/MWjHOfnYtuq3F5jZEQ=",
"dev": true
},
"extend-shallow": {
"version": "1.1.4",
"resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-1.1.4.tgz",
"integrity": "sha1-Gda/lN/AnXa6cR85uHLSH/TdkHE=",
"dev": true,
"requires": {
"kind-of": "^1.1.0"
},
"dependencies": {
"kind-of": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/kind-of/-/kind-of-1.1.0.tgz",
"integrity": "sha1-FAo9LUGjbS78+pN3tiwk+ElaXEQ=",
"dev": true
}
}
},
"extglob": {
"version": "0.3.2",
"resolved": "https://registry.npmjs.org/extglob/-/extglob-0.3.2.tgz",
"integrity": "sha1-Lhj/PS9JqydlzskCPwEdqo2DSaE=",
"dev": true,
"requires": {
"is-extglob": "^1.0.0"
}
},
"eyes": {
"version": "0.1.8",
"resolved": "https://registry.npmjs.org/eyes/-/eyes-0.1.8.tgz",
"integrity": "sha1-Ys8SAjTGg3hdkCNIqADvPgzCC8A=",
"dev": true
},
"fancy-log": {
"version": "1.3.0",
"resolved": "https://registry.npmjs.org/fancy-log/-/fancy-log-1.3.0.tgz",
"integrity": "sha1-Rb4X0Cu5kX1gzP/UmVyZnmyMmUg=",
"dev": true,
"requires": {
"chalk": "^1.1.1",
"time-stamp": "^1.0.0"
}
},
"fast-levenshtein": {
"version": "2.0.6",
"resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
"integrity": "sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=",
"dev": true
},
"figures": {
"version": "1.7.0",
"resolved": "https://registry.npmjs.org/figures/-/figures-1.7.0.tgz",
"integrity": "sha1-y+Hjr/zxzUS4DK3+0o3Hk6lwHS4=",
"dev": true,
"requires": {
"escape-string-regexp": "^1.0.5",
"object-assign": "^4.1.0"
}
},
"filename-regex": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/filename-regex/-/filename-regex-2.0.1.tgz",
"integrity": "sha1-wcS5vuPglyXdsQa3XB4wH+LxiyY=",
"dev": true
},
"fill-range": {
"version": "2.2.3",
"resolved": "https://registry.npmjs.org/fill-range/-/fill-range-2.2.3.tgz",
"integrity": "sha1-ULd9/X5Gm8dJJHCWNpn+eoSFpyM=",
"dev": true,
"requires": {
"is-number": "^2.1.0",
"isobject": "^2.0.0",
"randomatic": "^1.1.3",
"repeat-element": "^1.1.2",
"repeat-string": "^1.5.2"
}
},
"find-index": {
"version": "0.1.1",
"resolved": "https://registry.npmjs.org/find-index/-/find-index-0.1.1.tgz",
"integrity": "sha1-Z101iyyjiS15Whq0cjL4tuLg3eQ=",
"dev": true
},
"find-parent-dir": {
"version": "0.3.0",
"resolved": "https://registry.npmjs.org/find-parent-dir/-/find-parent-dir-0.3.0.tgz",
"integrity": "sha1-M8RLQpqysvBkYpnF+fcY83b/jVQ=",
"dev": true
},
"find-up": {
"version": "1.1.2",
"resolved": "https://registry.npmjs.org/find-up/-/find-up-1.1.2.tgz",
"integrity": "sha1-ay6YIrGizgpgq2TWEOzK1TyyTQ8=",
"dev": true,
"requires": {
"path-exists": "^2.0.0",
"pinkie-promise": "^2.0.0"
}
},
"findup-sync": {
"version": "0.4.3",
"resolved": "https://registry.npmjs.org/findup-sync/-/findup-sync-0.4.3.tgz",
"integrity": "sha1-QAQ5Kee8YK3wt/SCfExudaDeyhI=",
"dev": true,
"requires": {
"detect-file": "^0.1.0",
"is-glob": "^2.0.1",
"micromatch": "^2.3.7",
"resolve-dir": "^0.1.0"
}
},
"fined": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/fined/-/fined-1.0.2.tgz",
"integrity": "sha1-WyhCS3YNdZiWC374SA3/itNmDpc=",
"dev": true,
"requires": {
"expand-tilde": "^1.2.1",
"lodash.assignwith": "^4.0.7",
"lodash.isempty": "^4.2.1",
"lodash.isplainobject": "^4.0.4",
"lodash.isstring": "^4.0.1",
"lodash.pick": "^4.2.1",
"parse-filepath": "^1.0.1"
}
},
"first-chunk-stream": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/first-chunk-stream/-/first-chunk-stream-1.0.0.tgz",
"integrity": "sha1-Wb+1DNkF9g18OUzT2ayqtOatk04=",
"dev": true
},
"flagged-respawn": {
"version": "0.3.2",
"resolved": "https://registry.npmjs.org/flagged-respawn/-/flagged-respawn-0.3.2.tgz",
"integrity": "sha1-/xke3c1wiKZ1smEP/8l2vpuAdLU=",
"dev": true
},
"for-in": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/for-in/-/for-in-1.0.2.tgz",
"integrity": "sha1-gQaNKVqBQuwKxybG4iAMMPttXoA=",
"dev": true
},
"for-own": {
"version": "0.1.5",
"resolved": "https://registry.npmjs.org/for-own/-/for-own-0.1.5.tgz",
"integrity": "sha1-UmXGgaTylNq78XyVCbZ2OqhFEM4=",
"dev": true,
"requires": {
"for-in": "^1.0.1"
}
},
"forever-agent": {
"version": "0.5.2",
"resolved": "https://registry.npmjs.org/forever-agent/-/forever-agent-0.5.2.tgz",
"integrity": "sha1-bQ4JxJIflKJ/Y9O0nF/v8epMUTA=",
"dev": true
},
"form-data": {
"version": "0.1.4",
"resolved": "https://registry.npmjs.org/form-data/-/form-data-0.1.4.tgz",
"integrity": "sha1-kavXiKupcCsaq/qLwBAxoqyeOxI=",
"dev": true,
"optional": true,
"requires": {
"async": "~0.9.0",
"combined-stream": "~0.0.4",
"mime": "~1.2.11"
},
"dependencies": {
"async": {
"version": "0.9.2",
"resolved": "https://registry.npmjs.org/async/-/async-0.9.2.tgz",
"integrity": "sha1-rqdNXmHB+JlhO/ZL2mbUx48v0X0=",
"dev": true,
"optional": true
}
}
},
"fragment-cache": {
"version": "0.2.1",
"resolved": "https://registry.npmjs.org/fragment-cache/-/fragment-cache-0.2.1.tgz",
"integrity": "sha1-QpD60n8T6Jvn8zeZxrxaCr//DRk=",
"dev": true,
"requires": {
"map-cache": "^0.2.2"
}
},
"fs-exists-sync": {
"version": "0.1.0",
"resolved": "https://registry.npmjs.org/fs-exists-sync/-/fs-exists-sync-0.1.0.tgz",
"integrity": "sha1-mC1ok6+RjnLQjeyehnP/K1qNat0=",
"dev": true
},
"fs-extra": {
"version": "4.0.2",
"resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-4.0.2.tgz",
"integrity": "sha1-+RcExT0bRh+JNFKwwwfZmXZHq2s=",
"dev": true,
"requires": {
"graceful-fs": "^4.1.2",
"jsonfile": "^4.0.0",
"universalify": "^0.1.0"
}
},
"fs.realpath": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
"integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=",
"dev": true
},
"func-comparator": {
"version": "0.7.3",
"resolved": "https://registry.npmjs.org/func-comparator/-/func-comparator-0.7.3.tgz",
"integrity": "sha1-iUtKgIlCTZNLxxA6qoCQV6tPSrw=",
"dev": true,
"requires": {
"neo-timer": "^0.2.0"
}
},
"g-status": {
"version": "2.0.2",
"resolved": "https://registry.npmjs.org/g-status/-/g-status-2.0.2.tgz",
"integrity": "sha512-kQoE9qH+T1AHKgSSD0Hkv98bobE90ILQcXAF4wvGgsr7uFqNvwmh8j+Lq3l0RVt3E3HjSbv2B9biEGcEtpHLCA==",
"dev": true,
"requires": {
"arrify": "^1.0.1",
"matcher": "^1.0.0",
"simple-git": "^1.85.0"
}
},
"gaze": {
"version": "0.5.2",
"resolved": "https://registry.npmjs.org/gaze/-/gaze-0.5.2.tgz",
"integrity": "sha1-QLcJU30k0dRXZ9takIaJ3+aaxE8=",
"dev": true,
"requires": {
"globule": "~0.1.0"
}
},
"get-own-enumerable-property-symbols": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/get-own-enumerable-property-symbols/-/get-own-enumerable-property-symbols-3.0.0.tgz",
"integrity": "sha512-CIJYJC4GGF06TakLg8z4GQKvDsx9EMspVxOYih7LerEL/WosUnFIww45CGfxfeKHqlg3twgUrYRT1O3WQqjGCg==",
"dev": true
},
"get-stdin": {
"version": "4.0.1",
"resolved": "https://registry.npmjs.org/get-stdin/-/get-stdin-4.0.1.tgz",
"integrity": "sha1-uWjGsKBDhDJJAui/Gl3zJXmkUP4=",
"dev": true
},
"get-stream": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/get-stream/-/get-stream-3.0.0.tgz",
"integrity": "sha1-jpQ9E1jcN1VQVOy+LtsFqhdO3hQ=",
"dev": true
},
"get-value": {
"version": "2.0.6",
"resolved": "https://registry.npmjs.org/get-value/-/get-value-2.0.6.tgz",
"integrity": "sha1-3BXKHGcjh8p2vTesCjlbogQqLCg=",
"dev": true
},
"glob": {
"version": "4.5.3",
"resolved": "https://registry.npmjs.org/glob/-/glob-4.5.3.tgz",
"integrity": "sha1-xstz0yJsHv7wTePFbQEvAzd+4V8=",
"dev": true,
"requires": {
"inflight": "^1.0.4",
"inherits": "2",
"minimatch": "^2.0.1",
"once": "^1.3.0"
}
},
"glob-base": {
"version": "0.3.0",
"resolved": "https://registry.npmjs.org/glob-base/-/glob-base-0.3.0.tgz",
"integrity": "sha1-27Fk9iIbHAscz4Kuoyi0l98Oo8Q=",
"dev": true,
"requires": {
"glob-parent": "^2.0.0",
"is-glob": "^2.0.0"
}
},
"glob-parent": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-2.0.0.tgz",
"integrity": "sha1-gTg9ctsFT8zPUzbaqQLxgvbtuyg=",
"dev": true,
"requires": {
"is-glob": "^2.0.0"
}
},
"glob-stream": {
"version": "3.1.18",
"resolved": "https://registry.npmjs.org/glob-stream/-/glob-stream-3.1.18.tgz",
"integrity": "sha1-kXCl8St5Awb9/lmPMT+PeVT9FDs=",
"dev": true,
"requires": {
"glob": "^4.3.1",
"glob2base": "^0.0.12",
"minimatch": "^2.0.1",
"ordered-read-streams": "^0.1.0",
"through2": "^0.6.1",
"unique-stream": "^1.0.0"
},
"dependencies": {
"through2": {
"version": "0.6.5",
"resolved": "https://registry.npmjs.org/through2/-/through2-0.6.5.tgz",
"integrity": "sha1-QaucZ7KdVyCQcUEOHXp6lozTrUg=",
"dev": true,
"requires": {
"readable-stream": ">=1.0.33-1 <1.1.0-0",
"xtend": ">=4.0.0 <4.1.0-0"
}
}
}
},
"glob-watcher": {
"version": "0.0.6",
"resolved": "https://registry.npmjs.org/glob-watcher/-/glob-watcher-0.0.6.tgz",
"integrity": "sha1-uVtKjfdLOcgymLDAXJeLTZo7cQs=",
"dev": true,
"requires": {
"gaze": "^0.5.1"
}
},
"glob2base": {
"version": "0.0.12",
"resolved": "https://registry.npmjs.org/glob2base/-/glob2base-0.0.12.tgz",
"integrity": "sha1-nUGbPijxLoOjYhZKJ3BVkiycDVY=",
"dev": true,
"requires": {
"find-index": "^0.1.1"
}
},
"global-modules": {
"version": "0.2.3",
"resolved": "https://registry.npmjs.org/global-modules/-/global-modules-0.2.3.tgz",
"integrity": "sha1-6lo77ULG1s6ZWk+KEmm12uIjgo0=",
"dev": true,
"requires": {
"global-prefix": "^0.1.4",
"is-windows": "^0.2.0"
}
},
"global-prefix": {
"version": "0.1.5",
"resolved": "https://registry.npmjs.org/global-prefix/-/global-prefix-0.1.5.tgz",
"integrity": "sha1-jTvGuNo8qBEqFg2NSW/wRiv+948=",
"dev": true,
"requires": {
"homedir-polyfill": "^1.0.0",
"ini": "^1.3.4",
"is-windows": "^0.2.0",
"which": "^1.2.12"
}
},
"globby": {
"version": "6.1.0",
"resolved": "http://registry.npmjs.org/globby/-/globby-6.1.0.tgz",
"integrity": "sha1-9abXDoOV4hyFj7BInWTfAkJNUGw=",
"dev": true,
"requires": {
"array-union": "^1.0.1",
"glob": "^7.0.3",
"object-assign": "^4.0.1",
"pify": "^2.0.0",
"pinkie-promise": "^2.0.0"
},
"dependencies": {
"glob": {
"version": "7.1.3",
"resolved": "https://registry.npmjs.org/glob/-/glob-7.1.3.tgz",
"integrity": "sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==",
"dev": true,
"requires": {
"fs.realpath": "^1.0.0",
"inflight": "^1.0.4",
"inherits": "2",
"minimatch": "^3.0.4",
"once": "^1.3.0",
"path-is-absolute": "^1.0.0"
}
},
"minimatch": {
"version": "3.0.4",
"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
"integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
"dev": true,
"requires": {
"brace-expansion": "^1.1.7"
}
}
}
},
"globule": {
"version": "0.1.0",
"resolved": "https://registry.npmjs.org/globule/-/globule-0.1.0.tgz",
"integrity": "sha1-2cjt3h2nnRJaFRt5UzuXhnY0auU=",
"dev": true,
"requires": {
"glob": "~3.1.21",
"lodash": "~1.0.1",
"minimatch": "~0.2.11"
},
"dependencies": {
"glob": {
"version": "3.1.21",
"resolved": "https://registry.npmjs.org/glob/-/glob-3.1.21.tgz",
"integrity": "sha1-0p4KBV3qUTj00H7UDomC6DwgZs0=",
"dev": true,
"requires": {
"graceful-fs": "~1.2.0",
"inherits": "1",
"minimatch": "~0.2.11"
}
},
"graceful-fs": {
"version": "1.2.3",
"resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-1.2.3.tgz",
"integrity": "sha1-FaSAaldUfLLS2/J/QuiajDRRs2Q=",
"dev": true
},
"inherits": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/inherits/-/inherits-1.0.2.tgz",
"integrity": "sha1-ykMJ2t7mtUzAuNJH6NfHoJdb3Js=",
"dev": true
},
"lodash": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/lodash/-/lodash-1.0.2.tgz",
"integrity": "sha1-j1dWDIO1n8JwvT1WG2kAQ0MOJVE=",
"dev": true
},
"minimatch": {
"version": "0.2.14",
"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-0.2.14.tgz",
"integrity": "sha1-x054BXT2PG+aCQ6Q775u9TpqdWo=",
"dev": true,
"requires": {
"lru-cache": "2",
"sigmund": "~1.0.0"
}
}
}
},
"glogg": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/glogg/-/glogg-1.0.0.tgz",
"integrity": "sha1-f+DxmfV6yQbPUS/urY+Q7kooT8U=",
"dev": true,
"requires": {
"sparkles": "^1.0.0"
}
},
"graceful-fs": {
"version": "4.1.11",
"resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.1.11.tgz",
"integrity": "sha1-Dovf5NHduIVNZOBOp8AOKgJuVlg=",
"dev": true
},
"graceful-readlink": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/graceful-readlink/-/graceful-readlink-1.0.1.tgz",
"integrity": "sha1-TK+tdrxi8C+gObL5Tpo906ORpyU=",
"dev": true
},
"growl": {
"version": "1.9.2",
"resolved": "https://registry.npmjs.org/growl/-/growl-1.9.2.tgz",
"integrity": "sha1-Dqd0NxXbjY3ixe3hd14bRayFwC8=",
"dev": true
},
"gulp": {
"version": "3.9.1",
"resolved": "https://registry.npmjs.org/gulp/-/gulp-3.9.1.tgz",
"integrity": "sha1-VxzkWSjdQK9lFPxAEYZgFsE4RbQ=",
"dev": true,
"requires": {
"archy": "^1.0.0",
"chalk": "^1.0.0",
"deprecated": "^0.0.1",
"gulp-util": "^3.0.0",
"interpret": "^1.0.0",
"liftoff": "^2.1.0",
"minimist": "^1.1.0",
"orchestrator": "^0.3.0",
"pretty-hrtime": "^1.0.0",
"semver": "^4.1.0",
"tildify": "^1.0.0",
"v8flags": "^2.0.2",
"vinyl-fs": "^0.3.0"
}
},
"gulp-bump": {
"version": "2.8.0",
"resolved": "https://registry.npmjs.org/gulp-bump/-/gulp-bump-2.8.0.tgz",
"integrity": "sha512-syvQLax2xQo1EDFJxanUqX1rv+YkVB4/cx/THN+uInmSjMGezT1/6WYLdXqkBAMQUw2KlyB2melz0DzrHdwkLA==",
"dev": true,
"requires": {
"bump-regex": "^2.8.0",
"plugin-error": "^0.1.2",
"plugin-log": "^0.1.0",
"semver": "^5.3.0",
"through2": "^2.0.1"
},
"dependencies": {
"semver": {
"version": "5.4.1",
"resolved": "https://registry.npmjs.org/semver/-/semver-5.4.1.tgz",
"integrity": "sha512-WfG/X9+oATh81XtllIo/I8gOiY9EXRdv1cQdyykeXK17YcUW3EXUAi2To4pcH6nZtJPr7ZOpM5OMyWJZm+8Rsg==",
"dev": true
}
}
},
"gulp-exit": {
"version": "0.0.2",
"resolved": "https://registry.npmjs.org/gulp-exit/-/gulp-exit-0.0.2.tgz",
"integrity": "sha1-CCMTVIaDrQqwXUMNelYzMNTmE3A=",
"dev": true
},
"gulp-git": {
"version": "2.4.2",
"resolved": "https://registry.npmjs.org/gulp-git/-/gulp-git-2.4.2.tgz",
"integrity": "sha512-YgFW2PmtGSHkUYFql75ByRqFjiEDvOk7jxVkkqH0OSDKc3icxD8GDBR1kbr2zG7oNaIynk2NcKVSypgPHl7ibQ==",
"dev": true,
"requires": {
"any-shell-escape": "^0.1.1",
"gulp-util": "^3.0.8",
"require-dir": "^0.3.2",
"strip-bom-stream": "^3.0.0",
"through2": "^2.0.3",
"vinyl": "^2.0.1"
},
"dependencies": {
"clone": {
"version": "2.1.1",
"resolved": "https://registry.npmjs.org/clone/-/clone-2.1.1.tgz",
"integrity": "sha1-0hfR6WERjjrJpLi7oyhVU79kfNs=",
"dev": true
},
"clone-stats": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/clone-stats/-/clone-stats-1.0.0.tgz",
"integrity": "sha1-s3gt/4u1R04Yuba/D9/ngvh3doA=",
"dev": true
},
"replace-ext": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/replace-ext/-/replace-ext-1.0.0.tgz",
"integrity": "sha1-3mMSg3P8v3w8z6TeWkgMRaZ5WOs=",
"dev": true
},
"vinyl": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/vinyl/-/vinyl-2.1.0.tgz",
"integrity": "sha1-Ah+cLPlR1rk5lDyJ617lrdT9kkw=",
"dev": true,
"requires": {
"clone": "^2.1.1",
"clone-buffer": "^1.0.0",
"clone-stats": "^1.0.0",
"cloneable-readable": "^1.0.0",
"remove-trailing-separator": "^1.0.1",
"replace-ext": "^1.0.0"
}
}
}
},
"gulp-jscs": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/gulp-jscs/-/gulp-jscs-4.0.0.tgz",
"integrity": "sha1-TbLWP5IHzkpUtbJnkOMY40a3aoU=",
"dev": true,
"requires": {
"gulp-util": "^3.0.4",
"jscs": "^3.0.4",
"through2": "^2.0.0",
"tildify": "^1.0.0"
}
},
"gulp-mocha": {
"version": "4.3.1",
"resolved": "https://registry.npmjs.org/gulp-mocha/-/gulp-mocha-4.3.1.tgz",
"integrity": "sha1-d5ULQ7z/gWWVdnwHNOD9p9Fz3Nk=",
"dev": true,
"requires": {
"dargs": "^5.1.0",
"execa": "^0.6.0",
"gulp-util": "^3.0.0",
"mocha": "^3.0.0",
"npm-run-path": "^2.0.2",
"through2": "^2.0.3"
}
},
"gulp-tag-version": {
"version": "1.3.0",
"resolved": "https://registry.npmjs.org/gulp-tag-version/-/gulp-tag-version-1.3.0.tgz",
"integrity": "sha1-hEjIfu0YZtuObLWYvEGb4t98R9s=",
"dev": true,
"requires": {
"gulp-git": "~0.3.6",
"gulp-util": "~2.2.14",
"map-stream": "~0.1.0"
},
"dependencies": {
"ansi-regex": {
"version": "0.2.1",
"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-0.2.1.tgz",
"integrity": "sha1-DY6UaWej2BQ/k+JOKYUl/BsiNfk=",
"dev": true
},
"ansi-styles": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-1.1.0.tgz",
"integrity": "sha1-6uy/Zs1waIJ2Cy9GkVgrj1XXp94=",
"dev": true
},
"chalk": {
"version": "0.5.1",
"resolved": "https://registry.npmjs.org/chalk/-/chalk-0.5.1.tgz",
"integrity": "sha1-Zjs6ZItotV0EaQ1JFnqoN4WPIXQ=",
"dev": true,
"requires": {
"ansi-styles": "^1.1.0",
"escape-string-regexp": "^1.0.0",
"has-ansi": "^0.1.0",
"strip-ansi": "^0.3.0",
"supports-color": "^0.2.0"
}
},
"gulp-git": {
"version": "0.3.6",
"resolved": "https://registry.npmjs.org/gulp-git/-/gulp-git-0.3.6.tgz",
"integrity": "sha1-d+w9oiklwkbt15bKENQWOWXYFAo=",
"dev": true,
"requires": {
"any-shell-escape": "^0.1.1",
"gulp-util": "~2.2.14",
"map-stream": "~0.1.0",
"through2": "^0.4.1"
}
},
"gulp-util": {
"version": "2.2.20",
"resolved": "https://registry.npmjs.org/gulp-util/-/gulp-util-2.2.20.tgz",
"integrity": "sha1-1xRuVyiRC9jwR6awseVJvCLb1kw=",
"dev": true,
"requires": {
"chalk": "^0.5.0",
"dateformat": "^1.0.7-1.2.3",
"lodash._reinterpolate": "^2.4.1",
"lodash.template": "^2.4.1",
"minimist": "^0.2.0",
"multipipe": "^0.1.0",
"through2": "^0.5.0",
"vinyl": "^0.2.1"
},
"dependencies": {
"through2": {
"version": "0.5.1",
"resolved": "https://registry.npmjs.org/through2/-/through2-0.5.1.tgz",
"integrity": "sha1-390BLrnHAOIyP9M084rGIqs3Lac=",
"dev": true,
"requires": {
"readable-stream": "~1.0.17",
"xtend": "~3.0.0"
}
}
}
},
"has-ansi": {
"version": "0.1.0",
"resolved": "https://registry.npmjs.org/has-ansi/-/has-ansi-0.1.0.tgz",
"integrity": "sha1-hPJlqujA5qiKEtcCKJS3VoiUxi4=",
"dev": true,
"requires": {
"ansi-regex": "^0.2.0"
}
},
"lodash._reinterpolate": {
"version": "2.4.1",
"resolved": "https://registry.npmjs.org/lodash._reinterpolate/-/lodash._reinterpolate-2.4.1.tgz",
"integrity": "sha1-TxInqlqHEfxjL1sHofRgequLMiI=",
"dev": true
},
"lodash.escape": {
"version": "2.4.1",
"resolved": "https://registry.npmjs.org/lodash.escape/-/lodash.escape-2.4.1.tgz",
"integrity": "sha1-LOEsXghNsKV92l5dHu659dF1o7Q=",
"dev": true,
"requires": {
"lodash._escapehtmlchar": "~2.4.1",
"lodash._reunescapedhtml": "~2.4.1",
"lodash.keys": "~2.4.1"
}
},
"lodash.keys": {
"version": "2.4.1",
"resolved": "https://registry.npmjs.org/lodash.keys/-/lodash.keys-2.4.1.tgz",
"integrity": "sha1-SN6kbfj/djKxDXBrissmWR4rNyc=",
"dev": true,
"requires": {
"lodash._isnative": "~2.4.1",
"lodash._shimkeys": "~2.4.1",
"lodash.isobject": "~2.4.1"
}
},
"lodash.template": {
"version": "2.4.1",
"resolved": "https://registry.npmjs.org/lodash.template/-/lodash.template-2.4.1.tgz",
"integrity": "sha1-nmEQB+32KRKal0qzxIuBez4c8g0=",
"dev": true,
"requires": {
"lodash._escapestringchar": "~2.4.1",
"lodash._reinterpolate": "~2.4.1",
"lodash.defaults": "~2.4.1",
"lodash.escape": "~2.4.1",
"lodash.keys": "~2.4.1",
"lodash.templatesettings": "~2.4.1",
"lodash.values": "~2.4.1"
}
},
"lodash.templatesettings": {
"version": "2.4.1",
"resolved": "https://registry.npmjs.org/lodash.templatesettings/-/lodash.templatesettings-2.4.1.tgz",
"integrity": "sha1-6nbHXRHrhtTb6JqDiTu4YZKaxpk=",
"dev": true,
"requires": {
"lodash._reinterpolate": "~2.4.1",
"lodash.escape": "~2.4.1"
}
},
"minimist": {
"version": "0.2.0",
"resolved": "https://registry.npmjs.org/minimist/-/minimist-0.2.0.tgz",
"integrity": "sha1-Tf/lJdriuGTGbC4jxicdev3s784=",
"dev": true
},
"strip-ansi": {
"version": "0.3.0",
"resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-0.3.0.tgz",
"integrity": "sha1-JfSOoiynkYfzF0pNuHWTR7sSYiA=",
"dev": true,
"requires": {
"ansi-regex": "^0.2.1"
}
},
"supports-color": {
"version": "0.2.0",
"resolved": "https://registry.npmjs.org/supports-color/-/supports-color-0.2.0.tgz",
"integrity": "sha1-2S3iaU6z9nMjlz1649i1W0wiGQo=",
"dev": true
},
"through2": {
"version": "0.4.2",
"resolved": "https://registry.npmjs.org/through2/-/through2-0.4.2.tgz",
"integrity": "sha1-2/WGYDEVHsg1K7bE22SiKSqEC5s=",
"dev": true,
"requires": {
"readable-stream": "~1.0.17",
"xtend": "~2.1.1"
},
"dependencies": {
"xtend": {
"version": "2.1.2",
"resolved": "https://registry.npmjs.org/xtend/-/xtend-2.1.2.tgz",
"integrity": "sha1-bv7MKk2tjmlixJAbM3znuoe10os=",
"dev": true,
"requires": {
"object-keys": "~0.4.0"
}
}
}
},
"vinyl": {
"version": "0.2.3",
"resolved": "https://registry.npmjs.org/vinyl/-/vinyl-0.2.3.tgz",
"integrity": "sha1-vKk4IJWC7FpJrVOKAPofEl5RMlI=",
"dev": true,
"requires": {
"clone-stats": "~0.0.1"
}
},
"xtend": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/xtend/-/xtend-3.0.0.tgz",
"integrity": "sha1-XM50B7r2Qsunvs2laBEcST9ZZlo=",
"dev": true
}
}
},
"gulp-util": {
"version": "3.0.8",
"resolved": "https://registry.npmjs.org/gulp-util/-/gulp-util-3.0.8.tgz",
"integrity": "sha1-AFTh50RQLifATBh8PsxQXdVLu08=",
"dev": true,
"requires": {
"array-differ": "^1.0.0",
"array-uniq": "^1.0.2",
"beeper": "^1.0.0",
"chalk": "^1.0.0",
"dateformat": "^2.0.0",
"fancy-log": "^1.1.0",
"gulplog": "^1.0.0",
"has-gulplog": "^0.1.0",
"lodash._reescape": "^3.0.0",
"lodash._reevaluate": "^3.0.0",
"lodash._reinterpolate": "^3.0.0",
"lodash.template": "^3.0.0",
"minimist": "^1.1.0",
"multipipe": "^0.1.2",
"object-assign": "^3.0.0",
"replace-ext": "0.0.1",
"through2": "^2.0.0",
"vinyl": "^0.5.0"
},
"dependencies": {
"dateformat": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/dateformat/-/dateformat-2.0.0.tgz",
"integrity": "sha1-J0Pjq7XD/CRi5SfcpEXgTp9N7hc=",
"dev": true
},
"object-assign": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/object-assign/-/object-assign-3.0.0.tgz",
"integrity": "sha1-m+3VygiXlJvKR+f/QIBi1Un1h/I=",
"dev": true
}
}
},
"gulplog": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/gulplog/-/gulplog-1.0.0.tgz",
"integrity": "sha1-4oxNRdBey77YGDY86PnFkmIp/+U=",
"dev": true,
"requires": {
"glogg": "^1.0.0"
}
},
"handlebars": {
"version": "4.0.10",
"resolved": "https://registry.npmjs.org/handlebars/-/handlebars-4.0.10.tgz",
"integrity": "sha1-PTDHGLCaPZbyPqTMH0A8TTup/08=",
"dev": true,
"requires": {
"async": "^1.4.0",
"optimist": "^0.6.1",
"source-map": "^0.4.4",
"uglify-js": "^2.6"
},
"dependencies": {
"async": {
"version": "1.5.2",
"resolved": "https://registry.npmjs.org/async/-/async-1.5.2.tgz",
"integrity": "sha1-7GphrlZIDAw8skHJVhjiCJL5Zyo=",
"dev": true
},
"source-map": {
"version": "0.4.4",
"resolved": "https://registry.npmjs.org/source-map/-/source-map-0.4.4.tgz",
"integrity": "sha1-66T12pwNyZneaAMti092FzZSA2s=",
"dev": true,
"requires": {
"amdefine": ">=0.0.4"
}
}
}
},
"has-ansi": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/has-ansi/-/has-ansi-2.0.0.tgz",
"integrity": "sha1-NPUEnOHs3ysGSa8+8k5F7TVBbZE=",
"dev": true,
"requires": {
"ansi-regex": "^2.0.0"
}
},
"has-color": {
"version": "0.1.7",
"resolved": "https://registry.npmjs.org/has-color/-/has-color-0.1.7.tgz",
"integrity": "sha1-ZxRKUmDDT8PMpnfQQdr1L+e3iy8=",
"dev": true
},
"has-flag": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/has-flag/-/has-flag-1.0.0.tgz",
"integrity": "sha1-nZ55MWXOAXoA8AQYxD+UKnsdEfo=",
"dev": true
},
"has-gulplog": {
"version": "0.1.0",
"resolved": "https://registry.npmjs.org/has-gulplog/-/has-gulplog-0.1.0.tgz",
"integrity": "sha1-ZBTIKRNpfaUVkDl9r7EvIpZ4Ec4=",
"dev": true,
"requires": {
"sparkles": "^1.0.0"
}
},
"has-value": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/has-value/-/has-value-1.0.0.tgz",
"integrity": "sha1-GLKB2lhbHFxR3vJMkw7SmgvmsXc=",
"dev": true,
"requires": {
"get-value": "^2.0.6",
"has-values": "^1.0.0",
"isobject": "^3.0.0"
},
"dependencies": {
"isobject": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz",
"integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=",
"dev": true
}
}
},
"has-values": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/has-values/-/has-values-1.0.0.tgz",
"integrity": "sha1-lbC2P+whRmGab+V/51Yo1aOe/k8=",
"dev": true,
"requires": {
"is-number": "^3.0.0",
"kind-of": "^4.0.0"
},
"dependencies": {
"is-number": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz",
"integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=",
"dev": true,
"requires": {
"kind-of": "^3.0.2"
},
"dependencies": {
"kind-of": {
"version": "3.2.2",
"resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz",
"integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
"dev": true,
"requires": {
"is-buffer": "^1.1.5"
}
}
}
},
"kind-of": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/kind-of/-/kind-of-4.0.0.tgz",
"integrity": "sha1-IIE989cSkosgc3hpGkUGb65y3Vc=",
"dev": true,
"requires": {
"is-buffer": "^1.1.5"
}
}
}
},
"hawk": {
"version": "1.1.1",
"resolved": "https://registry.npmjs.org/hawk/-/hawk-1.1.1.tgz",
"integrity": "sha1-h81JH5tG5OKurKM1QWdmiF0tHtk=",
"dev": true,
"optional": true,
"requires": {
"boom": "0.4.x",
"cryptiles": "0.2.x",
"hoek": "0.9.x",
"sntp": "0.2.x"
}
},
"he": {
"version": "1.1.1",
"resolved": "https://registry.npmjs.org/he/-/he-1.1.1.tgz",
"integrity": "sha1-k0EP0hsAlzUVH4howvJx80J+I/0=",
"dev": true
},
"hoek": {
"version": "0.9.1",
"resolved": "https://registry.npmjs.org/hoek/-/hoek-0.9.1.tgz",
"integrity": "sha1-PTIkYrrfB3Fup+uFuviAec3c5QU=",
"dev": true,
"optional": true
},
"homedir-polyfill": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/homedir-polyfill/-/homedir-polyfill-1.0.1.tgz",
"integrity": "sha1-TCu8inWJmP7r9e1oWA921GdotLw=",
"dev": true,
"requires": {
"parse-passwd": "^1.0.0"
}
},
"hosted-git-info": {
"version": "2.5.0",
"resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.5.0.tgz",
"integrity": "sha512-pNgbURSuab90KbTqvRPsseaTxOJCZBD0a7t+haSN33piP9cCM4l0CqdzAif2hUqm716UovKB2ROmiabGAKVXyg==",
"dev": true
},
"htmlparser2": {
"version": "3.8.3",
"resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-3.8.3.tgz",
"integrity": "sha1-mWwosZFRaovoZQGn15dX5ccMEGg=",
"dev": true,
"requires": {
"domelementtype": "1",
"domhandler": "2.3",
"domutils": "1.5",
"entities": "1.0",
"readable-stream": "1.1"
},
"dependencies": {
"readable-stream": {
"version": "1.1.14",
"resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz",
"integrity": "sha1-fPTFTvZI44EwhMY23SB54WbAgdk=",
"dev": true,
"requires": {
"core-util-is": "~1.0.0",
"inherits": "~2.0.1",
"isarray": "0.0.1",
"string_decoder": "~0.10.x"
}
}
}
},
"http-signature": {
"version": "0.10.1",
"resolved": "https://registry.npmjs.org/http-signature/-/http-signature-0.10.1.tgz",
"integrity": "sha1-T72sEyVZqoMjEh5UB3nAoBKyfmY=",
"dev": true,
"optional": true,
"requires": {
"asn1": "0.1.11",
"assert-plus": "^0.1.5",
"ctype": "0.5.3"
}
},
"husky": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/husky/-/husky-1.2.0.tgz",
"integrity": "sha512-/ib3+iycykXC0tYIxsyqierikVa9DA2DrT32UEirqNEFVqOj1bFMTgP3jAz8HM7FgC/C8pc/BTUa9MV2GEkZaA==",
"dev": true,
"requires": {
"cosmiconfig": "^5.0.6",
"execa": "^1.0.0",
"find-up": "^3.0.0",
"get-stdin": "^6.0.0",
"is-ci": "^1.2.1",
"pkg-dir": "^3.0.0",
"please-upgrade-node": "^3.1.1",
"read-pkg": "^4.0.1",
"run-node": "^1.0.0",
"slash": "^2.0.0"
},
"dependencies": {
"cross-spawn": {
"version": "6.0.5",
"resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-6.0.5.tgz",
"integrity": "sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ==",
"dev": true,
"requires": {
"nice-try": "^1.0.4",
"path-key": "^2.0.1",
"semver": "^5.5.0",
"shebang-command": "^1.2.0",
"which": "^1.2.9"
}
},
"execa": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/execa/-/execa-1.0.0.tgz",
"integrity": "sha512-adbxcyWV46qiHyvSp50TKt05tB4tK3HcmF7/nxfAdhnox83seTDbwnaqKO4sXRy7roHAIFqJP/Rw/AuEbX61LA==",
"dev": true,
"requires": {
"cross-spawn": "^6.0.0",
"get-stream": "^4.0.0",
"is-stream": "^1.1.0",
"npm-run-path": "^2.0.0",
"p-finally": "^1.0.0",
"signal-exit": "^3.0.0",
"strip-eof": "^1.0.0"
}
},
"find-up": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/find-up/-/find-up-3.0.0.tgz",
"integrity": "sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==",
"dev": true,
"requires": {
"locate-path": "^3.0.0"
}
},
"get-stdin": {
"version": "6.0.0",
"resolved": "https://registry.npmjs.org/get-stdin/-/get-stdin-6.0.0.tgz",
"integrity": "sha512-jp4tHawyV7+fkkSKyvjuLZswblUtz+SQKzSWnBbii16BuZksJlU1wuBYXY75r+duh/llF1ur6oNwi+2ZzjKZ7g==",
"dev": true
},
"get-stream": {
"version": "4.1.0",
"resolved": "https://registry.npmjs.org/get-stream/-/get-stream-4.1.0.tgz",
"integrity": "sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w==",
"dev": true,
"requires": {
"pump": "^3.0.0"
}
},
"parse-json": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/parse-json/-/parse-json-4.0.0.tgz",
"integrity": "sha1-vjX1Qlvh9/bHRxhPmKeIy5lHfuA=",
"dev": true,
"requires": {
"error-ex": "^1.3.1",
"json-parse-better-errors": "^1.0.1"
}
},
"pify": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz",
"integrity": "sha1-5aSs0sEB/fPZpNB/DbxNtJ3SgXY=",
"dev": true
},
"read-pkg": {
"version": "4.0.1",
"resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-4.0.1.tgz",
"integrity": "sha1-ljYlN48+HE1IyFhytabsfV0JMjc=",
"dev": true,
"requires": {
"normalize-package-data": "^2.3.2",
"parse-json": "^4.0.0",
"pify": "^3.0.0"
}
},
"semver": {
"version": "5.6.0",
"resolved": "https://registry.npmjs.org/semver/-/semver-5.6.0.tgz",
"integrity": "sha512-RS9R6R35NYgQn++fkDWaOmqGoj4Ek9gGs+DPxNUZKuwE183xjJroKvyo1IzVFeXvUrvmALy6FWD5xrdJT25gMg==",
"dev": true
}
}
},
"i": {
"version": "0.3.5",
"resolved": "https://registry.npmjs.org/i/-/i-0.3.5.tgz",
"integrity": "sha1-HSuFQVjsgWkRPGy39raAHpniEdU=",
"dev": true
},
"import-fresh": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-2.0.0.tgz",
"integrity": "sha1-2BNVwVYS04bGH53dOSLUMEgipUY=",
"dev": true,
"requires": {
"caller-path": "^2.0.0",
"resolve-from": "^3.0.0"
}
},
"indent-string": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/indent-string/-/indent-string-2.1.0.tgz",
"integrity": "sha1-ji1INIdCEhtKghi3oTfppSBJ3IA=",
"dev": true,
"requires": {
"repeating": "^2.0.0"
}
},
"inflight": {
"version": "1.0.6",
"resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
"integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
"dev": true,
"requires": {
"once": "^1.3.0",
"wrappy": "1"
}
},
"inherit": {
"version": "2.2.6",
"resolved": "https://registry.npmjs.org/inherit/-/inherit-2.2.6.tgz",
"integrity": "sha1-8WFLBshUToEo5CKchjR9tzrZeI0=",
"dev": true
},
"inherits": {
"version": "2.0.3",
"resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
"integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=",
"dev": true
},
"ini": {
"version": "1.3.4",
"resolved": "https://registry.npmjs.org/ini/-/ini-1.3.4.tgz",
"integrity": "sha1-BTfLedr1m1mhpRff9wbIbsA5Fi4=",
"dev": true
},
"interpret": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/interpret/-/interpret-1.0.3.tgz",
"integrity": "sha1-y8NcYu7uc/Gat7EKgBURQBr8D5A=",
"dev": true
},
"is-absolute": {
"version": "0.2.6",
"resolved": "https://registry.npmjs.org/is-absolute/-/is-absolute-0.2.6.tgz",
"integrity": "sha1-IN5p89uULvLYe5wto28XIjWxtes=",
"dev": true,
"requires": {
"is-relative": "^0.2.1",
"is-windows": "^0.2.0"
}
},
"is-accessor-descriptor": {
"version": "0.1.6",
"resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz",
"integrity": "sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=",
"dev": true,
"requires": {
"kind-of": "^3.0.2"
}
},
"is-arrayish": {
"version": "0.2.1",
"resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz",
"integrity": "sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=",
"dev": true
},
"is-buffer": {
"version": "1.1.5",
"resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.5.tgz",
"integrity": "sha1-Hzsm72E7IUuIy8ojzGwB2Hlh7sw=",
"dev": true
},
"is-builtin-module": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/is-builtin-module/-/is-builtin-module-1.0.0.tgz",
"integrity": "sha1-VAVy0096wxGfj3bDDLwbHgN6/74=",
"dev": true,
"requires": {
"builtin-modules": "^1.0.0"
}
},
"is-ci": {
"version": "1.2.1",
"resolved": "https://registry.npmjs.org/is-ci/-/is-ci-1.2.1.tgz",
"integrity": "sha512-s6tfsaQaQi3JNciBH6shVqEDvhGut0SUXr31ag8Pd8BBbVVlcGfWhpPmEOoM6RJ5TFhbypvf5yyRw/VXW1IiWg==",
"dev": true,
"requires": {
"ci-info": "^1.5.0"
}
},
"is-data-descriptor": {
"version": "0.1.4",
"resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz",
"integrity": "sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=",
"dev": true,
"requires": {
"kind-of": "^3.0.2"
}
},
"is-descriptor": {
"version": "0.1.6",
"resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-0.1.6.tgz",
"integrity": "sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==",
"dev": true,
"requires": {
"is-accessor-descriptor": "^0.1.6",
"is-data-descriptor": "^0.1.4",
"kind-of": "^5.0.0"
},
"dependencies": {
"kind-of": {
"version": "5.1.0",
"resolved": "https://registry.npmjs.org/kind-of/-/kind-of-5.1.0.tgz",
"integrity": "sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==",
"dev": true
}
}
},
"is-directory": {
"version": "0.3.1",
"resolved": "https://registry.npmjs.org/is-directory/-/is-directory-0.3.1.tgz",
"integrity": "sha1-YTObbyR1/Hcv2cnYP1yFddwVSuE=",
"dev": true
},
"is-dotfile": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/is-dotfile/-/is-dotfile-1.0.3.tgz",
"integrity": "sha1-pqLzL/0t+wT1yiXs0Pa4PPeYoeE=",
"dev": true
},
"is-equal-shallow": {
"version": "0.1.3",
"resolved": "https://registry.npmjs.org/is-equal-shallow/-/is-equal-shallow-0.1.3.tgz",
"integrity": "sha1-IjgJj8Ih3gvPpdnqxMRdY4qhxTQ=",
"dev": true,
"requires": {
"is-primitive": "^2.0.0"
}
},
"is-extendable": {
"version": "0.1.1",
"resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz",
"integrity": "sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=",
"dev": true
},
"is-extglob": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-1.0.0.tgz",
"integrity": "sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=",
"dev": true
},
"is-finite": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/is-finite/-/is-finite-1.0.2.tgz",
"integrity": "sha1-zGZ3aVYCvlUO8R6LSqYwU0K20Ko=",
"dev": true,
"requires": {
"number-is-nan": "^1.0.0"
}
},
"is-fullwidth-code-point": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz",
"integrity": "sha1-754xOG8DGn8NZDr4L95QxFfvAMs=",
"dev": true,
"requires": {
"number-is-nan": "^1.0.0"
}
},
"is-glob": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/is-glob/-/is-glob-2.0.1.tgz",
"integrity": "sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=",
"dev": true,
"requires": {
"is-extglob": "^1.0.0"
}
},
"is-number": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/is-number/-/is-number-2.1.0.tgz",
"integrity": "sha1-Afy7s5NGOlSPL0ZszhbezknbkI8=",
"dev": true,
"requires": {
"kind-of": "^3.0.2"
}
},
"is-obj": {
"version": "1.0.1",
"resolved": "http://registry.npmjs.org/is-obj/-/is-obj-1.0.1.tgz",
"integrity": "sha1-PkcprB9f3gJc19g6iW2rn09n2w8=",
"dev": true
},
"is-observable": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/is-observable/-/is-observable-1.1.0.tgz",
"integrity": "sha512-NqCa4Sa2d+u7BWc6CukaObG3Fh+CU9bvixbpcXYhy2VvYS7vVGIdAgnIS5Ks3A/cqk4rebLJ9s8zBstT2aKnIA==",
"dev": true,
"requires": {
"symbol-observable": "^1.1.0"
}
},
"is-path-cwd": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/is-path-cwd/-/is-path-cwd-1.0.0.tgz",
"integrity": "sha1-0iXsIxMuie3Tj9p2dHLmLmXxEG0=",
"dev": true
},
"is-path-in-cwd": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/is-path-in-cwd/-/is-path-in-cwd-1.0.1.tgz",
"integrity": "sha512-FjV1RTW48E7CWM7eE/J2NJvAEEVektecDBVBE5Hh3nM1Jd0kvhHtX68Pr3xsDf857xt3Y4AkwVULK1Vku62aaQ==",
"dev": true,
"requires": {
"is-path-inside": "^1.0.0"
}
},
"is-path-inside": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-1.0.1.tgz",
"integrity": "sha1-jvW33lBDej/cprToZe96pVy0gDY=",
"dev": true,
"requires": {
"path-is-inside": "^1.0.1"
}
},
"is-plain-object": {
"version": "2.0.4",
"resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz",
"integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==",
"dev": true,
"requires": {
"isobject": "^3.0.1"
},
"dependencies": {
"isobject": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz",
"integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=",
"dev": true
}
}
},
"is-posix-bracket": {
"version": "0.1.1",
"resolved": "https://registry.npmjs.org/is-posix-bracket/-/is-posix-bracket-0.1.1.tgz",
"integrity": "sha1-MzTceXdDaOkvAW5vvAqI9c1ua8Q=",
"dev": true
},
"is-primitive": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/is-primitive/-/is-primitive-2.0.0.tgz",
"integrity": "sha1-IHurkWOEmcB7Kt8kCkGochADRXU=",
"dev": true
},
"is-promise": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/is-promise/-/is-promise-2.1.0.tgz",
"integrity": "sha1-eaKp7OfwlugPNtKy87wWwf9L8/o=",
"dev": true
},
"is-regexp": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/is-regexp/-/is-regexp-1.0.0.tgz",
"integrity": "sha1-/S2INUXEa6xaYz57mgnof6LLUGk=",
"dev": true
},
"is-relative": {
"version": "0.2.1",
"resolved": "https://registry.npmjs.org/is-relative/-/is-relative-0.2.1.tgz",
"integrity": "sha1-0n9MfVFtF1+2ENuEu+7yPDvJeqU=",
"dev": true,
"requires": {
"is-unc-path": "^0.1.1"
}
},
"is-stream": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/is-stream/-/is-stream-1.1.0.tgz",
"integrity": "sha1-EtSj3U5o4Lec6428hBc66A2RykQ=",
"dev": true
},
"is-unc-path": {
"version": "0.1.2",
"resolved": "https://registry.npmjs.org/is-unc-path/-/is-unc-path-0.1.2.tgz",
"integrity": "sha1-arBTpyVzwQJQ/0FqOBTDUXivObk=",
"dev": true,
"requires": {
"unc-path-regex": "^0.1.0"
}
},
"is-utf8": {
"version": "0.2.1",
"resolved": "https://registry.npmjs.org/is-utf8/-/is-utf8-0.2.1.tgz",
"integrity": "sha1-Sw2hRCEE0bM2NA6AeX6GXPOffXI=",
"dev": true
},
"is-windows": {
"version": "0.2.0",
"resolved": "https://registry.npmjs.org/is-windows/-/is-windows-0.2.0.tgz",
"integrity": "sha1-3hqm1j6indJIc3tp8f+LgALSEIw=",
"dev": true
},
"isarray": {
"version": "0.0.1",
"resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz",
"integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=",
"dev": true
},
"isexe": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
"integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=",
"dev": true
},
"isobject": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/isobject/-/isobject-2.1.0.tgz",
"integrity": "sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=",
"dev": true,
"requires": {
"isarray": "1.0.0"
},
"dependencies": {
"isarray": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
"integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=",
"dev": true
}
}
},
"isstream": {
"version": "0.1.2",
"resolved": "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz",
"integrity": "sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo=",
"dev": true
},
"istanbul": {
"version": "0.4.5",
"resolved": "https://registry.npmjs.org/istanbul/-/istanbul-0.4.5.tgz",
"integrity": "sha1-ZcfXPUxNqE1POsMQuRj7C4Azczs=",
"dev": true,
"requires": {
"abbrev": "1.0.x",
"async": "1.x",
"escodegen": "1.8.x",
"esprima": "2.7.x",
"glob": "^5.0.15",
"handlebars": "^4.0.1",
"js-yaml": "3.x",
"mkdirp": "0.5.x",
"nopt": "3.x",
"once": "1.x",
"resolve": "1.1.x",
"supports-color": "^3.1.0",
"which": "^1.1.1",
"wordwrap": "^1.0.0"
},
"dependencies": {
"abbrev": {
"version": "1.0.9",
"resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.0.9.tgz",
"integrity": "sha1-kbR5JYinc4wl813W9jdSovh3YTU=",
"dev": true
},
"async": {
"version": "1.5.2",
"resolved": "https://registry.npmjs.org/async/-/async-1.5.2.tgz",
"integrity": "sha1-7GphrlZIDAw8skHJVhjiCJL5Zyo=",
"dev": true
},
"glob": {
"version": "5.0.15",
"resolved": "https://registry.npmjs.org/glob/-/glob-5.0.15.tgz",
"integrity": "sha1-G8k2ueAvSmA/zCIuz3Yz0wuLk7E=",
"dev": true,
"requires": {
"inflight": "^1.0.4",
"inherits": "2",
"minimatch": "2 || 3",
"once": "^1.3.0",
"path-is-absolute": "^1.0.0"
}
},
"resolve": {
"version": "1.1.7",
"resolved": "https://registry.npmjs.org/resolve/-/resolve-1.1.7.tgz",
"integrity": "sha1-IDEU2CrSxe2ejgQRs5ModeiJ6Xs=",
"dev": true
},
"supports-color": {
"version": "3.2.3",
"resolved": "https://registry.npmjs.org/supports-color/-/supports-color-3.2.3.tgz",
"integrity": "sha1-ZawFBLOVQXHYpklGsq48u4pfVPY=",
"dev": true,
"requires": {
"has-flag": "^1.0.0"
}
}
}
},
"jest-get-type": {
"version": "22.4.3",
"resolved": "http://registry.npmjs.org/jest-get-type/-/jest-get-type-22.4.3.tgz",
"integrity": "sha512-/jsz0Y+V29w1chdXVygEKSz2nBoHoYqNShPe+QgxSNjAuP1i8+k4LbQNrfoliKej0P45sivkSCh7yiD6ubHS3w==",
"dev": true
},
"jest-validate": {
"version": "23.6.0",
"resolved": "https://registry.npmjs.org/jest-validate/-/jest-validate-23.6.0.tgz",
"integrity": "sha512-OFKapYxe72yz7agrDAWi8v2WL8GIfVqcbKRCLbRG9PAxtzF9b1SEDdTpytNDN12z2fJynoBwpMpvj2R39plI2A==",
"dev": true,
"requires": {
"chalk": "^2.0.1",
"jest-get-type": "^22.1.0",
"leven": "^2.1.0",
"pretty-format": "^23.6.0"
},
"dependencies": {
"ansi-styles": {
"version": "3.2.1",
"resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
"integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
"dev": true,
"requires": {
"color-convert": "^1.9.0"
}
},
"chalk": {
"version": "2.4.1",
"resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz",
"integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==",
"dev": true,
"requires": {
"ansi-styles": "^3.2.1",
"escape-string-regexp": "^1.0.5",
"supports-color": "^5.3.0"
}
},
"has-flag": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
"integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=",
"dev": true
},
"supports-color": {
"version": "5.5.0",
"resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
"integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
"dev": true,
"requires": {
"has-flag": "^3.0.0"
}
}
}
},
"js-yaml": {
"version": "3.4.6",
"resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.4.6.tgz",
"integrity": "sha1-a+GyP2JJ9T0pM3D9TRqqY84bTrA=",
"dev": true,
"requires": {
"argparse": "^1.0.2",
"esprima": "^2.6.0",
"inherit": "^2.2.2"
}
},
"js2xmlparser": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/js2xmlparser/-/js2xmlparser-3.0.0.tgz",
"integrity": "sha1-P7YOqgicVED5MZ9RdgzNB+JJlzM=",
"dev": true,
"requires": {
"xmlcreate": "^1.0.1"
}
},
"jscs": {
"version": "3.0.7",
"resolved": "https://registry.npmjs.org/jscs/-/jscs-3.0.7.tgz",
"integrity": "sha1-cUG03/W4bjLQ6Z12S4NnZ8MNIBo=",
"dev": true,
"requires": {
"chalk": "~1.1.0",
"cli-table": "~0.3.1",
"commander": "~2.9.0",
"cst": "^0.4.3",
"estraverse": "^4.1.0",
"exit": "~0.1.2",
"glob": "^5.0.1",
"htmlparser2": "3.8.3",
"js-yaml": "~3.4.0",
"jscs-jsdoc": "^2.0.0",
"jscs-preset-wikimedia": "~1.0.0",
"jsonlint": "~1.6.2",
"lodash": "~3.10.0",
"minimatch": "~3.0.0",
"natural-compare": "~1.2.2",
"pathval": "~0.1.1",
"prompt": "~0.2.14",
"reserved-words": "^0.1.1",
"resolve": "^1.1.6",
"strip-bom": "^2.0.0",
"strip-json-comments": "~1.0.2",
"to-double-quotes": "^2.0.0",
"to-single-quotes": "^2.0.0",
"vow": "~0.4.8",
"vow-fs": "~0.3.4",
"xmlbuilder": "^3.1.0"
},
"dependencies": {
"glob": {
"version": "5.0.15",
"resolved": "https://registry.npmjs.org/glob/-/glob-5.0.15.tgz",
"integrity": "sha1-G8k2ueAvSmA/zCIuz3Yz0wuLk7E=",
"dev": true,
"requires": {
"inflight": "^1.0.4",
"inherits": "2",
"minimatch": "2 || 3",
"once": "^1.3.0",
"path-is-absolute": "^1.0.0"
}
},
"lodash": {
"version": "3.10.1",
"resolved": "https://registry.npmjs.org/lodash/-/lodash-3.10.1.tgz",
"integrity": "sha1-W/Rejkm6QYnhfUgnid/RW9FAt7Y=",
"dev": true
},
"minimatch": {
"version": "3.0.4",
"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
"integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
"dev": true,
"requires": {
"brace-expansion": "^1.1.7"
}
},
"strip-json-comments": {
"version": "1.0.4",
"resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-1.0.4.tgz",
"integrity": "sha1-HhX7ysl9Pumb8tc7TGVrCCu6+5E=",
"dev": true
}
}
},
"jscs-jsdoc": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/jscs-jsdoc/-/jscs-jsdoc-2.0.0.tgz",
"integrity": "sha1-9T684CmqMSW9iCkLpQ1k1FEKSHE=",
"dev": true,
"requires": {
"comment-parser": "^0.3.1",
"jsdoctypeparser": "~1.2.0"
}
},
"jscs-preset-wikimedia": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/jscs-preset-wikimedia/-/jscs-preset-wikimedia-1.0.0.tgz",
"integrity": "sha1-//VjNCA4/C6IJre7cwnDrjQG/H4=",
"dev": true
},
"jsdoc": {
"version": "3.5.5",
"resolved": "https://registry.npmjs.org/jsdoc/-/jsdoc-3.5.5.tgz",
"integrity": "sha512-6PxB65TAU4WO0Wzyr/4/YhlGovXl0EVYfpKbpSroSj0qBxT4/xod/l40Opkm38dRHRdQgdeY836M0uVnJQG7kg==",
"dev": true,
"requires": {
"babylon": "7.0.0-beta.19",
"bluebird": "~3.5.0",
"catharsis": "~0.8.9",
"escape-string-regexp": "~1.0.5",
"js2xmlparser": "~3.0.0",
"klaw": "~2.0.0",
"marked": "~0.3.6",
"mkdirp": "~0.5.1",
"requizzle": "~0.2.1",
"strip-json-comments": "~2.0.1",
"taffydb": "2.6.2",
"underscore": "~1.8.3"
},
"dependencies": {
"babylon": {
"version": "7.0.0-beta.19",
"resolved": "https://registry.npmjs.org/babylon/-/babylon-7.0.0-beta.19.tgz",
"integrity": "sha512-Vg0C9s/REX6/WIXN37UKpv5ZhRi6A4pjHlpkE34+8/a6c2W1Q692n3hmc+SZG5lKRnaExLUbxtJ1SVT+KaCQ/A==",
"dev": true
},
"underscore": {
"version": "1.8.3",
"resolved": "https://registry.npmjs.org/underscore/-/underscore-1.8.3.tgz",
"integrity": "sha1-Tz+1OxBuYJf8+ctBCfKl6b36UCI=",
"dev": true
}
}
},
"jsdoctypeparser": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/jsdoctypeparser/-/jsdoctypeparser-1.2.0.tgz",
"integrity": "sha1-597cFToRhJ/8UUEUSuhqfvDCU5I=",
"dev": true,
"requires": {
"lodash": "^3.7.0"
},
"dependencies": {
"lodash": {
"version": "3.10.1",
"resolved": "https://registry.npmjs.org/lodash/-/lodash-3.10.1.tgz",
"integrity": "sha1-W/Rejkm6QYnhfUgnid/RW9FAt7Y=",
"dev": true
}
}
},
"jshint": {
"version": "2.9.5",
"resolved": "https://registry.npmjs.org/jshint/-/jshint-2.9.5.tgz",
"integrity": "sha1-HnJSkVzmgbQIJ+4UJIxG006apiw=",
"dev": true,
"requires": {
"cli": "~1.0.0",
"console-browserify": "1.1.x",
"exit": "0.1.x",
"htmlparser2": "3.8.x",
"lodash": "3.7.x",
"minimatch": "~3.0.2",
"shelljs": "0.3.x",
"strip-json-comments": "1.0.x"
},
"dependencies": {
"lodash": {
"version": "3.7.0",
"resolved": "https://registry.npmjs.org/lodash/-/lodash-3.7.0.tgz",
"integrity": "sha1-Nni9irmVBXwHreg27S7wh9qBHUU=",
"dev": true
},
"minimatch": {
"version": "3.0.4",
"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
"integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
"dev": true,
"requires": {
"brace-expansion": "^1.1.7"
}
},
"strip-json-comments": {
"version": "1.0.4",
"resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-1.0.4.tgz",
"integrity": "sha1-HhX7ysl9Pumb8tc7TGVrCCu6+5E=",
"dev": true
}
}
},
"json-parse-better-errors": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/json-parse-better-errors/-/json-parse-better-errors-1.0.2.tgz",
"integrity": "sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw==",
"dev": true
},
"json-stringify-safe": {
"version": "5.0.1",
"resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz",
"integrity": "sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=",
"dev": true
},
"json3": {
"version": "3.3.2",
"resolved": "https://registry.npmjs.org/json3/-/json3-3.3.2.tgz",
"integrity": "sha1-PAQ0dD35Pi9cQq7nsZvLSDV19OE=",
"dev": true
},
"jsonfile": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz",
"integrity": "sha1-h3Gq4HmbZAdrdmQPygWPnBDjPss=",
"dev": true,
"requires": {
"graceful-fs": "^4.1.6"
}
},
"jsonify": {
"version": "0.0.0",
"resolved": "https://registry.npmjs.org/jsonify/-/jsonify-0.0.0.tgz",
"integrity": "sha1-LHS27kHZPKUbe1qu6PUDYx0lKnM=",
"dev": true
},
"jsonlint": {
"version": "1.6.2",
"resolved": "https://registry.npmjs.org/jsonlint/-/jsonlint-1.6.2.tgz",
"integrity": "sha1-VzcEUIX1XrRVxosf9OvAG9UOiDA=",
"dev": true,
"requires": {
"JSV": ">= 4.0.x",
"nomnom": ">= 1.5.x"
}
},
"kind-of": {
"version": "3.2.2",
"resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz",
"integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
"dev": true,
"requires": {
"is-buffer": "^1.1.5"
}
},
"klaw": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/klaw/-/klaw-2.0.0.tgz",
"integrity": "sha1-WcEo4Nxc5BAgEVEZTuucv4WGUPY=",
"dev": true,
"requires": {
"graceful-fs": "^4.1.9"
}
},
"lazy-cache": {
"version": "1.0.4",
"resolved": "https://registry.npmjs.org/lazy-cache/-/lazy-cache-1.0.4.tgz",
"integrity": "sha1-odePw6UEdMuAhF07O24dpJpEbo4=",
"dev": true,
"optional": true
},
"leven": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/leven/-/leven-2.1.0.tgz",
"integrity": "sha1-wuep93IJTe6dNCAq6KzORoeHVYA=",
"dev": true
},
"levn": {
"version": "0.3.0",
"resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz",
"integrity": "sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4=",
"dev": true,
"requires": {
"prelude-ls": "~1.1.2",
"type-check": "~0.3.2"
}
},
"liftoff": {
"version": "2.3.0",
"resolved": "https://registry.npmjs.org/liftoff/-/liftoff-2.3.0.tgz",
"integrity": "sha1-qY8v9nGD2Lp8+soQVIvX/wVQs4U=",
"dev": true,
"requires": {
"extend": "^3.0.0",
"findup-sync": "^0.4.2",
"fined": "^1.0.1",
"flagged-respawn": "^0.3.2",
"lodash.isplainobject": "^4.0.4",
"lodash.isstring": "^4.0.1",
"lodash.mapvalues": "^4.4.0",
"rechoir": "^0.6.2",
"resolve": "^1.1.7"
}
},
"lint-staged": {
"version": "8.1.0",
"resolved": "https://registry.npmjs.org/lint-staged/-/lint-staged-8.1.0.tgz",
"integrity": "sha512-yfSkyJy7EuVsaoxtUSEhrD81spdJOe/gMTGea3XaV7HyoRhTb9Gdlp6/JppRZERvKSEYXP9bjcmq6CA5oL2lYQ==",
"dev": true,
"requires": {
"@iamstarkov/listr-update-renderer": "0.4.1",
"chalk": "^2.3.1",
"commander": "^2.14.1",
"cosmiconfig": "5.0.6",
"debug": "^3.1.0",
"dedent": "^0.7.0",
"del": "^3.0.0",
"execa": "^1.0.0",
"find-parent-dir": "^0.3.0",
"g-status": "^2.0.2",
"is-glob": "^4.0.0",
"is-windows": "^1.0.2",
"jest-validate": "^23.5.0",
"listr": "^0.14.2",
"lodash": "^4.17.5",
"log-symbols": "^2.2.0",
"micromatch": "^3.1.8",
"npm-which": "^3.0.1",
"p-map": "^1.1.1",
"path-is-inside": "^1.0.2",
"pify": "^3.0.0",
"please-upgrade-node": "^3.0.2",
"staged-git-files": "1.1.2",
"string-argv": "^0.0.2",
"stringify-object": "^3.2.2"
},
"dependencies": {
"ansi-styles": {
"version": "3.2.1",
"resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
"integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
"dev": true,
"requires": {
"color-convert": "^1.9.0"
}
},
"arr-diff": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-4.0.0.tgz",
"integrity": "sha1-1kYQdP6/7HHn4VI1dhoyml3HxSA=",
"dev": true
},
"arr-flatten": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/arr-flatten/-/arr-flatten-1.1.0.tgz",
"integrity": "sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg==",
"dev": true
},
"array-unique": {
"version": "0.3.2",
"resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.3.2.tgz",
"integrity": "sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg=",
"dev": true
},
"braces": {
"version": "2.3.2",
"resolved": "https://registry.npmjs.org/braces/-/braces-2.3.2.tgz",
"integrity": "sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==",
"dev": true,
"requires": {
"arr-flatten": "^1.1.0",
"array-unique": "^0.3.2",
"extend-shallow": "^2.0.1",
"fill-range": "^4.0.0",
"isobject": "^3.0.1",
"repeat-element": "^1.1.2",
"snapdragon": "^0.8.1",
"snapdragon-node": "^2.0.1",
"split-string": "^3.0.2",
"to-regex": "^3.0.1"
},
"dependencies": {
"extend-shallow": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
"integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
"dev": true,
"requires": {
"is-extendable": "^0.1.0"
}
}
}
},
"chalk": {
"version": "2.4.1",
"resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz",
"integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==",
"dev": true,
"requires": {
"ansi-styles": "^3.2.1",
"escape-string-regexp": "^1.0.5",
"supports-color": "^5.3.0"
}
},
"commander": {
"version": "2.19.0",
"resolved": "https://registry.npmjs.org/commander/-/commander-2.19.0.tgz",
"integrity": "sha512-6tvAOO+D6OENvRAh524Dh9jcfKTYDQAqvqezbCW82xj5X0pSrcpxtvRKHLG0yBY6SD7PSDrJaj+0AiOcKVd1Xg==",
"dev": true
},
"cosmiconfig": {
"version": "5.0.6",
"resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-5.0.6.tgz",
"integrity": "sha512-6DWfizHriCrFWURP1/qyhsiFvYdlJzbCzmtFWh744+KyWsJo5+kPzUZZaMRSSItoYc0pxFX7gEO7ZC1/gN/7AQ==",
"dev": true,
"requires": {
"is-directory": "^0.3.1",
"js-yaml": "^3.9.0",
"parse-json": "^4.0.0"
}
},
"cross-spawn": {
"version": "6.0.5",
"resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-6.0.5.tgz",
"integrity": "sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ==",
"dev": true,
"requires": {
"nice-try": "^1.0.4",
"path-key": "^2.0.1",
"semver": "^5.5.0",
"shebang-command": "^1.2.0",
"which": "^1.2.9"
}
},
"debug": {
"version": "3.2.6",
"resolved": "https://registry.npmjs.org/debug/-/debug-3.2.6.tgz",
"integrity": "sha512-mel+jf7nrtEl5Pn1Qx46zARXKDpBbvzezse7p7LqINmdoIk8PYP5SySaxEmYv6TZ0JyEKA1hsCId6DIhgITtWQ==",
"dev": true,
"requires": {
"ms": "^2.1.1"
}
},
"esprima": {
"version": "4.0.1",
"resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
"integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
"dev": true
},
"execa": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/execa/-/execa-1.0.0.tgz",
"integrity": "sha512-adbxcyWV46qiHyvSp50TKt05tB4tK3HcmF7/nxfAdhnox83seTDbwnaqKO4sXRy7roHAIFqJP/Rw/AuEbX61LA==",
"dev": true,
"requires": {
"cross-spawn": "^6.0.0",
"get-stream": "^4.0.0",
"is-stream": "^1.1.0",
"npm-run-path": "^2.0.0",
"p-finally": "^1.0.0",
"signal-exit": "^3.0.0",
"strip-eof": "^1.0.0"
}
},
"expand-brackets": {
"version": "2.1.4",
"resolved": "https://registry.npmjs.org/expand-brackets/-/expand-brackets-2.1.4.tgz",
"integrity": "sha1-t3c14xXOMPa27/D4OwQVGiJEliI=",
"dev": true,
"requires": {
"debug": "^2.3.3",
"define-property": "^0.2.5",
"extend-shallow": "^2.0.1",
"posix-character-classes": "^0.1.0",
"regex-not": "^1.0.0",
"snapdragon": "^0.8.1",
"to-regex": "^3.0.1"
},
"dependencies": {
"debug": {
"version": "2.6.9",
"resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
"integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
"dev": true,
"requires": {
"ms": "2.0.0"
}
},
"define-property": {
"version": "0.2.5",
"resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz",
"integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=",
"dev": true,
"requires": {
"is-descriptor": "^0.1.0"
}
},
"extend-shallow": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
"integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
"dev": true,
"requires": {
"is-extendable": "^0.1.0"
}
},
"is-accessor-descriptor": {
"version": "0.1.6",
"resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz",
"integrity": "sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=",
"dev": true,
"requires": {
"kind-of": "^3.0.2"
},
"dependencies": {
"kind-of": {
"version": "3.2.2",
"resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz",
"integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
"dev": true,
"requires": {
"is-buffer": "^1.1.5"
}
}
}
},
"is-data-descriptor": {
"version": "0.1.4",
"resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz",
"integrity": "sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=",
"dev": true,
"requires": {
"kind-of": "^3.0.2"
},
"dependencies": {
"kind-of": {
"version": "3.2.2",
"resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz",
"integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
"dev": true,
"requires": {
"is-buffer": "^1.1.5"
}
}
}
},
"is-descriptor": {
"version": "0.1.6",
"resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-0.1.6.tgz",
"integrity": "sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==",
"dev": true,
"requires": {
"is-accessor-descriptor": "^0.1.6",
"is-data-descriptor": "^0.1.4",
"kind-of": "^5.0.0"
}
},
"kind-of": {
"version": "5.1.0",
"resolved": "https://registry.npmjs.org/kind-of/-/kind-of-5.1.0.tgz",
"integrity": "sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==",
"dev": true
},
"ms": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
"integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=",
"dev": true
}
}
},
"extend-shallow": {
"version": "3.0.2",
"resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz",
"integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=",
"dev": true,
"requires": {
"assign-symbols": "^1.0.0",
"is-extendable": "^1.0.1"
},
"dependencies": {
"is-extendable": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz",
"integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==",
"dev": true,
"requires": {
"is-plain-object": "^2.0.4"
}
}
}
},
"extglob": {
"version": "2.0.4",
"resolved": "https://registry.npmjs.org/extglob/-/extglob-2.0.4.tgz",
"integrity": "sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw==",
"dev": true,
"requires": {
"array-unique": "^0.3.2",
"define-property": "^1.0.0",
"expand-brackets": "^2.1.4",
"extend-shallow": "^2.0.1",
"fragment-cache": "^0.2.1",
"regex-not": "^1.0.0",
"snapdragon": "^0.8.1",
"to-regex": "^3.0.1"
},
"dependencies": {
"define-property": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz",
"integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=",
"dev": true,
"requires": {
"is-descriptor": "^1.0.0"
}
},
"extend-shallow": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
"integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
"dev": true,
"requires": {
"is-extendable": "^0.1.0"
}
}
}
},
"fill-range": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/fill-range/-/fill-range-4.0.0.tgz",
"integrity": "sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=",
"dev": true,
"requires": {
"extend-shallow": "^2.0.1",
"is-number": "^3.0.0",
"repeat-string": "^1.6.1",
"to-regex-range": "^2.1.0"
},
"dependencies": {
"extend-shallow": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
"integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
"dev": true,
"requires": {
"is-extendable": "^0.1.0"
}
}
}
},
"get-stream": {
"version": "4.1.0",
"resolved": "https://registry.npmjs.org/get-stream/-/get-stream-4.1.0.tgz",
"integrity": "sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w==",
"dev": true,
"requires": {
"pump": "^3.0.0"
}
},
"has-flag": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
"integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=",
"dev": true
},
"is-accessor-descriptor": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz",
"integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==",
"dev": true,
"requires": {
"kind-of": "^6.0.0"
}
},
"is-data-descriptor": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz",
"integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==",
"dev": true,
"requires": {
"kind-of": "^6.0.0"
}
},
"is-descriptor": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz",
"integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==",
"dev": true,
"requires": {
"is-accessor-descriptor": "^1.0.0",
"is-data-descriptor": "^1.0.0",
"kind-of": "^6.0.2"
}
},
"is-extglob": {
"version": "2.1.1",
"resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
"integrity": "sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=",
"dev": true
},
"is-glob": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.0.tgz",
"integrity": "sha1-lSHHaEXMJhCoUgPd8ICpWML/q8A=",
"dev": true,
"requires": {
"is-extglob": "^2.1.1"
}
},
"is-number": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz",
"integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=",
"dev": true,
"requires": {
"kind-of": "^3.0.2"
},
"dependencies": {
"kind-of": {
"version": "3.2.2",
"resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz",
"integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
"dev": true,
"requires": {
"is-buffer": "^1.1.5"
}
}
}
},
"is-windows": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz",
"integrity": "sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==",
"dev": true
},
"isobject": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz",
"integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=",
"dev": true
},
"js-yaml": {
"version": "3.12.0",
"resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.12.0.tgz",
"integrity": "sha512-PIt2cnwmPfL4hKNwqeiuz4bKfnzHTBv6HyVgjahA6mPLwPDzjDWrplJBMjHUFxku/N3FlmrbyPclad+I+4mJ3A==",
"dev": true,
"requires": {
"argparse": "^1.0.7",
"esprima": "^4.0.0"
}
},
"kind-of": {
"version": "6.0.2",
"resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.2.tgz",
"integrity": "sha512-s5kLOcnH0XqDO+FvuaLX8DDjZ18CGFk7VygH40QoKPUQhW4e2rvM0rwUq0t8IQDOwYSeLK01U90OjzBTme2QqA==",
"dev": true
},
"lodash": {
"version": "4.17.11",
"resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.11.tgz",
"integrity": "sha512-cQKh8igo5QUhZ7lg38DYWAxMvjSAKG0A8wGSVimP07SIUEK2UO+arSRKbRZWtelMtN5V0Hkwh5ryOto/SshYIg==",
"dev": true
},
"micromatch": {
"version": "3.1.10",
"resolved": "https://registry.npmjs.org/micromatch/-/micromatch-3.1.10.tgz",
"integrity": "sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==",
"dev": true,
"requires": {
"arr-diff": "^4.0.0",
"array-unique": "^0.3.2",
"braces": "^2.3.1",
"define-property": "^2.0.2",
"extend-shallow": "^3.0.2",
"extglob": "^2.0.4",
"fragment-cache": "^0.2.1",
"kind-of": "^6.0.2",
"nanomatch": "^1.2.9",
"object.pick": "^1.3.0",
"regex-not": "^1.0.0",
"snapdragon": "^0.8.1",
"to-regex": "^3.0.2"
}
},
"ms": {
"version": "2.1.1",
"resolved": "https://registry.npmjs.org/ms/-/ms-2.1.1.tgz",
"integrity": "sha512-tgp+dl5cGk28utYktBsrFqA7HKgrhgPsg6Z/EfhWI4gl1Hwq8B/GmY/0oXZ6nF8hDVesS/FpnYaD/kOWhYQvyg==",
"dev": true
},
"parse-json": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/parse-json/-/parse-json-4.0.0.tgz",
"integrity": "sha1-vjX1Qlvh9/bHRxhPmKeIy5lHfuA=",
"dev": true,
"requires": {
"error-ex": "^1.3.1",
"json-parse-better-errors": "^1.0.1"
}
},
"pify": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz",
"integrity": "sha1-5aSs0sEB/fPZpNB/DbxNtJ3SgXY=",
"dev": true
},
"semver": {
"version": "5.6.0",
"resolved": "https://registry.npmjs.org/semver/-/semver-5.6.0.tgz",
"integrity": "sha512-RS9R6R35NYgQn++fkDWaOmqGoj4Ek9gGs+DPxNUZKuwE183xjJroKvyo1IzVFeXvUrvmALy6FWD5xrdJT25gMg==",
"dev": true
},
"supports-color": {
"version": "5.5.0",
"resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
"integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
"dev": true,
"requires": {
"has-flag": "^3.0.0"
}
}
}
},
"listr": {
"version": "0.14.3",
"resolved": "https://registry.npmjs.org/listr/-/listr-0.14.3.tgz",
"integrity": "sha512-RmAl7su35BFd/xoMamRjpIE4j3v+L28o8CT5YhAXQJm1fD+1l9ngXY8JAQRJ+tFK2i5njvi0iRUKV09vPwA0iA==",
"dev": true,
"requires": {
"@samverschueren/stream-to-observable": "^0.3.0",
"is-observable": "^1.1.0",
"is-promise": "^2.1.0",
"is-stream": "^1.1.0",
"listr-silent-renderer": "^1.1.1",
"listr-update-renderer": "^0.5.0",
"listr-verbose-renderer": "^0.5.0",
"p-map": "^2.0.0",
"rxjs": "^6.3.3"
},
"dependencies": {
"p-map": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/p-map/-/p-map-2.0.0.tgz",
"integrity": "sha512-GO107XdrSUmtHxVoi60qc9tUl/KkNKm+X2CF4P9amalpGxv5YqVPJNfSb0wcA+syCopkZvYYIzW8OVTQW59x/w==",
"dev": true
}
}
},
"listr-silent-renderer": {
"version": "1.1.1",
"resolved": "https://registry.npmjs.org/listr-silent-renderer/-/listr-silent-renderer-1.1.1.tgz",
"integrity": "sha1-kktaN1cVN3C/Go4/v3S4u/P5JC4=",
"dev": true
},
"listr-update-renderer": {
"version": "0.5.0",
"resolved": "https://registry.npmjs.org/listr-update-renderer/-/listr-update-renderer-0.5.0.tgz",
"integrity": "sha512-tKRsZpKz8GSGqoI/+caPmfrypiaq+OQCbd+CovEC24uk1h952lVj5sC7SqyFUm+OaJ5HN/a1YLt5cit2FMNsFA==",
"dev": true,
"requires": {
"chalk": "^1.1.3",
"cli-truncate": "^0.2.1",
"elegant-spinner": "^1.0.1",
"figures": "^1.7.0",
"indent-string": "^3.0.0",
"log-symbols": "^1.0.2",
"log-update": "^2.3.0",
"strip-ansi": "^3.0.1"
},
"dependencies": {
"indent-string": {
"version": "3.2.0",
"resolved": "https://registry.npmjs.org/indent-string/-/indent-string-3.2.0.tgz",
"integrity": "sha1-Sl/W0nzDMvN+VBmlBNu4NxBckok=",
"dev": true
},
"log-symbols": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-1.0.2.tgz",
"integrity": "sha1-N2/3tY6jCGoPCfrMdGF+ylAeGhg=",
"dev": true,
"requires": {
"chalk": "^1.0.0"
}
}
}
},
"listr-verbose-renderer": {
"version": "0.5.0",
"resolved": "https://registry.npmjs.org/listr-verbose-renderer/-/listr-verbose-renderer-0.5.0.tgz",
"integrity": "sha512-04PDPqSlsqIOaaaGZ+41vq5FejI9auqTInicFRndCBgE3bXG8D6W1I+mWhk+1nqbHmyhla/6BUrd5OSiHwKRXw==",
"dev": true,
"requires": {
"chalk": "^2.4.1",
"cli-cursor": "^2.1.0",
"date-fns": "^1.27.2",
"figures": "^2.0.0"
},
"dependencies": {
"ansi-styles": {
"version": "3.2.1",
"resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
"integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
"dev": true,
"requires": {
"color-convert": "^1.9.0"
}
},
"chalk": {
"version": "2.4.1",
"resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz",
"integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==",
"dev": true,
"requires": {
"ansi-styles": "^3.2.1",
"escape-string-regexp": "^1.0.5",
"supports-color": "^5.3.0"
}
},
"figures": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/figures/-/figures-2.0.0.tgz",
"integrity": "sha1-OrGi0qYsi/tDGgyUy3l6L84nyWI=",
"dev": true,
"requires": {
"escape-string-regexp": "^1.0.5"
}
},
"has-flag": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
"integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=",
"dev": true
},
"supports-color": {
"version": "5.5.0",
"resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
"integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
"dev": true,
"requires": {
"has-flag": "^3.0.0"
}
}
}
},
"load-json-file": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-1.1.0.tgz",
"integrity": "sha1-lWkFcI1YtLq0wiYbBPWfMcmTdMA=",
"dev": true,
"requires": {
"graceful-fs": "^4.1.2",
"parse-json": "^2.2.0",
"pify": "^2.0.0",
"pinkie-promise": "^2.0.0",
"strip-bom": "^2.0.0"
}
},
"locate-path": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/locate-path/-/locate-path-3.0.0.tgz",
"integrity": "sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==",
"dev": true,
"requires": {
"p-locate": "^3.0.0",
"path-exists": "^3.0.0"
},
"dependencies": {
"path-exists": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz",
"integrity": "sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=",
"dev": true
}
}
},
"lodash": {
"version": "4.17.4",
"resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.4.tgz",
"integrity": "sha1-eCA6TRwyiuHYbcpkYONptX9AVa4=",
"dev": true
},
"lodash._baseassign": {
"version": "3.2.0",
"resolved": "https://registry.npmjs.org/lodash._baseassign/-/lodash._baseassign-3.2.0.tgz",
"integrity": "sha1-jDigmVAPIVrQnlnxci/QxSv+Ck4=",
"dev": true,
"requires": {
"lodash._basecopy": "^3.0.0",
"lodash.keys": "^3.0.0"
}
},
"lodash._basecopy": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/lodash._basecopy/-/lodash._basecopy-3.0.1.tgz",
"integrity": "sha1-jaDmqHbPNEwK2KVIghEd08XHyjY=",
"dev": true
},
"lodash._basecreate": {
"version": "3.0.3",
"resolved": "https://registry.npmjs.org/lodash._basecreate/-/lodash._basecreate-3.0.3.tgz",
"integrity": "sha1-G8ZhYU2qf8MRt9A78WgGoCE8+CE=",
"dev": true
},
"lodash._basetostring": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/lodash._basetostring/-/lodash._basetostring-3.0.1.tgz",
"integrity": "sha1-0YYdh3+CSlL2aYMtyvPuFVZqB9U=",
"dev": true
},
"lodash._basevalues": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/lodash._basevalues/-/lodash._basevalues-3.0.0.tgz",
"integrity": "sha1-W3dXYoAr3j0yl1A+JjAIIP32Ybc=",
"dev": true
},
"lodash._escapehtmlchar": {
"version": "2.4.1",
"resolved": "https://registry.npmjs.org/lodash._escapehtmlchar/-/lodash._escapehtmlchar-2.4.1.tgz",
"integrity": "sha1-32fDu2t+jh6DGrSL+geVuSr+iZ0=",
"dev": true,
"requires": {
"lodash._htmlescapes": "~2.4.1"
}
},
"lodash._escapestringchar": {
"version": "2.4.1",
"resolved": "https://registry.npmjs.org/lodash._escapestringchar/-/lodash._escapestringchar-2.4.1.tgz",
"integrity": "sha1-7P4iYYoq3lC/7qQ5N+Ud9m8O23I=",
"dev": true
},
"lodash._getnative": {
"version": "3.9.1",
"resolved": "https://registry.npmjs.org/lodash._getnative/-/lodash._getnative-3.9.1.tgz",
"integrity": "sha1-VwvH3t5G1hzc3mh9ZdPuy6o6r/U=",
"dev": true
},
"lodash._htmlescapes": {
"version": "2.4.1",
"resolved": "https://registry.npmjs.org/lodash._htmlescapes/-/lodash._htmlescapes-2.4.1.tgz",
"integrity": "sha1-MtFL8IRLbeb4tioFG09nwii2JMs=",
"dev": true
},
"lodash._isiterateecall": {
"version": "3.0.9",
"resolved": "https://registry.npmjs.org/lodash._isiterateecall/-/lodash._isiterateecall-3.0.9.tgz",
"integrity": "sha1-UgOte6Ql+uhCRg5pbbnPPmqsBXw=",
"dev": true
},
"lodash._isnative": {
"version": "2.4.1",
"resolved": "https://registry.npmjs.org/lodash._isnative/-/lodash._isnative-2.4.1.tgz",
"integrity": "sha1-PqZAS3hKe+g2x7V1gOHN95sUgyw=",
"dev": true
},
"lodash._objecttypes": {
"version": "2.4.1",
"resolved": "https://registry.npmjs.org/lodash._objecttypes/-/lodash._objecttypes-2.4.1.tgz",
"integrity": "sha1-fAt/admKH3ZSn4kLDNsbTf7BHBE=",
"dev": true
},
"lodash._reescape": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/lodash._reescape/-/lodash._reescape-3.0.0.tgz",
"integrity": "sha1-Kx1vXf4HyKNVdT5fJ/rH8c3hYWo=",
"dev": true
},
"lodash._reevaluate": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/lodash._reevaluate/-/lodash._reevaluate-3.0.0.tgz",
"integrity": "sha1-WLx0xAZklTrgsSTYBpltrKQx4u0=",
"dev": true
},
"lodash._reinterpolate": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/lodash._reinterpolate/-/lodash._reinterpolate-3.0.0.tgz",
"integrity": "sha1-DM8tiRZq8Ds2Y8eWU4t1rG4RTZ0=",
"dev": true
},
"lodash._reunescapedhtml": {
"version": "2.4.1",
"resolved": "https://registry.npmjs.org/lodash._reunescapedhtml/-/lodash._reunescapedhtml-2.4.1.tgz",
"integrity": "sha1-dHxPxAED6zu4oJduVx96JlnpO6c=",
"dev": true,
"requires": {
"lodash._htmlescapes": "~2.4.1",
"lodash.keys": "~2.4.1"
},
"dependencies": {
"lodash.keys": {
"version": "2.4.1",
"resolved": "https://registry.npmjs.org/lodash.keys/-/lodash.keys-2.4.1.tgz",
"integrity": "sha1-SN6kbfj/djKxDXBrissmWR4rNyc=",
"dev": true,
"requires": {
"lodash._isnative": "~2.4.1",
"lodash._shimkeys": "~2.4.1",
"lodash.isobject": "~2.4.1"
}
}
}
},
"lodash._root": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/lodash._root/-/lodash._root-3.0.1.tgz",
"integrity": "sha1-+6HEUkwZ7ppfgTa0YJ8BfPTe1pI=",
"dev": true
},
"lodash._shimkeys": {
"version": "2.4.1",
"resolved": "https://registry.npmjs.org/lodash._shimkeys/-/lodash._shimkeys-2.4.1.tgz",
"integrity": "sha1-bpzJZm/wgfC1psl4uD4kLmlJ0gM=",
"dev": true,
"requires": {
"lodash._objecttypes": "~2.4.1"
}
},
"lodash.assignwith": {
"version": "4.2.0",
"resolved": "https://registry.npmjs.org/lodash.assignwith/-/lodash.assignwith-4.2.0.tgz",
"integrity": "sha1-EnqX8CrcQXUalU0ksN4X4QDgOOs=",
"dev": true
},
"lodash.create": {
"version": "3.1.1",
"resolved": "https://registry.npmjs.org/lodash.create/-/lodash.create-3.1.1.tgz",
"integrity": "sha1-1/KEnw29p+BGgruM1yqwIkYd6+c=",
"dev": true,
"requires": {
"lodash._baseassign": "^3.0.0",
"lodash._basecreate": "^3.0.0",
"lodash._isiterateecall": "^3.0.0"
}
},
"lodash.defaults": {
"version": "2.4.1",
"resolved": "https://registry.npmjs.org/lodash.defaults/-/lodash.defaults-2.4.1.tgz",
"integrity": "sha1-p+iIXwXmiFEUS24SqPNngCa8TFQ=",
"dev": true,
"requires": {
"lodash._objecttypes": "~2.4.1",
"lodash.keys": "~2.4.1"
},
"dependencies": {
"lodash.keys": {
"version": "2.4.1",
"resolved": "https://registry.npmjs.org/lodash.keys/-/lodash.keys-2.4.1.tgz",
"integrity": "sha1-SN6kbfj/djKxDXBrissmWR4rNyc=",
"dev": true,
"requires": {
"lodash._isnative": "~2.4.1",
"lodash._shimkeys": "~2.4.1",
"lodash.isobject": "~2.4.1"
}
}
}
},
"lodash.escape": {
"version": "3.2.0",
"resolved": "https://registry.npmjs.org/lodash.escape/-/lodash.escape-3.2.0.tgz",
"integrity": "sha1-mV7g3BjBtIzJLv+ucaEKq1tIdpg=",
"dev": true,
"requires": {
"lodash._root": "^3.0.0"
}
},
"lodash.isarguments": {
"version": "3.1.0",
"resolved": "https://registry.npmjs.org/lodash.isarguments/-/lodash.isarguments-3.1.0.tgz",
"integrity": "sha1-L1c9hcaiQon/AGY7SRwdM4/zRYo=",
"dev": true
},
"lodash.isarray": {
"version": "3.0.4",
"resolved": "https://registry.npmjs.org/lodash.isarray/-/lodash.isarray-3.0.4.tgz",
"integrity": "sha1-eeTriMNqgSKvhvhEqpvNhRtfu1U=",
"dev": true
},
"lodash.isempty": {
"version": "4.4.0",
"resolved": "https://registry.npmjs.org/lodash.isempty/-/lodash.isempty-4.4.0.tgz",
"integrity": "sha1-b4bL7di+TsmHvpqvM8loTbGzHn4=",
"dev": true
},
"lodash.isobject": {
"version": "2.4.1",
"resolved": "https://registry.npmjs.org/lodash.isobject/-/lodash.isobject-2.4.1.tgz",
"integrity": "sha1-Wi5H/mmVPx7mMafrof5k0tBlWPU=",
"dev": true,
"requires": {
"lodash._objecttypes": "~2.4.1"
}
},
"lodash.isplainobject": {
"version": "4.0.6",
"resolved": "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz",
"integrity": "sha1-fFJqUtibRcRcxpC4gWO+BJf1UMs=",
"dev": true
},
"lodash.isstring": {
"version": "4.0.1",
"resolved": "https://registry.npmjs.org/lodash.isstring/-/lodash.isstring-4.0.1.tgz",
"integrity": "sha1-1SfftUVuynzJu5XV2ur4i6VKVFE=",
"dev": true
},
"lodash.keys": {
"version": "3.1.2",
"resolved": "https://registry.npmjs.org/lodash.keys/-/lodash.keys-3.1.2.tgz",
"integrity": "sha1-TbwEcrFWvlCgsoaFXRvQsMZWCYo=",
"dev": true,
"requires": {
"lodash._getnative": "^3.0.0",
"lodash.isarguments": "^3.0.0",
"lodash.isarray": "^3.0.0"
}
},
"lodash.mapvalues": {
"version": "4.6.0",
"resolved": "https://registry.npmjs.org/lodash.mapvalues/-/lodash.mapvalues-4.6.0.tgz",
"integrity": "sha1-G6+lAF3p3W9PJmaMMMo3IwzJaJw=",
"dev": true
},
"lodash.pick": {
"version": "4.4.0",
"resolved": "https://registry.npmjs.org/lodash.pick/-/lodash.pick-4.4.0.tgz",
"integrity": "sha1-UvBWEP/53tQiYRRB7R/BI6AwAbM=",
"dev": true
},
"lodash.restparam": {
"version": "3.6.1",
"resolved": "https://registry.npmjs.org/lodash.restparam/-/lodash.restparam-3.6.1.tgz",
"integrity": "sha1-k2pOMJ7zMKdkXtQUWYbIWuWyCAU=",
"dev": true
},
"lodash.template": {
"version": "3.6.2",
"resolved": "https://registry.npmjs.org/lodash.template/-/lodash.template-3.6.2.tgz",
"integrity": "sha1-+M3sxhaaJVvpCYrosMU9N4kx0U8=",
"dev": true,
"requires": {
"lodash._basecopy": "^3.0.0",
"lodash._basetostring": "^3.0.0",
"lodash._basevalues": "^3.0.0",
"lodash._isiterateecall": "^3.0.0",
"lodash._reinterpolate": "^3.0.0",
"lodash.escape": "^3.0.0",
"lodash.keys": "^3.0.0",
"lodash.restparam": "^3.0.0",
"lodash.templatesettings": "^3.0.0"
}
},
"lodash.templatesettings": {
"version": "3.1.1",
"resolved": "https://registry.npmjs.org/lodash.templatesettings/-/lodash.templatesettings-3.1.1.tgz",
"integrity": "sha1-+zB4RHU7Zrnxr6VOJix0UwfbqOU=",
"dev": true,
"requires": {
"lodash._reinterpolate": "^3.0.0",
"lodash.escape": "^3.0.0"
}
},
"lodash.values": {
"version": "2.4.1",
"resolved": "https://registry.npmjs.org/lodash.values/-/lodash.values-2.4.1.tgz",
"integrity": "sha1-q/UUQ2s8twUAFieXjLzzCxKA7qQ=",
"dev": true,
"requires": {
"lodash.keys": "~2.4.1"
},
"dependencies": {
"lodash.keys": {
"version": "2.4.1",
"resolved": "https://registry.npmjs.org/lodash.keys/-/lodash.keys-2.4.1.tgz",
"integrity": "sha1-SN6kbfj/djKxDXBrissmWR4rNyc=",
"dev": true,
"requires": {
"lodash._isnative": "~2.4.1",
"lodash._shimkeys": "~2.4.1",
"lodash.isobject": "~2.4.1"
}
}
}
},
"log-symbols": {
"version": "2.2.0",
"resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-2.2.0.tgz",
"integrity": "sha512-VeIAFslyIerEJLXHziedo2basKbMKtTw3vfn5IzG0XTjhAVEJyNHnL2p7vc+wBDSdQuUpNw3M2u6xb9QsAY5Eg==",
"dev": true,
"requires": {
"chalk": "^2.0.1"
},
"dependencies": {
"ansi-styles": {
"version": "3.2.1",
"resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
"integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
"dev": true,
"requires": {
"color-convert": "^1.9.0"
}
},
"chalk": {
"version": "2.4.1",
"resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz",
"integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==",
"dev": true,
"requires": {
"ansi-styles": "^3.2.1",
"escape-string-regexp": "^1.0.5",
"supports-color": "^5.3.0"
}
},
"has-flag": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
"integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=",
"dev": true
},
"supports-color": {
"version": "5.5.0",
"resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
"integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
"dev": true,
"requires": {
"has-flag": "^3.0.0"
}
}
}
},
"log-update": {
"version": "2.3.0",
"resolved": "https://registry.npmjs.org/log-update/-/log-update-2.3.0.tgz",
"integrity": "sha1-iDKP19HOeTiykoN0bwsbwSayRwg=",
"dev": true,
"requires": {
"ansi-escapes": "^3.0.0",
"cli-cursor": "^2.0.0",
"wrap-ansi": "^3.0.1"
}
},
"longest": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/longest/-/longest-1.0.1.tgz",
"integrity": "sha1-MKCy2jj3N3DoKUoNIuZiXtd9AJc=",
"dev": true,
"optional": true
},
"loud-rejection": {
"version": "1.6.0",
"resolved": "https://registry.npmjs.org/loud-rejection/-/loud-rejection-1.6.0.tgz",
"integrity": "sha1-W0b4AUft7leIcPCG0Eghz5mOVR8=",
"dev": true,
"requires": {
"currently-unhandled": "^0.4.1",
"signal-exit": "^3.0.0"
}
},
"lru-cache": {
"version": "2.7.3",
"resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-2.7.3.tgz",
"integrity": "sha1-bUUk6LlV+V1PW1iFHOId1y+06VI=",
"dev": true
},
"map-cache": {
"version": "0.2.2",
"resolved": "https://registry.npmjs.org/map-cache/-/map-cache-0.2.2.tgz",
"integrity": "sha1-wyq9C9ZSXZsFFkW7TyasXcmKDb8=",
"dev": true
},
"map-obj": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/map-obj/-/map-obj-1.0.1.tgz",
"integrity": "sha1-2TPOuSBdgr3PSIb2dCvcK03qFG0=",
"dev": true
},
"map-stream": {
"version": "0.1.0",
"resolved": "https://registry.npmjs.org/map-stream/-/map-stream-0.1.0.tgz",
"integrity": "sha1-5WqpTEyAVaFkBKBnS3jyFffI4ZQ=",
"dev": true
},
"map-visit": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/map-visit/-/map-visit-1.0.0.tgz",
"integrity": "sha1-7Nyo8TFE5mDxtb1B8S80edmN+48=",
"dev": true,
"requires": {
"object-visit": "^1.0.0"
}
},
"marked": {
"version": "0.3.6",
"resolved": "https://registry.npmjs.org/marked/-/marked-0.3.6.tgz",
"integrity": "sha1-ssbGGPzOzk74bE/Gy4p8v1rtqNc=",
"dev": true
},
"matcher": {
"version": "1.1.1",
"resolved": "https://registry.npmjs.org/matcher/-/matcher-1.1.1.tgz",
"integrity": "sha512-+BmqxWIubKTRKNWx/ahnCkk3mG8m7OturVlqq6HiojGJTd5hVYbgZm6WzcYPCoB+KBT4Vd6R7WSRG2OADNaCjg==",
"dev": true,
"requires": {
"escape-string-regexp": "^1.0.4"
}
},
"meow": {
"version": "3.7.0",
"resolved": "https://registry.npmjs.org/meow/-/meow-3.7.0.tgz",
"integrity": "sha1-cstmi0JSKCkKu/qFaJJYcwioAfs=",
"dev": true,
"requires": {
"camelcase-keys": "^2.0.0",
"decamelize": "^1.1.2",
"loud-rejection": "^1.0.0",
"map-obj": "^1.0.1",
"minimist": "^1.1.3",
"normalize-package-data": "^2.3.4",
"object-assign": "^4.0.1",
"read-pkg-up": "^1.0.1",
"redent": "^1.0.0",
"trim-newlines": "^1.0.0"
},
"dependencies": {
"normalize-package-data": {
"version": "2.4.0",
"resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.4.0.tgz",
"integrity": "sha512-9jjUFbTPfEy3R/ad/2oNbKtW9Hgovl5O1FvFWKkKblNXoN/Oou6+9+KKohPK13Yc3/TyunyWhJp6gvRNR/PPAw==",
"dev": true,
"requires": {
"hosted-git-info": "^2.1.4",
"is-builtin-module": "^1.0.0",
"semver": "2 || 3 || 4 || 5",
"validate-npm-package-license": "^3.0.1"
}
}
}
},
"micromatch": {
"version": "2.3.11",
"resolved": "https://registry.npmjs.org/micromatch/-/micromatch-2.3.11.tgz",
"integrity": "sha1-hmd8l9FyCzY0MdBNDRUpO9OMFWU=",
"dev": true,
"requires": {
"arr-diff": "^2.0.0",
"array-unique": "^0.2.1",
"braces": "^1.8.2",
"expand-brackets": "^0.1.4",
"extglob": "^0.3.1",
"filename-regex": "^2.0.0",
"is-extglob": "^1.0.0",
"is-glob": "^2.0.1",
"kind-of": "^3.0.2",
"normalize-path": "^2.0.1",
"object.omit": "^2.0.0",
"parse-glob": "^3.0.4",
"regex-cache": "^0.4.2"
}
},
"mime": {
"version": "1.2.11",
"resolved": "https://registry.npmjs.org/mime/-/mime-1.2.11.tgz",
"integrity": "sha1-WCA+7Ybjpe8XrtK32evUfwpg3RA=",
"dev": true,
"optional": true
},
"mime-types": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/mime-types/-/mime-types-1.0.2.tgz",
"integrity": "sha1-mVrhOSq4r/y/yyZB3QVOlDwNXc4=",
"dev": true
},
"mimic-fn": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-1.2.0.tgz",
"integrity": "sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ==",
"dev": true
},
"minimatch": {
"version": "2.0.10",
"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-2.0.10.tgz",
"integrity": "sha1-jQh8OcazjAAbl/ynzm0OHoCvusc=",
"dev": true,
"requires": {
"brace-expansion": "^1.0.0"
}
},
"minimist": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
"integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=",
"dev": true
},
"mixin-deep": {
"version": "1.3.1",
"resolved": "https://registry.npmjs.org/mixin-deep/-/mixin-deep-1.3.1.tgz",
"integrity": "sha512-8ZItLHeEgaqEvd5lYBXfm4EZSFCX29Jb9K+lAHhDKzReKBQKj3R+7NOF6tjqYi9t4oI8VUfaWITJQm86wnXGNQ==",
"dev": true,
"requires": {
"for-in": "^1.0.2",
"is-extendable": "^1.0.1"
},
"dependencies": {
"is-extendable": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz",
"integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==",
"dev": true,
"requires": {
"is-plain-object": "^2.0.4"
}
}
}
},
"mkdirp": {
"version": "0.5.1",
"resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz",
"integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=",
"dev": true,
"requires": {
"minimist": "0.0.8"
},
"dependencies": {
"minimist": {
"version": "0.0.8",
"resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz",
"integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=",
"dev": true
}
}
},
"mocha": {
"version": "3.5.3",
"resolved": "https://registry.npmjs.org/mocha/-/mocha-3.5.3.tgz",
"integrity": "sha512-/6na001MJWEtYxHOV1WLfsmR4YIynkUEhBwzsb+fk2qmQ3iqsi258l/Q2MWHJMImAcNpZ8DEdYAK72NHoIQ9Eg==",
"dev": true,
"requires": {
"browser-stdout": "1.3.0",
"commander": "2.9.0",
"debug": "2.6.8",
"diff": "3.2.0",
"escape-string-regexp": "1.0.5",
"glob": "7.1.1",
"growl": "1.9.2",
"he": "1.1.1",
"json3": "3.3.2",
"lodash.create": "3.1.1",
"mkdirp": "0.5.1",
"supports-color": "3.1.2"
},
"dependencies": {
"glob": {
"version": "7.1.1",
"resolved": "https://registry.npmjs.org/glob/-/glob-7.1.1.tgz",
"integrity": "sha1-gFIR3wT6rxxjo2ADBs31reULLsg=",
"dev": true,
"requires": {
"fs.realpath": "^1.0.0",
"inflight": "^1.0.4",
"inherits": "2",
"minimatch": "^3.0.2",
"once": "^1.3.0",
"path-is-absolute": "^1.0.0"
}
},
"minimatch": {
"version": "3.0.4",
"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
"integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
"dev": true,
"requires": {
"brace-expansion": "^1.1.7"
}
},
"supports-color": {
"version": "3.1.2",
"resolved": "https://registry.npmjs.org/supports-color/-/supports-color-3.1.2.tgz",
"integrity": "sha1-cqJiiU2dQIuVbKBf83su2KbiotU=",
"dev": true,
"requires": {
"has-flag": "^1.0.0"
}
}
}
},
"mocha-parallel-executor": {
"version": "0.3.0",
"resolved": "https://registry.npmjs.org/mocha-parallel-executor/-/mocha-parallel-executor-0.3.0.tgz",
"integrity": "sha1-tOZupcnNaPIWC6cB4gxWloITPck=",
"dev": true,
"requires": {
"dcp": "^0.1.3",
"lodash": "^4.14.1",
"mocha": "^3.0.0",
"neo-async": "^2.0.0"
},
"dependencies": {
"neo-async": {
"version": "2.2.0",
"resolved": "https://registry.npmjs.org/neo-async/-/neo-async-2.2.0.tgz",
"integrity": "sha1-63y327hbghzlFo0MZfkCnlybRkg=",
"dev": true
}
}
},
"mocha.parallel": {
"version": "0.15.3",
"resolved": "https://registry.npmjs.org/mocha.parallel/-/mocha.parallel-0.15.3.tgz",
"integrity": "sha512-3UqVrq5XtAtR2eMHl/N6URoSmizwaCcc84iIETtytEMbP0cIo6KacpCJFmF1id090Ig+HmbAuakC7RM4msfC2Q==",
"dev": true,
"requires": {
"bluebird": "^2.9.34",
"semaphore": "^1.0.5"
},
"dependencies": {
"bluebird": {
"version": "2.11.0",
"resolved": "https://registry.npmjs.org/bluebird/-/bluebird-2.11.0.tgz",
"integrity": "sha1-U0uQM8AiyVecVro7Plpcqvu2UOE=",
"dev": true
}
}
},
"ms": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
"integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=",
"dev": true
},
"multipipe": {
"version": "0.1.2",
"resolved": "https://registry.npmjs.org/multipipe/-/multipipe-0.1.2.tgz",
"integrity": "sha1-Ko8t33Du1WTf8tV/HhoTfZ8FB4s=",
"dev": true,
"requires": {
"duplexer2": "0.0.2"
}
},
"mute-stream": {
"version": "0.0.7",
"resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.7.tgz",
"integrity": "sha1-MHXOk7whuPq0PhvE2n6BFe0ee6s=",
"dev": true
},
"nanomatch": {
"version": "1.2.13",
"resolved": "https://registry.npmjs.org/nanomatch/-/nanomatch-1.2.13.tgz",
"integrity": "sha512-fpoe2T0RbHwBTBUOftAfBPaDEi06ufaUai0mE6Yn1kacc3SnTErfb/h+X94VXzI64rKFHYImXSvdwGGCmwOqCA==",
"dev": true,
"requires": {
"arr-diff": "^4.0.0",
"array-unique": "^0.3.2",
"define-property": "^2.0.2",
"extend-shallow": "^3.0.2",
"fragment-cache": "^0.2.1",
"is-windows": "^1.0.2",
"kind-of": "^6.0.2",
"object.pick": "^1.3.0",
"regex-not": "^1.0.0",
"snapdragon": "^0.8.1",
"to-regex": "^3.0.1"
},
"dependencies": {
"arr-diff": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-4.0.0.tgz",
"integrity": "sha1-1kYQdP6/7HHn4VI1dhoyml3HxSA=",
"dev": true
},
"array-unique": {
"version": "0.3.2",
"resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.3.2.tgz",
"integrity": "sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg=",
"dev": true
},
"extend-shallow": {
"version": "3.0.2",
"resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz",
"integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=",
"dev": true,
"requires": {
"assign-symbols": "^1.0.0",
"is-extendable": "^1.0.1"
}
},
"is-extendable": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz",
"integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==",
"dev": true,
"requires": {
"is-plain-object": "^2.0.4"
}
},
"is-windows": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz",
"integrity": "sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==",
"dev": true
},
"kind-of": {
"version": "6.0.2",
"resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.2.tgz",
"integrity": "sha512-s5kLOcnH0XqDO+FvuaLX8DDjZ18CGFk7VygH40QoKPUQhW4e2rvM0rwUq0t8IQDOwYSeLK01U90OjzBTme2QqA==",
"dev": true
}
}
},
"natives": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/natives/-/natives-1.1.0.tgz",
"integrity": "sha1-6f+EFBimsux6SV6TmYT3jxY+bjE=",
"dev": true
},
"natural-compare": {
"version": "1.2.2",
"resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.2.2.tgz",
"integrity": "sha1-H5bWDjFBysG20FZTzg2urHY69qo=",
"dev": true
},
"ncp": {
"version": "0.4.2",
"resolved": "https://registry.npmjs.org/ncp/-/ncp-0.4.2.tgz",
"integrity": "sha1-q8xsvT7C7Spyn/bnwfqPAXhKhXQ=",
"dev": true
},
"neo-timer": {
"version": "0.2.0",
"resolved": "https://registry.npmjs.org/neo-timer/-/neo-timer-0.2.0.tgz",
"integrity": "sha1-XxAvuawgC/cFMyGiaNnrx4d3GT8=",
"dev": true
},
"nice-try": {
"version": "1.0.5",
"resolved": "https://registry.npmjs.org/nice-try/-/nice-try-1.0.5.tgz",
"integrity": "sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ==",
"dev": true
},
"node-uuid": {
"version": "1.4.8",
"resolved": "https://registry.npmjs.org/node-uuid/-/node-uuid-1.4.8.tgz",
"integrity": "sha1-sEDrCSOWivq/jTL7HxfxFn/auQc=",
"dev": true
},
"nomnom": {
"version": "1.8.1",
"resolved": "https://registry.npmjs.org/nomnom/-/nomnom-1.8.1.tgz",
"integrity": "sha1-IVH3Ikcrp55Qp2/BJbuMjy5Nwqc=",
"dev": true,
"requires": {
"chalk": "~0.4.0",
"underscore": "~1.6.0"
},
"dependencies": {
"ansi-styles": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-1.0.0.tgz",
"integrity": "sha1-yxAt8cVvUSPquLZ817mAJ6AnkXg=",
"dev": true
},
"chalk": {
"version": "0.4.0",
"resolved": "https://registry.npmjs.org/chalk/-/chalk-0.4.0.tgz",
"integrity": "sha1-UZmj3c0MHv4jvAjBsCewYXbgxk8=",
"dev": true,
"requires": {
"ansi-styles": "~1.0.0",
"has-color": "~0.1.0",
"strip-ansi": "~0.1.0"
}
},
"strip-ansi": {
"version": "0.1.1",
"resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-0.1.1.tgz",
"integrity": "sha1-OeipjQRNFQZgq+SmgIrPcLt7yZE=",
"dev": true
}
}
},
"nopt": {
"version": "3.0.6",
"resolved": "https://registry.npmjs.org/nopt/-/nopt-3.0.6.tgz",
"integrity": "sha1-xkZdvwirzU2zWTF/eaxopkayj/k=",
"dev": true,
"requires": {
"abbrev": "1"
}
},
"normalize-package-data": {
"version": "2.4.0",
"resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.4.0.tgz",
"integrity": "sha512-9jjUFbTPfEy3R/ad/2oNbKtW9Hgovl5O1FvFWKkKblNXoN/Oou6+9+KKohPK13Yc3/TyunyWhJp6gvRNR/PPAw==",
"dev": true,
"requires": {
"hosted-git-info": "^2.1.4",
"is-builtin-module": "^1.0.0",
"semver": "2 || 3 || 4 || 5",
"validate-npm-package-license": "^3.0.1"
}
},
"normalize-path": {
"version": "2.1.1",
"resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-2.1.1.tgz",
"integrity": "sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=",
"dev": true,
"requires": {
"remove-trailing-separator": "^1.0.1"
}
},
"npm-path": {
"version": "2.0.4",
"resolved": "https://registry.npmjs.org/npm-path/-/npm-path-2.0.4.tgz",
"integrity": "sha512-IFsj0R9C7ZdR5cP+ET342q77uSRdtWOlWpih5eC+lu29tIDbNEgDbzgVJ5UFvYHWhxDZ5TFkJafFioO0pPQjCw==",
"dev": true,
"requires": {
"which": "^1.2.10"
}
},
"npm-run-path": {
"version": "2.0.2",
"resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-2.0.2.tgz",
"integrity": "sha1-NakjLfo11wZ7TLLd8jV7GHFTbF8=",
"dev": true,
"requires": {
"path-key": "^2.0.0"
}
},
"npm-which": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/npm-which/-/npm-which-3.0.1.tgz",
"integrity": "sha1-kiXybsOihcIJyuZ8OxGmtKtxQKo=",
"dev": true,
"requires": {
"commander": "^2.9.0",
"npm-path": "^2.0.2",
"which": "^1.2.10"
}
},
"number-is-nan": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/number-is-nan/-/number-is-nan-1.0.1.tgz",
"integrity": "sha1-CXtgK1NCKlIsGvuHkDGDNpQaAR0=",
"dev": true
},
"oauth-sign": {
"version": "0.4.0",
"resolved": "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.4.0.tgz",
"integrity": "sha1-8ilW8x6nFRqCHl8vsywRPK2Ln2k=",
"dev": true,
"optional": true
},
"object-assign": {
"version": "4.1.1",
"resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
"integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=",
"dev": true
},
"object-copy": {
"version": "0.1.0",
"resolved": "https://registry.npmjs.org/object-copy/-/object-copy-0.1.0.tgz",
"integrity": "sha1-fn2Fi3gb18mRpBupde04EnVOmYw=",
"dev": true,
"requires": {
"copy-descriptor": "^0.1.0",
"define-property": "^0.2.5",
"kind-of": "^3.0.3"
},
"dependencies": {
"define-property": {
"version": "0.2.5",
"resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz",
"integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=",
"dev": true,
"requires": {
"is-descriptor": "^0.1.0"
}
}
}
},
"object-keys": {
"version": "0.4.0",
"resolved": "https://registry.npmjs.org/object-keys/-/object-keys-0.4.0.tgz",
"integrity": "sha1-KKaq50KN0sOpLz2V8hM13SBOAzY=",
"dev": true
},
"object-visit": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/object-visit/-/object-visit-1.0.1.tgz",
"integrity": "sha1-95xEk68MU3e1n+OdOV5BBC3QRbs=",
"dev": true,
"requires": {
"isobject": "^3.0.0"
},
"dependencies": {
"isobject": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz",
"integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=",
"dev": true
}
}
},
"object.omit": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/object.omit/-/object.omit-2.0.1.tgz",
"integrity": "sha1-Gpx0SCnznbuFjHbKNXmuKlTr0fo=",
"dev": true,
"requires": {
"for-own": "^0.1.4",
"is-extendable": "^0.1.1"
}
},
"object.pick": {
"version": "1.3.0",
"resolved": "https://registry.npmjs.org/object.pick/-/object.pick-1.3.0.tgz",
"integrity": "sha1-h6EKxMFpS9Lhy/U1kaZhQftd10c=",
"dev": true,
"requires": {
"isobject": "^3.0.1"
},
"dependencies": {
"isobject": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz",
"integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=",
"dev": true
}
}
},
"once": {
"version": "1.3.3",
"resolved": "https://registry.npmjs.org/once/-/once-1.3.3.tgz",
"integrity": "sha1-suJhVXzkwxTsgwTz+oJmPkKXyiA=",
"dev": true,
"requires": {
"wrappy": "1"
}
},
"onetime": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/onetime/-/onetime-2.0.1.tgz",
"integrity": "sha1-BnQoIw/WdEOyeUsiu6UotoZ5YtQ=",
"dev": true,
"requires": {
"mimic-fn": "^1.0.0"
}
},
"optimist": {
"version": "0.6.1",
"resolved": "https://registry.npmjs.org/optimist/-/optimist-0.6.1.tgz",
"integrity": "sha1-2j6nRob6IaGaERwybpDrFaAZZoY=",
"dev": true,
"requires": {
"minimist": "~0.0.1",
"wordwrap": "~0.0.2"
},
"dependencies": {
"minimist": {
"version": "0.0.10",
"resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.10.tgz",
"integrity": "sha1-3j+YVD2/lggr5IrRoMfNqDYwHc8=",
"dev": true
},
"wordwrap": {
"version": "0.0.3",
"resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-0.0.3.tgz",
"integrity": "sha1-o9XabNXAvAAI03I0u68b7WMFkQc=",
"dev": true
}
}
},
"optionator": {
"version": "0.8.2",
"resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.2.tgz",
"integrity": "sha1-NkxeQJ0/TWMB1sC0wFu6UBgK62Q=",
"dev": true,
"requires": {
"deep-is": "~0.1.3",
"fast-levenshtein": "~2.0.4",
"levn": "~0.3.0",
"prelude-ls": "~1.1.2",
"type-check": "~0.3.2",
"wordwrap": "~1.0.0"
}
},
"orchestrator": {
"version": "0.3.8",
"resolved": "https://registry.npmjs.org/orchestrator/-/orchestrator-0.3.8.tgz",
"integrity": "sha1-FOfp4nZPcxX7rBhOUGx6pt+UrX4=",
"dev": true,
"requires": {
"end-of-stream": "~0.1.5",
"sequencify": "~0.0.7",
"stream-consume": "~0.1.0"
}
},
"ordered-read-streams": {
"version": "0.1.0",
"resolved": "https://registry.npmjs.org/ordered-read-streams/-/ordered-read-streams-0.1.0.tgz",
"integrity": "sha1-/VZamvjrRHO6abbtijQ1LLVS8SY=",
"dev": true
},
"os-homedir": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/os-homedir/-/os-homedir-1.0.2.tgz",
"integrity": "sha1-/7xJiDNuDoM94MFox+8VISGqf7M=",
"dev": true
},
"p-finally": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/p-finally/-/p-finally-1.0.0.tgz",
"integrity": "sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4=",
"dev": true
},
"p-limit": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.0.0.tgz",
"integrity": "sha512-fl5s52lI5ahKCernzzIyAP0QAZbGIovtVHGwpcu1Jr/EpzLVDI2myISHwGqK7m8uQFugVWSrbxH7XnhGtvEc+A==",
"dev": true,
"requires": {
"p-try": "^2.0.0"
}
},
"p-locate": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/p-locate/-/p-locate-3.0.0.tgz",
"integrity": "sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==",
"dev": true,
"requires": {
"p-limit": "^2.0.0"
}
},
"p-map": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/p-map/-/p-map-1.2.0.tgz",
"integrity": "sha512-r6zKACMNhjPJMTl8KcFH4li//gkrXWfbD6feV8l6doRHlzljFWGJ2AP6iKaCJXyZmAUMOPtvbW7EXkbWO/pLEA==",
"dev": true
},
"p-try": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/p-try/-/p-try-2.0.0.tgz",
"integrity": "sha512-hMp0onDKIajHfIkdRk3P4CdCmErkYAxxDtP3Wx/4nZ3aGlau2VKh3mZpcuFkH27WQkL/3WBCPOktzA9ZOAnMQQ==",
"dev": true
},
"parse-filepath": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/parse-filepath/-/parse-filepath-1.0.1.tgz",
"integrity": "sha1-FZ1hVdQ5BNFsEO9piRHaHpGWm3M=",
"dev": true,
"requires": {
"is-absolute": "^0.2.3",
"map-cache": "^0.2.0",
"path-root": "^0.1.1"
}
},
"parse-glob": {
"version": "3.0.4",
"resolved": "https://registry.npmjs.org/parse-glob/-/parse-glob-3.0.4.tgz",
"integrity": "sha1-ssN2z7EfNVE7rdFz7wu246OIORw=",
"dev": true,
"requires": {
"glob-base": "^0.3.0",
"is-dotfile": "^1.0.0",
"is-extglob": "^1.0.0",
"is-glob": "^2.0.0"
}
},
"parse-json": {
"version": "2.2.0",
"resolved": "https://registry.npmjs.org/parse-json/-/parse-json-2.2.0.tgz",
"integrity": "sha1-9ID0BDTvgHQfhGkJn43qGPVaTck=",
"dev": true,
"requires": {
"error-ex": "^1.2.0"
}
},
"parse-passwd": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/parse-passwd/-/parse-passwd-1.0.0.tgz",
"integrity": "sha1-bVuTSkVpk7I9N/QKOC1vFmao5cY=",
"dev": true
},
"pascalcase": {
"version": "0.1.1",
"resolved": "https://registry.npmjs.org/pascalcase/-/pascalcase-0.1.1.tgz",
"integrity": "sha1-s2PlXoAGym/iF4TS2yK9FdeRfxQ=",
"dev": true
},
"path-exists": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/path-exists/-/path-exists-2.1.0.tgz",
"integrity": "sha1-D+tsZPD8UY2adU3V77YscCJ2H0s=",
"dev": true,
"requires": {
"pinkie-promise": "^2.0.0"
}
},
"path-is-absolute": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
"integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=",
"dev": true
},
"path-is-inside": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/path-is-inside/-/path-is-inside-1.0.2.tgz",
"integrity": "sha1-NlQX3t5EQw0cEa9hAn+s8HS9/FM=",
"dev": true
},
"path-key": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/path-key/-/path-key-2.0.1.tgz",
"integrity": "sha1-QRyttXTFoUDTpLGRDUDYDMn0C0A=",
"dev": true
},
"path-parse": {
"version": "1.0.5",
"resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.5.tgz",
"integrity": "sha1-PBrfhx6pzWyUMbbqK9dKD/BVxME=",
"dev": true
},
"path-root": {
"version": "0.1.1",
"resolved": "https://registry.npmjs.org/path-root/-/path-root-0.1.1.tgz",
"integrity": "sha1-mkpoFMrBwM1zNgqV8yCDyOpHRbc=",
"dev": true,
"requires": {
"path-root-regex": "^0.1.0"
}
},
"path-root-regex": {
"version": "0.1.2",
"resolved": "https://registry.npmjs.org/path-root-regex/-/path-root-regex-0.1.2.tgz",
"integrity": "sha1-v8zcjfWxLcUsi0PsONGNcsBLqW0=",
"dev": true
},
"path-type": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/path-type/-/path-type-1.1.0.tgz",
"integrity": "sha1-WcRPfuSR2nBNpBXaWkBwuk+P5EE=",
"dev": true,
"requires": {
"graceful-fs": "^4.1.2",
"pify": "^2.0.0",
"pinkie-promise": "^2.0.0"
}
},
"pathval": {
"version": "0.1.1",
"resolved": "https://registry.npmjs.org/pathval/-/pathval-0.1.1.tgz",
"integrity": "sha1-CPkRzcqczllCiA2ngXvAtyO2bYI=",
"dev": true
},
"pify": {
"version": "2.3.0",
"resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz",
"integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=",
"dev": true
},
"pinkie": {
"version": "2.0.4",
"resolved": "https://registry.npmjs.org/pinkie/-/pinkie-2.0.4.tgz",
"integrity": "sha1-clVrgM+g1IqXToDnckjoDtT3+HA=",
"dev": true
},
"pinkie-promise": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/pinkie-promise/-/pinkie-promise-2.0.1.tgz",
"integrity": "sha1-ITXW36ejWMBprJsXh3YogihFD/o=",
"dev": true,
"requires": {
"pinkie": "^2.0.0"
}
},
"pkg-dir": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-3.0.0.tgz",
"integrity": "sha512-/E57AYkoeQ25qkxMj5PBOVgF8Kiu/h7cYS30Z5+R7WaiCCBfLq58ZI/dSeaEKb9WVJV5n/03QwrN3IeWIFllvw==",
"dev": true,
"requires": {
"find-up": "^3.0.0"
},
"dependencies": {
"find-up": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/find-up/-/find-up-3.0.0.tgz",
"integrity": "sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==",
"dev": true,
"requires": {
"locate-path": "^3.0.0"
}
}
}
},
"pkginfo": {
"version": "0.4.0",
"resolved": "https://registry.npmjs.org/pkginfo/-/pkginfo-0.4.0.tgz",
"integrity": "sha1-NJ27f/04CB/K3AhT32h/DHdEzWU=",
"dev": true
},
"platform": {
"version": "1.3.4",
"resolved": "https://registry.npmjs.org/platform/-/platform-1.3.4.tgz",
"integrity": "sha1-bw+xftqqSPIUQrOpdcBjEw8cPr0=",
"dev": true
},
"please-upgrade-node": {
"version": "3.1.1",
"resolved": "https://registry.npmjs.org/please-upgrade-node/-/please-upgrade-node-3.1.1.tgz",
"integrity": "sha512-KY1uHnQ2NlQHqIJQpnh/i54rKkuxCEBx+voJIS/Mvb+L2iYd2NMotwduhKTMjfC1uKoX3VXOxLjIYG66dfJTVQ==",
"dev": true,
"requires": {
"semver-compare": "^1.0.0"
}
},
"plugin-error": {
"version": "0.1.2",
"resolved": "https://registry.npmjs.org/plugin-error/-/plugin-error-0.1.2.tgz",
"integrity": "sha1-O5uzM1zPAPQl4HQ34ZJ2ln2kes4=",
"dev": true,
"requires": {
"ansi-cyan": "^0.1.1",
"ansi-red": "^0.1.1",
"arr-diff": "^1.0.1",
"arr-union": "^2.0.1",
"extend-shallow": "^1.1.2"
},
"dependencies": {
"arr-diff": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-1.1.0.tgz",
"integrity": "sha1-aHwydYFjWI/vfeezb6vklesaOZo=",
"dev": true,
"requires": {
"arr-flatten": "^1.0.1",
"array-slice": "^0.2.3"
}
}
}
},
"plugin-log": {
"version": "0.1.0",
"resolved": "https://registry.npmjs.org/plugin-log/-/plugin-log-0.1.0.tgz",
"integrity": "sha1-hgSc9qsQgzOYqTHzaJy67nteEzM=",
"dev": true,
"requires": {
"chalk": "^1.1.1",
"dateformat": "^1.0.11"
}
},
"posix-character-classes": {
"version": "0.1.1",
"resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
"integrity": "sha1-AerA/jta9xoqbAL+q7jB/vfgDqs=",
"dev": true
},
"prelude-ls": {
"version": "1.1.2",
"resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz",
"integrity": "sha1-IZMqVJ9eUv/ZqCf1cOBL5iqX2lQ=",
"dev": true
},
"preserve": {
"version": "0.2.0",
"resolved": "https://registry.npmjs.org/preserve/-/preserve-0.2.0.tgz",
"integrity": "sha1-gV7R9uvGWSb4ZbMQwHE7yzMVzks=",
"dev": true
},
"prettier": {
"version": "1.15.2",
"resolved": "https://registry.npmjs.org/prettier/-/prettier-1.15.2.tgz",
"integrity": "sha512-YgPLFFA0CdKL4Eg2IHtUSjzj/BWgszDHiNQAe0VAIBse34148whfdzLagRL+QiKS+YfK5ftB6X4v/MBw8yCoug==",
"dev": true
},
"pretty-format": {
"version": "23.6.0",
"resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-23.6.0.tgz",
"integrity": "sha512-zf9NV1NSlDLDjycnwm6hpFATCGl/K1lt0R/GdkAK2O5LN/rwJoB+Mh93gGJjut4YbmecbfgLWVGSTCr0Ewvvbw==",
"dev": true,
"requires": {
"ansi-regex": "^3.0.0",
"ansi-styles": "^3.2.0"
},
"dependencies": {
"ansi-regex": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz",
"integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=",
"dev": true
},
"ansi-styles": {
"version": "3.2.1",
"resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
"integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
"dev": true,
"requires": {
"color-convert": "^1.9.0"
}
}
}
},
"pretty-hrtime": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/pretty-hrtime/-/pretty-hrtime-1.0.3.tgz",
"integrity": "sha1-t+PqQkNaTJsnWdmeDyAesZWALuE=",
"dev": true
},
"process-nextick-args": {
"version": "1.0.7",
"resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-1.0.7.tgz",
"integrity": "sha1-FQ4gt1ZZCtP5EJPyWk8q2L/zC6M=",
"dev": true
},
"prompt": {
"version": "0.2.14",
"resolved": "https://registry.npmjs.org/prompt/-/prompt-0.2.14.tgz",
"integrity": "sha1-V3VPZPVD/XsIRXB8gY7OYY8F/9w=",
"dev": true,
"requires": {
"pkginfo": "0.x.x",
"read": "1.0.x",
"revalidator": "0.1.x",
"utile": "0.2.x",
"winston": "0.8.x"
}
},
"pseudomap": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/pseudomap/-/pseudomap-1.0.2.tgz",
"integrity": "sha1-8FKijacOYYkX7wqKw0wa5aaChrM=",
"dev": true
},
"pump": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/pump/-/pump-3.0.0.tgz",
"integrity": "sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==",
"dev": true,
"requires": {
"end-of-stream": "^1.1.0",
"once": "^1.3.1"
},
"dependencies": {
"end-of-stream": {
"version": "1.4.1",
"resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.1.tgz",
"integrity": "sha512-1MkrZNvWTKCaigbn+W15elq2BB/L22nqrSY5DKlo3X6+vclJm8Bb5djXJBmEX6fS3+zCh/F4VBK5Z2KxJt4s2Q==",
"dev": true,
"requires": {
"once": "^1.4.0"
},
"dependencies": {
"once": {
"version": "1.4.0",
"resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
"integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
"dev": true,
"requires": {
"wrappy": "1"
}
}
}
}
}
},
"punycode": {
"version": "1.4.1",
"resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz",
"integrity": "sha1-wNWmOycYgArY4esPpSachN1BhF4=",
"dev": true,
"optional": true
},
"qs": {
"version": "1.2.2",
"resolved": "https://registry.npmjs.org/qs/-/qs-1.2.2.tgz",
"integrity": "sha1-GbV/8k3CqZzh+L32r82ln472H4g=",
"dev": true
},
"randomatic": {
"version": "1.1.6",
"resolved": "https://registry.npmjs.org/randomatic/-/randomatic-1.1.6.tgz",
"integrity": "sha1-EQ3Kv/OX6dz/fAeJzMCkmt8exbs=",
"dev": true,
"requires": {
"is-number": "^2.0.2",
"kind-of": "^3.0.2"
}
},
"read": {
"version": "1.0.7",
"resolved": "https://registry.npmjs.org/read/-/read-1.0.7.tgz",
"integrity": "sha1-s9oZvQUkMal2cdRKQmNK33ELQMQ=",
"dev": true,
"requires": {
"mute-stream": "~0.0.4"
}
},
"read-pkg": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-1.1.0.tgz",
"integrity": "sha1-9f+qXs0pyzHAR0vKfXVra7KePyg=",
"dev": true,
"requires": {
"load-json-file": "^1.0.0",
"normalize-package-data": "^2.3.2",
"path-type": "^1.0.0"
},
"dependencies": {
"normalize-package-data": {
"version": "2.4.0",
"resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.4.0.tgz",
"integrity": "sha512-9jjUFbTPfEy3R/ad/2oNbKtW9Hgovl5O1FvFWKkKblNXoN/Oou6+9+KKohPK13Yc3/TyunyWhJp6gvRNR/PPAw==",
"dev": true,
"requires": {
"hosted-git-info": "^2.1.4",
"is-builtin-module": "^1.0.0",
"semver": "2 || 3 || 4 || 5",
"validate-npm-package-license": "^3.0.1"
}
}
}
},
"read-pkg-up": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-1.0.1.tgz",
"integrity": "sha1-nWPBMnbAZZGNV/ACpX9AobZD+wI=",
"dev": true,
"requires": {
"find-up": "^1.0.0",
"read-pkg": "^1.0.0"
}
},
"readable-stream": {
"version": "1.0.34",
"resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.0.34.tgz",
"integrity": "sha1-Elgg40vIQtLyqq+v5MKRbuMsFXw=",
"dev": true,
"requires": {
"core-util-is": "~1.0.0",
"inherits": "~2.0.1",
"isarray": "0.0.1",
"string_decoder": "~0.10.x"
}
},
"rechoir": {
"version": "0.6.2",
"resolved": "https://registry.npmjs.org/rechoir/-/rechoir-0.6.2.tgz",
"integrity": "sha1-hSBLVNuoLVdC4oyWdW70OvUOM4Q=",
"dev": true,
"requires": {
"resolve": "^1.1.6"
}
},
"redent": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/redent/-/redent-1.0.0.tgz",
"integrity": "sha1-z5Fqsf1fHxbfsggi3W7H9zDCr94=",
"dev": true,
"requires": {
"indent-string": "^2.1.0",
"strip-indent": "^1.0.1"
}
},
"regenerator-runtime": {
"version": "0.10.5",
"resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.10.5.tgz",
"integrity": "sha1-M2w+/BIgrc7dosn6tntaeVWjNlg=",
"dev": true
},
"regex-cache": {
"version": "0.4.3",
"resolved": "https://registry.npmjs.org/regex-cache/-/regex-cache-0.4.3.tgz",
"integrity": "sha1-mxpsNdTQ3871cRrmUejp09cRQUU=",
"dev": true,
"requires": {
"is-equal-shallow": "^0.1.3",
"is-primitive": "^2.0.0"
}
},
"regex-not": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/regex-not/-/regex-not-1.0.2.tgz",
"integrity": "sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==",
"dev": true,
"requires": {
"extend-shallow": "^3.0.2",
"safe-regex": "^1.1.0"
},
"dependencies": {
"extend-shallow": {
"version": "3.0.2",
"resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz",
"integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=",
"dev": true,
"requires": {
"assign-symbols": "^1.0.0",
"is-extendable": "^1.0.1"
}
},
"is-extendable": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz",
"integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==",
"dev": true,
"requires": {
"is-plain-object": "^2.0.4"
}
}
}
},
"remove-trailing-separator": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/remove-trailing-separator/-/remove-trailing-separator-1.0.1.tgz",
"integrity": "sha1-YV67lq9VlVLUv0BXyENtSGq2PMQ=",
"dev": true
},
"repeat-element": {
"version": "1.1.2",
"resolved": "https://registry.npmjs.org/repeat-element/-/repeat-element-1.1.2.tgz",
"integrity": "sha1-7wiaF40Ug7quTZPrmLT55OEdmQo=",
"dev": true
},
"repeat-string": {
"version": "1.6.1",
"resolved": "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz",
"integrity": "sha1-jcrkcOHIirwtYA//Sndihtp15jc=",
"dev": true
},
"repeating": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/repeating/-/repeating-2.0.1.tgz",
"integrity": "sha1-UhTFOpJtNVJwdSf7q0FdvAjQbdo=",
"dev": true,
"requires": {
"is-finite": "^1.0.0"
}
},
"replace-ext": {
"version": "0.0.1",
"resolved": "https://registry.npmjs.org/replace-ext/-/replace-ext-0.0.1.tgz",
"integrity": "sha1-KbvZIHinOfC8zitO5B6DeVNSKSQ=",
"dev": true
},
"request": {
"version": "2.42.0",
"resolved": "https://registry.npmjs.org/request/-/request-2.42.0.tgz",
"integrity": "sha1-VyvQFIk4VkBArHqxSLlkI6BjMEo=",
"dev": true,
"requires": {
"aws-sign2": "~0.5.0",
"bl": "~0.9.0",
"caseless": "~0.6.0",
"forever-agent": "~0.5.0",
"form-data": "~0.1.0",
"hawk": "1.1.1",
"http-signature": "~0.10.0",
"json-stringify-safe": "~5.0.0",
"mime-types": "~1.0.1",
"node-uuid": "~1.4.0",
"oauth-sign": "~0.4.0",
"qs": "~1.2.0",
"stringstream": "~0.0.4",
"tough-cookie": ">=0.12.0",
"tunnel-agent": "~0.4.0"
}
},
"require-dir": {
"version": "0.3.2",
"resolved": "https://registry.npmjs.org/require-dir/-/require-dir-0.3.2.tgz",
"integrity": "sha1-wdXHXp+//eny5rM+OD209ZS1pqk=",
"dev": true
},
"requizzle": {
"version": "0.2.1",
"resolved": "https://registry.npmjs.org/requizzle/-/requizzle-0.2.1.tgz",
"integrity": "sha1-aUPDUwxNmn5G8c3dUcFY/GcM294=",
"dev": true,
"requires": {
"underscore": "~1.6.0"
}
},
"reserved-words": {
"version": "0.1.1",
"resolved": "https://registry.npmjs.org/reserved-words/-/reserved-words-0.1.1.tgz",
"integrity": "sha1-b3wV5eVhTFDalhYw2kat3IfAzvI=",
"dev": true
},
"resolve": {
"version": "1.3.3",
"resolved": "https://registry.npmjs.org/resolve/-/resolve-1.3.3.tgz",
"integrity": "sha1-ZVkHw0aahoDcLeOidaj91paR8OU=",
"dev": true,
"requires": {
"path-parse": "^1.0.5"
}
},
"resolve-dir": {
"version": "0.1.1",
"resolved": "https://registry.npmjs.org/resolve-dir/-/resolve-dir-0.1.1.tgz",
"integrity": "sha1-shklmlYC+sXFxJatiUpujMQwJh4=",
"dev": true,
"requires": {
"expand-tilde": "^1.2.2",
"global-modules": "^0.2.3"
}
},
"resolve-from": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-3.0.0.tgz",
"integrity": "sha1-six699nWiBvItuZTM17rywoYh0g=",
"dev": true
},
"resolve-url": {
"version": "0.2.1",
"resolved": "https://registry.npmjs.org/resolve-url/-/resolve-url-0.2.1.tgz",
"integrity": "sha1-LGN/53yJOv0qZj/iGqkIAGjiBSo=",
"dev": true
},
"restore-cursor": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-2.0.0.tgz",
"integrity": "sha1-n37ih/gv0ybU/RYpI9YhKe7g368=",
"dev": true,
"requires": {
"onetime": "^2.0.0",
"signal-exit": "^3.0.2"
}
},
"resumer": {
"version": "0.0.0",
"resolved": "https://registry.npmjs.org/resumer/-/resumer-0.0.0.tgz",
"integrity": "sha1-8ej0YeQGS6Oegq883CqMiT0HZ1k=",
"dev": true,
"requires": {
"through": "~2.3.4"
}
},
"ret": {
"version": "0.1.15",
"resolved": "https://registry.npmjs.org/ret/-/ret-0.1.15.tgz",
"integrity": "sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==",
"dev": true
},
"revalidator": {
"version": "0.1.8",
"resolved": "https://registry.npmjs.org/revalidator/-/revalidator-0.1.8.tgz",
"integrity": "sha1-/s5hv6DBtSoga9axgZgYS91SOjs=",
"dev": true
},
"right-align": {
"version": "0.1.3",
"resolved": "https://registry.npmjs.org/right-align/-/right-align-0.1.3.tgz",
"integrity": "sha1-YTObci/mo1FWiSENJOFMlhSGE+8=",
"dev": true,
"optional": true,
"requires": {
"align-text": "^0.1.1"
}
},
"rimraf": {
"version": "2.6.1",
"resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.1.tgz",
"integrity": "sha1-wjOOxkPfeht/5cVPqG9XQopV8z0=",
"dev": true,
"requires": {
"glob": "^7.0.5"
},
"dependencies": {
"glob": {
"version": "7.1.2",
"resolved": "https://registry.npmjs.org/glob/-/glob-7.1.2.tgz",
"integrity": "sha512-MJTUg1kjuLeQCJ+ccE4Vpa6kKVXkPYJ2mOCQyUuKLcLQsdrMCpBPUi8qVE6+YuaJkozeA9NusTAw3hLr8Xe5EQ==",
"dev": true,
"requires": {
"fs.realpath": "^1.0.0",
"inflight": "^1.0.4",
"inherits": "2",
"minimatch": "^3.0.4",
"once": "^1.3.0",
"path-is-absolute": "^1.0.0"
}
},
"minimatch": {
"version": "3.0.4",
"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
"integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
"dev": true,
"requires": {
"brace-expansion": "^1.1.7"
}
}
}
},
"run-node": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/run-node/-/run-node-1.0.0.tgz",
"integrity": "sha512-kc120TBlQ3mih1LSzdAJXo4xn/GWS2ec0l3S+syHDXP9uRr0JAT8Qd3mdMuyjqCzeZktgP3try92cEgf9Nks8A==",
"dev": true
},
"run-sequence": {
"version": "1.2.2",
"resolved": "https://registry.npmjs.org/run-sequence/-/run-sequence-1.2.2.tgz",
"integrity": "sha1-UJWgvr6YczsBQL0I3YDsAw3azes=",
"dev": true,
"requires": {
"chalk": "*",
"gulp-util": "*"
}
},
"rxjs": {
"version": "6.3.3",
"resolved": "https://registry.npmjs.org/rxjs/-/rxjs-6.3.3.tgz",
"integrity": "sha512-JTWmoY9tWCs7zvIk/CvRjhjGaOd+OVBM987mxFo+OW66cGpdKjZcpmc74ES1sB//7Kl/PAe8+wEakuhG4pcgOw==",
"dev": true,
"requires": {
"tslib": "^1.9.0"
}
},
"safe-buffer": {
"version": "5.0.1",
"resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.0.1.tgz",
"integrity": "sha1-0mPKVGls2KMGtcplUekt5XkY++c=",
"dev": true
},
"safe-regex": {
"version": "1.1.0",
"resolved": "http://registry.npmjs.org/safe-regex/-/safe-regex-1.1.0.tgz",
"integrity": "sha1-QKNmnzsHfR6UPURinhV91IAjvy4=",
"dev": true,
"requires": {
"ret": "~0.1.10"
}
},
"semaphore": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/semaphore/-/semaphore-1.1.0.tgz",
"integrity": "sha512-O4OZEaNtkMd/K0i6js9SL+gqy0ZCBMgUvlSqHKi4IBdjhe7wB8pwztUk1BbZ1fmrvpwFrPbHzqd2w5pTcJH6LA==",
"dev": true
},
"semver": {
"version": "4.3.6",
"resolved": "https://registry.npmjs.org/semver/-/semver-4.3.6.tgz",
"integrity": "sha1-MAvG4OhjdPe6YQaLWx7NV/xlMto=",
"dev": true
},
"semver-compare": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/semver-compare/-/semver-compare-1.0.0.tgz",
"integrity": "sha1-De4hahyUGrN+nvsXiPavxf9VN/w=",
"dev": true
},
"sequencify": {
"version": "0.0.7",
"resolved": "https://registry.npmjs.org/sequencify/-/sequencify-0.0.7.tgz",
"integrity": "sha1-kM/xnQLgcCf9dn9erT57ldHnOAw=",
"dev": true
},
"set-value": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/set-value/-/set-value-2.0.0.tgz",
"integrity": "sha512-hw0yxk9GT/Hr5yJEYnHNKYXkIA8mVJgd9ditYZCe16ZczcaELYYcfvaXesNACk2O8O0nTiPQcQhGUQj8JLzeeg==",
"dev": true,
"requires": {
"extend-shallow": "^2.0.1",
"is-extendable": "^0.1.1",
"is-plain-object": "^2.0.3",
"split-string": "^3.0.1"
},
"dependencies": {
"extend-shallow": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
"integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
"dev": true,
"requires": {
"is-extendable": "^0.1.0"
}
}
}
},
"shebang-command": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz",
"integrity": "sha1-RKrGW2lbAzmJaMOfNj/uXer98eo=",
"dev": true,
"requires": {
"shebang-regex": "^1.0.0"
}
},
"shebang-regex": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-1.0.0.tgz",
"integrity": "sha1-2kL0l0DAtC2yypcoVxyxkMmO/qM=",
"dev": true
},
"shelljs": {
"version": "0.3.0",
"resolved": "https://registry.npmjs.org/shelljs/-/shelljs-0.3.0.tgz",
"integrity": "sha1-NZbmMHp4FUT1kfN9phg2DzHbV7E=",
"dev": true
},
"sigmund": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/sigmund/-/sigmund-1.0.1.tgz",
"integrity": "sha1-P/IfGYytIXX587eBhT/ZTQ0ZtZA=",
"dev": true
},
"signal-exit": {
"version": "3.0.2",
"resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.2.tgz",
"integrity": "sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0=",
"dev": true
},
"simple-git": {
"version": "1.107.0",
"resolved": "https://registry.npmjs.org/simple-git/-/simple-git-1.107.0.tgz",
"integrity": "sha512-t4OK1JRlp4ayKRfcW6owrWcRVLyHRUlhGd0uN6ZZTqfDq8a5XpcUdOKiGRNobHEuMtNqzp0vcJNvhYWwh5PsQA==",
"dev": true,
"requires": {
"debug": "^4.0.1"
},
"dependencies": {
"debug": {
"version": "4.1.0",
"resolved": "https://registry.npmjs.org/debug/-/debug-4.1.0.tgz",
"integrity": "sha512-heNPJUJIqC+xB6ayLAMHaIrmN9HKa7aQO8MGqKpvCA+uJYVcvR6l5kgdrhRuwPFHU7P5/A1w0BjByPHwpfTDKg==",
"dev": true,
"requires": {
"ms": "^2.1.1"
}
},
"ms": {
"version": "2.1.1",
"resolved": "https://registry.npmjs.org/ms/-/ms-2.1.1.tgz",
"integrity": "sha512-tgp+dl5cGk28utYktBsrFqA7HKgrhgPsg6Z/EfhWI4gl1Hwq8B/GmY/0oXZ6nF8hDVesS/FpnYaD/kOWhYQvyg==",
"dev": true
}
}
},
"slash": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/slash/-/slash-2.0.0.tgz",
"integrity": "sha512-ZYKh3Wh2z1PpEXWr0MpSBZ0V6mZHAQfYevttO11c51CaWjGTaadiKZ+wVt1PbMlDV5qhMFslpZCemhwOK7C89A==",
"dev": true
},
"slice-ansi": {
"version": "0.0.4",
"resolved": "http://registry.npmjs.org/slice-ansi/-/slice-ansi-0.0.4.tgz",
"integrity": "sha1-7b+JA/ZvfOL46v1s7tZeJkyDGzU=",
"dev": true
},
"snapdragon": {
"version": "0.8.2",
"resolved": "https://registry.npmjs.org/snapdragon/-/snapdragon-0.8.2.tgz",
"integrity": "sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg==",
"dev": true,
"requires": {
"base": "^0.11.1",
"debug": "^2.2.0",
"define-property": "^0.2.5",
"extend-shallow": "^2.0.1",
"map-cache": "^0.2.2",
"source-map": "^0.5.6",
"source-map-resolve": "^0.5.0",
"use": "^3.1.0"
},
"dependencies": {
"define-property": {
"version": "0.2.5",
"resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz",
"integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=",
"dev": true,
"requires": {
"is-descriptor": "^0.1.0"
}
},
"extend-shallow": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
"integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
"dev": true,
"requires": {
"is-extendable": "^0.1.0"
}
}
}
},
"snapdragon-node": {
"version": "2.1.1",
"resolved": "https://registry.npmjs.org/snapdragon-node/-/snapdragon-node-2.1.1.tgz",
"integrity": "sha512-O27l4xaMYt/RSQ5TR3vpWCAB5Kb/czIcqUFOM/C4fYcLnbZUc1PkjTAMjof2pBWaSTwOUd6qUHcFGVGj7aIwnw==",
"dev": true,
"requires": {
"define-property": "^1.0.0",
"isobject": "^3.0.0",
"snapdragon-util": "^3.0.1"
},
"dependencies": {
"define-property": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz",
"integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=",
"dev": true,
"requires": {
"is-descriptor": "^1.0.0"
}
},
"is-accessor-descriptor": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz",
"integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==",
"dev": true,
"requires": {
"kind-of": "^6.0.0"
}
},
"is-data-descriptor": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz",
"integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==",
"dev": true,
"requires": {
"kind-of": "^6.0.0"
}
},
"is-descriptor": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz",
"integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==",
"dev": true,
"requires": {
"is-accessor-descriptor": "^1.0.0",
"is-data-descriptor": "^1.0.0",
"kind-of": "^6.0.2"
}
},
"isobject": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz",
"integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=",
"dev": true
},
"kind-of": {
"version": "6.0.2",
"resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.2.tgz",
"integrity": "sha512-s5kLOcnH0XqDO+FvuaLX8DDjZ18CGFk7VygH40QoKPUQhW4e2rvM0rwUq0t8IQDOwYSeLK01U90OjzBTme2QqA==",
"dev": true
}
}
},
"snapdragon-util": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/snapdragon-util/-/snapdragon-util-3.0.1.tgz",
"integrity": "sha512-mbKkMdQKsjX4BAL4bRYTj21edOf8cN7XHdYUJEe+Zn99hVEYcMvKPct1IqNe7+AZPirn8BCDOQBHQZknqmKlZQ==",
"dev": true,
"requires": {
"kind-of": "^3.2.0"
}
},
"sntp": {
"version": "0.2.4",
"resolved": "https://registry.npmjs.org/sntp/-/sntp-0.2.4.tgz",
"integrity": "sha1-+4hfGLDzqtGJ+CSGJTa87ux1CQA=",
"dev": true,
"optional": true,
"requires": {
"hoek": "0.9.x"
}
},
"source-map": {
"version": "0.5.6",
"resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.6.tgz",
"integrity": "sha1-dc449SvwczxafwwRjYEzSiu19BI=",
"dev": true
},
"source-map-resolve": {
"version": "0.5.2",
"resolved": "https://registry.npmjs.org/source-map-resolve/-/source-map-resolve-0.5.2.tgz",
"integrity": "sha512-MjqsvNwyz1s0k81Goz/9vRBe9SZdB09Bdw+/zYyO+3CuPk6fouTaxscHkgtE8jKvf01kVfl8riHzERQ/kefaSA==",
"dev": true,
"requires": {
"atob": "^2.1.1",
"decode-uri-component": "^0.2.0",
"resolve-url": "^0.2.1",
"source-map-url": "^0.4.0",
"urix": "^0.1.0"
}
},
"source-map-support": {
"version": "0.4.15",
"resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.4.15.tgz",
"integrity": "sha1-AyAt9lwG0r2MfsI2KhkwVv7407E=",
"dev": true,
"requires": {
"source-map": "^0.5.6"
}
},
"source-map-url": {
"version": "0.4.0",
"resolved": "https://registry.npmjs.org/source-map-url/-/source-map-url-0.4.0.tgz",
"integrity": "sha1-PpNdfd1zYxuXZZlW1VEo6HtQhKM=",
"dev": true
},
"sparkles": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/sparkles/-/sparkles-1.0.0.tgz",
"integrity": "sha1-Gsu/tZJDbRC76PeFt8xvgoFQEsM=",
"dev": true
},
"spdx-correct": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-1.0.2.tgz",
"integrity": "sha1-SzBz2TP/UfORLwOsVRlJikFQ20A=",
"dev": true,
"requires": {
"spdx-license-ids": "^1.0.2"
}
},
"spdx-expression-parse": {
"version": "1.0.4",
"resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-1.0.4.tgz",
"integrity": "sha1-m98vIOH0DtRH++JzJmGR/O1RYmw=",
"dev": true
},
"spdx-license-ids": {
"version": "1.2.2",
"resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-1.2.2.tgz",
"integrity": "sha1-yd96NCRZSt5r0RkA1ZZpbcBrrFc=",
"dev": true
},
"split-string": {
"version": "3.1.0",
"resolved": "https://registry.npmjs.org/split-string/-/split-string-3.1.0.tgz",
"integrity": "sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw==",
"dev": true,
"requires": {
"extend-shallow": "^3.0.0"
},
"dependencies": {
"extend-shallow": {
"version": "3.0.2",
"resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz",
"integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=",
"dev": true,
"requires": {
"assign-symbols": "^1.0.0",
"is-extendable": "^1.0.1"
}
},
"is-extendable": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz",
"integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==",
"dev": true,
"requires": {
"is-plain-object": "^2.0.4"
}
}
}
},
"sprintf-js": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz",
"integrity": "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=",
"dev": true
},
"stack-trace": {
"version": "0.0.10",
"resolved": "https://registry.npmjs.org/stack-trace/-/stack-trace-0.0.10.tgz",
"integrity": "sha1-VHxws0fo0ytOEI6hoqFZ5f3eGcA=",
"dev": true
},
"staged-git-files": {
"version": "1.1.2",
"resolved": "https://registry.npmjs.org/staged-git-files/-/staged-git-files-1.1.2.tgz",
"integrity": "sha512-0Eyrk6uXW6tg9PYkhi/V/J4zHp33aNyi2hOCmhFLqLTIhbgqWn5jlSzI+IU0VqrZq6+DbHcabQl/WP6P3BG0QA==",
"dev": true
},
"static-extend": {
"version": "0.1.2",
"resolved": "https://registry.npmjs.org/static-extend/-/static-extend-0.1.2.tgz",
"integrity": "sha1-YICcOcv/VTNyJv1eC1IPNB8ftcY=",
"dev": true,
"requires": {
"define-property": "^0.2.5",
"object-copy": "^0.1.0"
},
"dependencies": {
"define-property": {
"version": "0.2.5",
"resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz",
"integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=",
"dev": true,
"requires": {
"is-descriptor": "^0.1.0"
}
}
}
},
"stream-combiner": {
"version": "0.0.4",
"resolved": "https://registry.npmjs.org/stream-combiner/-/stream-combiner-0.0.4.tgz",
"integrity": "sha1-TV5DPBhSYd3mI8o/RMWGvPXErRQ=",
"dev": true,
"requires": {
"duplexer": "~0.1.1"
}
},
"stream-consume": {
"version": "0.1.0",
"resolved": "https://registry.npmjs.org/stream-consume/-/stream-consume-0.1.0.tgz",
"integrity": "sha1-pB6tGm1ggc63n2WwYZAbbY89HQ8=",
"dev": true
},
"string-argv": {
"version": "0.0.2",
"resolved": "https://registry.npmjs.org/string-argv/-/string-argv-0.0.2.tgz",
"integrity": "sha1-2sMECGkMIfPDYwo/86BYd73L1zY=",
"dev": true
},
"string-width": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz",
"integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=",
"dev": true,
"requires": {
"code-point-at": "^1.0.0",
"is-fullwidth-code-point": "^1.0.0",
"strip-ansi": "^3.0.0"
}
},
"string_decoder": {
"version": "0.10.31",
"resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz",
"integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=",
"dev": true
},
"stringify-object": {
"version": "3.3.0",
"resolved": "https://registry.npmjs.org/stringify-object/-/stringify-object-3.3.0.tgz",
"integrity": "sha512-rHqiFh1elqCQ9WPLIC8I0Q/g/wj5J1eMkyoiD6eoQApWHP0FtlK7rqnhmabL5VUY9JQCcqwwvlOaSuutekgyrw==",
"dev": true,
"requires": {
"get-own-enumerable-property-symbols": "^3.0.0",
"is-obj": "^1.0.1",
"is-regexp": "^1.0.0"
}
},
"stringstream": {
"version": "0.0.5",
"resolved": "https://registry.npmjs.org/stringstream/-/stringstream-0.0.5.tgz",
"integrity": "sha1-TkhM1N5aC7vuGORjB3EKioFiGHg=",
"dev": true,
"optional": true
},
"strip-ansi": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz",
"integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=",
"dev": true,
"requires": {
"ansi-regex": "^2.0.0"
}
},
"strip-bom": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-2.0.0.tgz",
"integrity": "sha1-YhmoVhZSBJHzV4i9vxRHqZx+aw4=",
"dev": true,
"requires": {
"is-utf8": "^0.2.0"
}
},
"strip-bom-buf": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/strip-bom-buf/-/strip-bom-buf-1.0.0.tgz",
"integrity": "sha1-HLRar1dTD0yvhsf3UXnSyaUd1XI=",
"dev": true,
"requires": {
"is-utf8": "^0.2.1"
}
},
"strip-bom-stream": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/strip-bom-stream/-/strip-bom-stream-3.0.0.tgz",
"integrity": "sha1-lWvMXYRDD2klapDtgjdlzYWOFZw=",
"dev": true,
"requires": {
"first-chunk-stream": "^2.0.0",
"strip-bom-buf": "^1.0.0"
},
"dependencies": {
"first-chunk-stream": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/first-chunk-stream/-/first-chunk-stream-2.0.0.tgz",
"integrity": "sha1-G97NuOCDwGZLkZRVgVd6Q6nzHXA=",
"dev": true,
"requires": {
"readable-stream": "^2.0.2"
}
},
"isarray": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
"integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=",
"dev": true
},
"readable-stream": {
"version": "2.3.3",
"resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.3.tgz",
"integrity": "sha512-m+qzzcn7KUxEmd1gMbchF+Y2eIUbieUaxkWtptyHywrX0rE8QEYqPC07Vuy4Wm32/xE16NcdBctb8S0Xe/5IeQ==",
"dev": true,
"requires": {
"core-util-is": "~1.0.0",
"inherits": "~2.0.3",
"isarray": "~1.0.0",
"process-nextick-args": "~1.0.6",
"safe-buffer": "~5.1.1",
"string_decoder": "~1.0.3",
"util-deprecate": "~1.0.1"
}
},
"safe-buffer": {
"version": "5.1.1",
"resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.1.tgz",
"integrity": "sha512-kKvNJn6Mm93gAczWVJg7wH+wGYWNrDHdWvpUmHyEsgCtIwwo3bqPtV4tR5tuPaUhTOo/kvhVwd8XwwOllGYkbg==",
"dev": true
},
"string_decoder": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.0.3.tgz",
"integrity": "sha512-4AH6Z5fzNNBcH+6XDMfA/BTt87skxqJlO0lAh3Dker5zThcAxG6mKz+iGu308UKoPPQ8Dcqx/4JhujzltRa+hQ==",
"dev": true,
"requires": {
"safe-buffer": "~5.1.0"
}
}
}
},
"strip-eof": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/strip-eof/-/strip-eof-1.0.0.tgz",
"integrity": "sha1-u0P/VZim6wXYm1n80SnJgzE2Br8=",
"dev": true
},
"strip-indent": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/strip-indent/-/strip-indent-1.0.1.tgz",
"integrity": "sha1-DHlipq3vp7vUrDZkYKY4VSrhoKI=",
"dev": true,
"requires": {
"get-stdin": "^4.0.1"
}
},
"strip-json-comments": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz",
"integrity": "sha1-PFMZQukIwml8DsNEhYwobHygpgo=",
"dev": true
},
"supports-color": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/supports-color/-/supports-color-2.0.0.tgz",
"integrity": "sha1-U10EXOa2Nj+kARcIRimZXp3zJMc=",
"dev": true
},
"symbol-observable": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/symbol-observable/-/symbol-observable-1.2.0.tgz",
"integrity": "sha512-e900nM8RRtGhlV36KGEU9k65K3mPb1WV70OdjfxlG2EAuM1noi/E/BaW/uMhL7bPEssK8QV57vN3esixjUvcXQ==",
"dev": true
},
"taffydb": {
"version": "2.6.2",
"resolved": "https://registry.npmjs.org/taffydb/-/taffydb-2.6.2.tgz",
"integrity": "sha1-fLy2S1oUG2ou/CxdLGe04VCyomg=",
"dev": true
},
"tape": {
"version": "2.3.0",
"resolved": "https://registry.npmjs.org/tape/-/tape-2.3.0.tgz",
"integrity": "sha1-Df7scJIn+8yRcKvn8EaWKycUMds=",
"dev": true,
"requires": {
"deep-equal": "~0.1.0",
"defined": "~0.0.0",
"inherits": "~2.0.1",
"jsonify": "~0.0.0",
"resumer": "~0.0.0",
"split": "~0.2.10",
"stream-combiner": "~0.0.2",
"through": "~2.3.4"
},
"dependencies": {
"split": {
"version": "0.2.10",
"resolved": "https://registry.npmjs.org/split/-/split-0.2.10.tgz",
"integrity": "sha1-Zwl8YB1pfOE2j0GPBs0gHPBSGlc=",
"dev": true,
"requires": {
"through": "2"
}
}
}
},
"through": {
"version": "2.3.8",
"resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz",
"integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=",
"dev": true
},
"through2": {
"version": "2.0.3",
"resolved": "https://registry.npmjs.org/through2/-/through2-2.0.3.tgz",
"integrity": "sha1-AARWmzfHx0ujnEPzzteNGtlBQL4=",
"dev": true,
"requires": {
"readable-stream": "^2.1.5",
"xtend": "~4.0.1"
},
"dependencies": {
"isarray": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
"integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=",
"dev": true
},
"readable-stream": {
"version": "2.2.9",
"resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.2.9.tgz",
"integrity": "sha1-z3jsb0ptHrQ9JkiMrJfwQudLf8g=",
"dev": true,
"requires": {
"buffer-shims": "~1.0.0",
"core-util-is": "~1.0.0",
"inherits": "~2.0.1",
"isarray": "~1.0.0",
"process-nextick-args": "~1.0.6",
"string_decoder": "~1.0.0",
"util-deprecate": "~1.0.1"
}
},
"string_decoder": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.0.1.tgz",
"integrity": "sha1-YuIA8DmVWmgQ2N8KM//A8BNmLZg=",
"dev": true,
"requires": {
"safe-buffer": "^5.0.1"
}
}
}
},
"tildify": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/tildify/-/tildify-1.2.0.tgz",
"integrity": "sha1-3OwD9V3Km3qj5bBPIYF+tW5jWIo=",
"dev": true,
"requires": {
"os-homedir": "^1.0.0"
}
},
"time-stamp": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/time-stamp/-/time-stamp-1.1.0.tgz",
"integrity": "sha1-dkpaEa9QVhkhsTPztE5hhofg9cM=",
"dev": true
},
"to-double-quotes": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/to-double-quotes/-/to-double-quotes-2.0.0.tgz",
"integrity": "sha1-qvIx1vqUiUn4GTAburRITYWI5Kc=",
"dev": true
},
"to-object-path": {
"version": "0.3.0",
"resolved": "https://registry.npmjs.org/to-object-path/-/to-object-path-0.3.0.tgz",
"integrity": "sha1-KXWIt7Dn4KwI4E5nL4XB9JmeF68=",
"dev": true,
"requires": {
"kind-of": "^3.0.2"
}
},
"to-regex": {
"version": "3.0.2",
"resolved": "https://registry.npmjs.org/to-regex/-/to-regex-3.0.2.tgz",
"integrity": "sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw==",
"dev": true,
"requires": {
"define-property": "^2.0.2",
"extend-shallow": "^3.0.2",
"regex-not": "^1.0.2",
"safe-regex": "^1.1.0"
},
"dependencies": {
"extend-shallow": {
"version": "3.0.2",
"resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz",
"integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=",
"dev": true,
"requires": {
"assign-symbols": "^1.0.0",
"is-extendable": "^1.0.1"
}
},
"is-extendable": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz",
"integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==",
"dev": true,
"requires": {
"is-plain-object": "^2.0.4"
}
}
}
},
"to-regex-range": {
"version": "2.1.1",
"resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-2.1.1.tgz",
"integrity": "sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=",
"dev": true,
"requires": {
"is-number": "^3.0.0",
"repeat-string": "^1.6.1"
},
"dependencies": {
"is-number": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz",
"integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=",
"dev": true,
"requires": {
"kind-of": "^3.0.2"
}
}
}
},
"to-single-quotes": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/to-single-quotes/-/to-single-quotes-2.0.1.tgz",
"integrity": "sha1-fMKRUfD18sQZRvEZ9ZMv5VQXASU=",
"dev": true
},
"tough-cookie": {
"version": "2.3.2",
"resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.3.2.tgz",
"integrity": "sha1-8IH3bkyFcg5sN6X6ztc3FQ2EByo=",
"dev": true,
"optional": true,
"requires": {
"punycode": "^1.4.1"
}
},
"trim-newlines": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/trim-newlines/-/trim-newlines-1.0.0.tgz",
"integrity": "sha1-WIeWa7WCpFA6QetST301ARgVphM=",
"dev": true
},
"tslib": {
"version": "1.9.3",
"resolved": "https://registry.npmjs.org/tslib/-/tslib-1.9.3.tgz",
"integrity": "sha512-4krF8scpejhaOgqzBEcGM7yDIEfi0/8+8zDRZhNZZ2kjmHJ4hv3zCbQWxoJGz1iw5U0Jl0nma13xzHXcncMavQ==",
"dev": true
},
"tunnel-agent": {
"version": "0.4.3",
"resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.4.3.tgz",
"integrity": "sha1-Y3PbdpCf5XDgjXNYM2Xtgop07us=",
"dev": true
},
"type-check": {
"version": "0.3.2",
"resolved": "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz",
"integrity": "sha1-WITKtRLPHTVeP7eE8wgEsrUg23I=",
"dev": true,
"requires": {
"prelude-ls": "~1.1.2"
}
},
"uglify-js": {
"version": "2.8.27",
"resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-2.8.27.tgz",
"integrity": "sha1-R3h/kSsPJC5bmENDvo416V9pTJw=",
"dev": true,
"optional": true,
"requires": {
"source-map": "~0.5.1",
"uglify-to-browserify": "~1.0.0",
"yargs": "~3.10.0"
}
},
"uglify-to-browserify": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/uglify-to-browserify/-/uglify-to-browserify-1.0.2.tgz",
"integrity": "sha1-bgkk1r2mta/jSeOabWMoUKD4grc=",
"dev": true,
"optional": true
},
"unc-path-regex": {
"version": "0.1.2",
"resolved": "https://registry.npmjs.org/unc-path-regex/-/unc-path-regex-0.1.2.tgz",
"integrity": "sha1-5z3T17DXxe2G+6xrCufYxqadUPo=",
"dev": true
},
"underscore": {
"version": "1.6.0",
"resolved": "https://registry.npmjs.org/underscore/-/underscore-1.6.0.tgz",
"integrity": "sha1-izixDKze9jM3uLJOT/htRa6lKag=",
"dev": true
},
"underscore-contrib": {
"version": "0.3.0",
"resolved": "https://registry.npmjs.org/underscore-contrib/-/underscore-contrib-0.3.0.tgz",
"integrity": "sha1-ZltmwkeD+PorGMn4y7Dix9SMJsc=",
"dev": true,
"requires": {
"underscore": "1.6.0"
}
},
"union-value": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/union-value/-/union-value-1.0.0.tgz",
"integrity": "sha1-XHHDTLW61dzr4+oM0IIHulqhrqQ=",
"dev": true,
"requires": {
"arr-union": "^3.1.0",
"get-value": "^2.0.6",
"is-extendable": "^0.1.1",
"set-value": "^0.4.3"
},
"dependencies": {
"arr-union": {
"version": "3.1.0",
"resolved": "https://registry.npmjs.org/arr-union/-/arr-union-3.1.0.tgz",
"integrity": "sha1-45sJrqne+Gao8gbiiK9jkZuuOcQ=",
"dev": true
},
"extend-shallow": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
"integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
"dev": true,
"requires": {
"is-extendable": "^0.1.0"
}
},
"set-value": {
"version": "0.4.3",
"resolved": "https://registry.npmjs.org/set-value/-/set-value-0.4.3.tgz",
"integrity": "sha1-fbCPnT0i3H945Trzw79GZuzfzPE=",
"dev": true,
"requires": {
"extend-shallow": "^2.0.1",
"is-extendable": "^0.1.1",
"is-plain-object": "^2.0.1",
"to-object-path": "^0.3.0"
}
}
}
},
"unique-stream": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/unique-stream/-/unique-stream-1.0.0.tgz",
"integrity": "sha1-1ZpKdUJ0R9mqbJHnAmP40mpLEEs=",
"dev": true
},
"universalify": {
"version": "0.1.1",
"resolved": "https://registry.npmjs.org/universalify/-/universalify-0.1.1.tgz",
"integrity": "sha1-+nG63UQ3r0wUiEHjs7Fl+enlkLc=",
"dev": true
},
"unset-value": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/unset-value/-/unset-value-1.0.0.tgz",
"integrity": "sha1-g3aHP30jNRef+x5vw6jtDfyKtVk=",
"dev": true,
"requires": {
"has-value": "^0.3.1",
"isobject": "^3.0.0"
},
"dependencies": {
"has-value": {
"version": "0.3.1",
"resolved": "https://registry.npmjs.org/has-value/-/has-value-0.3.1.tgz",
"integrity": "sha1-ex9YutpiyoJ+wKIHgCVlSEWZXh8=",
"dev": true,
"requires": {
"get-value": "^2.0.3",
"has-values": "^0.1.4",
"isobject": "^2.0.0"
},
"dependencies": {
"isobject": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/isobject/-/isobject-2.1.0.tgz",
"integrity": "sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=",
"dev": true,
"requires": {
"isarray": "1.0.0"
}
}
}
},
"has-values": {
"version": "0.1.4",
"resolved": "https://registry.npmjs.org/has-values/-/has-values-0.1.4.tgz",
"integrity": "sha1-bWHeldkd/Km5oCCJrThL/49it3E=",
"dev": true
},
"isarray": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
"integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=",
"dev": true
},
"isobject": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz",
"integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=",
"dev": true
}
}
},
"urix": {
"version": "0.1.0",
"resolved": "https://registry.npmjs.org/urix/-/urix-0.1.0.tgz",
"integrity": "sha1-2pN/emLiH+wf0Y1Js1wpNQZ6bHI=",
"dev": true
},
"urlgrey": {
"version": "0.4.0",
"resolved": "https://registry.npmjs.org/urlgrey/-/urlgrey-0.4.0.tgz",
"integrity": "sha1-8GU1cED7NcOzEdTl3DZITZbb6gY=",
"dev": true,
"requires": {
"tape": "2.3.0"
}
},
"use": {
"version": "3.1.1",
"resolved": "https://registry.npmjs.org/use/-/use-3.1.1.tgz",
"integrity": "sha512-cwESVXlO3url9YWlFW/TA9cshCEhtu7IKJ/p5soJ/gGpj7vbvFrAY/eIioQ6Dw23KjZhYgiIo8HOs1nQ2vr/oQ==",
"dev": true
},
"user-home": {
"version": "1.1.1",
"resolved": "https://registry.npmjs.org/user-home/-/user-home-1.1.1.tgz",
"integrity": "sha1-K1viOjK2Onyd640PKNSFcko98ZA=",
"dev": true
},
"util-deprecate": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
"integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=",
"dev": true
},
"utile": {
"version": "0.2.1",
"resolved": "https://registry.npmjs.org/utile/-/utile-0.2.1.tgz",
"integrity": "sha1-kwyI6ZCY1iIINMNWy9mncFItkNc=",
"dev": true,
"requires": {
"async": "~0.2.9",
"deep-equal": "*",
"i": "0.3.x",
"mkdirp": "0.x.x",
"ncp": "0.4.x",
"rimraf": "2.x.x"
},
"dependencies": {
"async": {
"version": "0.2.10",
"resolved": "https://registry.npmjs.org/async/-/async-0.2.10.tgz",
"integrity": "sha1-trvgsGdLnXGXCMo43owjfLUmw9E=",
"dev": true
}
}
},
"uuid": {
"version": "2.0.3",
"resolved": "https://registry.npmjs.org/uuid/-/uuid-2.0.3.tgz",
"integrity": "sha1-Z+LoY3lyFVMN/zGOW/nc6/1Hsho=",
"dev": true
},
"v8flags": {
"version": "2.1.1",
"resolved": "https://registry.npmjs.org/v8flags/-/v8flags-2.1.1.tgz",
"integrity": "sha1-qrGh+jDUX4jdMhFIh1rALAtV5bQ=",
"dev": true,
"requires": {
"user-home": "^1.1.1"
}
},
"validate-npm-package-license": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.1.tgz",
"integrity": "sha1-KAS6vnEq0zeUWaz74kdGqywwP7w=",
"dev": true,
"requires": {
"spdx-correct": "~1.0.0",
"spdx-expression-parse": "~1.0.0"
}
},
"vinyl": {
"version": "0.5.3",
"resolved": "https://registry.npmjs.org/vinyl/-/vinyl-0.5.3.tgz",
"integrity": "sha1-sEVbOPxeDPMNQyUTLkYZcMIJHN4=",
"dev": true,
"requires": {
"clone": "^1.0.0",
"clone-stats": "^0.0.1",
"replace-ext": "0.0.1"
}
},
"vinyl-fs": {
"version": "0.3.14",
"resolved": "https://registry.npmjs.org/vinyl-fs/-/vinyl-fs-0.3.14.tgz",
"integrity": "sha1-mmhRzhysHBzqX+hsCTHWIMLPqeY=",
"dev": true,
"requires": {
"defaults": "^1.0.0",
"glob-stream": "^3.1.5",
"glob-watcher": "^0.0.6",
"graceful-fs": "^3.0.0",
"mkdirp": "^0.5.0",
"strip-bom": "^1.0.0",
"through2": "^0.6.1",
"vinyl": "^0.4.0"
},
"dependencies": {
"clone": {
"version": "0.2.0",
"resolved": "https://registry.npmjs.org/clone/-/clone-0.2.0.tgz",
"integrity": "sha1-xhJqkK1Pctv1rNskPMN3JP6T/B8=",
"dev": true
},
"graceful-fs": {
"version": "3.0.11",
"resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-3.0.11.tgz",
"integrity": "sha1-dhPHeKGv6mLyXGMKCG1/Osu92Bg=",
"dev": true,
"requires": {
"natives": "^1.1.0"
}
},
"strip-bom": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-1.0.0.tgz",
"integrity": "sha1-hbiGLzhEtabV7IRnqTWYFzo295Q=",
"dev": true,
"requires": {
"first-chunk-stream": "^1.0.0",
"is-utf8": "^0.2.0"
}
},
"through2": {
"version": "0.6.5",
"resolved": "https://registry.npmjs.org/through2/-/through2-0.6.5.tgz",
"integrity": "sha1-QaucZ7KdVyCQcUEOHXp6lozTrUg=",
"dev": true,
"requires": {
"readable-stream": ">=1.0.33-1 <1.1.0-0",
"xtend": ">=4.0.0 <4.1.0-0"
}
},
"vinyl": {
"version": "0.4.6",
"resolved": "https://registry.npmjs.org/vinyl/-/vinyl-0.4.6.tgz",
"integrity": "sha1-LzVsh6VQolVGHza76ypbqL94SEc=",
"dev": true,
"requires": {
"clone": "^0.2.0",
"clone-stats": "^0.0.1"
}
}
}
},
"vow": {
"version": "0.4.16",
"resolved": "https://registry.npmjs.org/vow/-/vow-0.4.16.tgz",
"integrity": "sha1-u51U2TjV+AUg1linQOeoleMP7us=",
"dev": true
},
"vow-fs": {
"version": "0.3.6",
"resolved": "https://registry.npmjs.org/vow-fs/-/vow-fs-0.3.6.tgz",
"integrity": "sha1-LUxZviLivyYY3fWXq0uqkjvnIA0=",
"dev": true,
"requires": {
"glob": "^7.0.5",
"uuid": "^2.0.2",
"vow": "^0.4.7",
"vow-queue": "^0.4.1"
},
"dependencies": {
"glob": {
"version": "7.1.2",
"resolved": "https://registry.npmjs.org/glob/-/glob-7.1.2.tgz",
"integrity": "sha512-MJTUg1kjuLeQCJ+ccE4Vpa6kKVXkPYJ2mOCQyUuKLcLQsdrMCpBPUi8qVE6+YuaJkozeA9NusTAw3hLr8Xe5EQ==",
"dev": true,
"requires": {
"fs.realpath": "^1.0.0",
"inflight": "^1.0.4",
"inherits": "2",
"minimatch": "^3.0.4",
"once": "^1.3.0",
"path-is-absolute": "^1.0.0"
}
},
"minimatch": {
"version": "3.0.4",
"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
"integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
"dev": true,
"requires": {
"brace-expansion": "^1.1.7"
}
}
}
},
"vow-queue": {
"version": "0.4.2",
"resolved": "https://registry.npmjs.org/vow-queue/-/vow-queue-0.4.2.tgz",
"integrity": "sha1-5/4XFg4Vx8QYTRtmapvGThjjAYQ=",
"dev": true,
"requires": {
"vow": "~0.4.0"
}
},
"which": {
"version": "1.2.14",
"resolved": "https://registry.npmjs.org/which/-/which-1.2.14.tgz",
"integrity": "sha1-mofEN48D6CfOyvGs31bHNsAcFOU=",
"dev": true,
"requires": {
"isexe": "^2.0.0"
}
},
"window-size": {
"version": "0.1.0",
"resolved": "https://registry.npmjs.org/window-size/-/window-size-0.1.0.tgz",
"integrity": "sha1-VDjNLqk7IC76Ohn+iIeu58lPnJ0=",
"dev": true,
"optional": true
},
"winston": {
"version": "0.8.3",
"resolved": "https://registry.npmjs.org/winston/-/winston-0.8.3.tgz",
"integrity": "sha1-ZLar9M0Brcrv1QCTk7HY6L7BnbA=",
"dev": true,
"requires": {
"async": "0.2.x",
"colors": "0.6.x",
"cycle": "1.0.x",
"eyes": "0.1.x",
"isstream": "0.1.x",
"pkginfo": "0.3.x",
"stack-trace": "0.0.x"
},
"dependencies": {
"async": {
"version": "0.2.10",
"resolved": "https://registry.npmjs.org/async/-/async-0.2.10.tgz",
"integrity": "sha1-trvgsGdLnXGXCMo43owjfLUmw9E=",
"dev": true
},
"colors": {
"version": "0.6.2",
"resolved": "https://registry.npmjs.org/colors/-/colors-0.6.2.tgz",
"integrity": "sha1-JCP+ZnisDF2uiFLl0OW+CMmXq8w=",
"dev": true
},
"pkginfo": {
"version": "0.3.1",
"resolved": "https://registry.npmjs.org/pkginfo/-/pkginfo-0.3.1.tgz",
"integrity": "sha1-Wyn2qB9wcXFC4J52W76rl7T4HiE=",
"dev": true
}
}
},
"wordwrap": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz",
"integrity": "sha1-J1hIEIkUVqQXHI0CJkQa3pDLyus=",
"dev": true
},
"wrap-ansi": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-3.0.1.tgz",
"integrity": "sha1-KIoE2H7aXChuBg3+jxNc6NAH+Lo=",
"dev": true,
"requires": {
"string-width": "^2.1.1",
"strip-ansi": "^4.0.0"
},
"dependencies": {
"ansi-regex": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz",
"integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=",
"dev": true
},
"is-fullwidth-code-point": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
"integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=",
"dev": true
},
"string-width": {
"version": "2.1.1",
"resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz",
"integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==",
"dev": true,
"requires": {
"is-fullwidth-code-point": "^2.0.0",
"strip-ansi": "^4.0.0"
}
},
"strip-ansi": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz",
"integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=",
"dev": true,
"requires": {
"ansi-regex": "^3.0.0"
}
}
}
},
"wrappy": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
"integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=",
"dev": true
},
"xmlbuilder": {
"version": "3.1.0",
"resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-3.1.0.tgz",
"integrity": "sha1-LIaIjy1OrehQ+jjKf3Ij9yCVFuE=",
"dev": true,
"requires": {
"lodash": "^3.5.0"
},
"dependencies": {
"lodash": {
"version": "3.10.1",
"resolved": "https://registry.npmjs.org/lodash/-/lodash-3.10.1.tgz",
"integrity": "sha1-W/Rejkm6QYnhfUgnid/RW9FAt7Y=",
"dev": true
}
}
},
"xmlcreate": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/xmlcreate/-/xmlcreate-1.0.2.tgz",
"integrity": "sha1-+mv3YqYKQT+z3Y9LA8WyaSONMI8=",
"dev": true
},
"xtend": {
"version": "4.0.1",
"resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.1.tgz",
"integrity": "sha1-pcbVMr5lbiPbgg77lDofBJmNY68=",
"dev": true
},
"yallist": {
"version": "2.1.2",
"resolved": "https://registry.npmjs.org/yallist/-/yallist-2.1.2.tgz",
"integrity": "sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI=",
"dev": true
},
"yargs": {
"version": "3.10.0",
"resolved": "https://registry.npmjs.org/yargs/-/yargs-3.10.0.tgz",
"integrity": "sha1-9+572FfdfB0tOMDnTvvWgdFDH9E=",
"dev": true,
"optional": true,
"requires": {
"camelcase": "^1.0.2",
"cliui": "^2.1.0",
"decamelize": "^1.0.0",
"window-size": "0.1.0"
},
"dependencies": {
"camelcase": {
"version": "1.2.1",
"resolved": "https://registry.npmjs.org/camelcase/-/camelcase-1.2.1.tgz",
"integrity": "sha1-m7UwTS4LVmmLLHWLCKPqqdqlijk=",
"dev": true,
"optional": true
}
}
}
}
}
neo-async-2.6.1/package.json 0000664 0000000 0000000 00000003412 13466145133 0015710 0 ustar 00root root 0000000 0000000 {
"name": "neo-async",
"version": "2.6.1",
"description": "Neo-Async is thought to be used as a drop-in replacement for Async, it almost fully covers its functionality and runs faster ",
"main": "index.js",
"scripts": {
"test": "istanbul cover ./node_modules/.bin/_mocha --report lcovonly -- -R spec ./test --recursive",
"clean": "rm -rf coverage",
"cov:100": "grep Lines | perl -nle 'my ($l, $c, $p, @d) = split(/[\\s%]+/); exit(($p == 100) == 0)'"
},
"license": "MIT",
"keywords": "async, util",
"private": true,
"repository": {
"type": "git",
"url": "git@github.com:suguru03/neo-async.git"
},
"homepage": "https://github.com/suguru03/neo-async",
"files": [
"LICENSE",
"index.js",
"lib/async.js",
"lib/async.min.js",
"dist/async.js",
"dist/async.min.js"
],
"dependencies": {},
"devDependencies": {
"aigle": "^1.8.1",
"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": "^3.9.1",
"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",
"run-sequence": "^1.2.2"
},
"lint-staged": {
"*.{js,ts}": [
"prettier --write",
"git add"
]
},
"prettier": {
"printWidth": 100,
"singleQuote": true
}
}
neo-async-2.6.1/perf/ 0000775 0000000 0000000 00000000000 13466145133 0014356 5 ustar 00root root 0000000 0000000 neo-async-2.6.1/perf/README.md 0000664 0000000 0000000 00000003127 13466145133 0015640 0 ustar 00root root 0000000 0000000 # benchmark
The benchmark tool is using `benchmark.js` and `func-comparator`.
## How to execute
```bash
// execute all cases
$ node ./
// specify benchmark tool
$ node ./ -b benchmark // ['benchmark', 'func-comparator']
$ node ./ -b bench
$ node ./ --benchmark func
// specify function name
$ node ./ --target each // all `each` tasks
$ node ./ --target each:array // only `each:array` task
// specify times (only func-comparator)
$ node ./ -t 10
$ node ./ --times 10
```
## Sample
```bash
$ node ./ --target each
======================================
[async], v2.0.0-rc.4
[neo_async], v2.0.0_pre
======================================
[each:array] Comparating...
--------------------------------------
[benchmark] Executing...
[1] "neo_async" 7.30μs[1.00][1.00]
[2] "async" 22.0μs[0.332][3.01]
--------------------------------------
[func-comparator] Executing...
[1] "neo_async" 80.4μs[1.00][1.00]
[2] "async" 185μs[0.435][2.30]
======================================
[each:object] Comparating...
--------------------------------------
[benchmark] Executing...
[1] "neo_async" 14.6μs[1.00][1.00]
[2] "async" 32.0μs[0.456][2.19]
--------------------------------------
[func-comparator] Executing...
[1] "neo_async" 135μs[1.00][1.00]
[2] "async" 236μs[0.572][1.75]
======================================
[each:map] Comparating...
--------------------------------------
[benchmark] Executing...
[1] "neo_async" 9.44μs[1.00][1.00]
[2] "async" 31.7μs[0.297][3.36]
--------------------------------------
[func-comparator] Executing...
[1] "neo_async" 86.4μs[1.00][1.00]
[2] "async" 238μs[0.363][2.75]
```
neo-async-2.6.1/perf/benchmark/ 0000775 0000000 0000000 00000000000 13466145133 0016310 5 ustar 00root root 0000000 0000000 neo-async-2.6.1/perf/benchmark/index.js 0000664 0000000 0000000 00000002132 13466145133 0017753 0 ustar 00root root 0000000 0000000 'use strict';
var _ = require('lodash');
var Benchmark = require('benchmark');
module.exports = function(funcs) {
return function(callback) {
var suite = new Benchmark.Suite();
var total = {};
_.forEach(funcs, function(func, key) {
total[key] = {
count: 0,
time: 0
};
suite.add(key, {
defer: true,
fn: function(deferred) {
var start = process.hrtime();
func(function() {
var diff = process.hrtime(start);
total[key].time += (diff[0] * 1e9 + diff[1]) / 1000;
total[key].count++;
deferred.resolve();
});
}
});
});
suite
.on('complete', function() {
var result = _.chain(this)
.map(function(data) {
var name = data.name;
var time = total[name];
return {
name: name,
mean: time.time / time.count
};
})
.sortBy('mean')
.value();
callback(null, result);
})
.run({
async: true
});
};
};
neo-async-2.6.1/perf/config.js 0000664 0000000 0000000 00000075631 13466145133 0016175 0 ustar 00root root 0000000 0000000 'use strict';
var _ = require('lodash');
var limit = 4;
var current = 0;
var concurrency = 1;
var collection, iterator, tasks, test, worker, func, times;
module.exports = {
defaults: {
avaiable: true,
count: 100,
times: 500000
},
'each:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, callback) {
callback();
};
},
func: function(async, callback) {
async.each(collection, iterator, callback);
}
},
'each:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, callback) {
callback();
};
},
func: function(async, callback) {
async.each(collection, iterator, callback);
}
},
'each:set': {
setup: function(count) {
collection = createSetCollection(count);
iterator = function(n, callback) {
callback();
};
},
func: function(async, callback) {
async.each(collection, iterator, callback);
}
},
'each:map': {
setup: function(count) {
collection = createMapCollection(count);
iterator = function(n, callback) {
callback();
};
},
func: function(async, callback) {
async.each(collection, iterator, callback);
}
},
'eachSeries:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, callback) {
process.nextTick(callback);
};
},
func: function(async, callback) {
async.eachSeries(collection, iterator, callback);
}
},
'eachSeries:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, callback) {
process.nextTick(callback);
};
},
func: function(async, callback) {
async.eachSeries(collection, iterator, callback);
}
},
'eachLimit:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, callback) {
process.nextTick(callback);
};
},
func: function(async, callback) {
async.eachLimit(collection, limit, iterator, callback);
}
},
'eachLimit:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, callback) {
process.nextTick(callback);
};
},
func: function(async, callback) {
async.eachLimit(collection, limit, iterator, callback);
}
},
'eachOf:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, key, callback) {
callback();
};
},
func: function(async, callback) {
async.eachOf(collection, iterator, callback);
}
},
'eachOf:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, key, callback) {
callback();
};
},
func: function(async, callback) {
async.eachOf(collection, iterator, callback);
}
},
'eachOfSeries:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, key, callback) {
process.nextTick(callback);
};
},
func: function(async, callback) {
async.eachOfSeries(collection, iterator, callback);
}
},
'eachOfSeries:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, key, callback) {
process.nextTick(callback);
};
},
func: function(async, callback) {
async.eachOfSeries(collection, iterator, callback);
}
},
'eachOfLimit:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, key, callback) {
process.nextTick(callback);
};
},
func: function(async, callback) {
async.eachOfLimit(collection, limit, iterator, callback);
}
},
'eachOfLimit:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, key, callback) {
process.nextTick(callback);
};
},
func: function(async, callback) {
async.eachOfLimit(collection, limit, iterator, callback);
}
},
'map:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, callback) {
callback(null, n);
};
},
func: function(async, callback) {
async.map(collection, iterator, callback);
}
},
'map:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, callback) {
callback(null, n);
};
},
func: function(async, callback) {
async.map(collection, iterator, callback);
}
},
'mapSeries:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, n);
});
};
},
func: function(async, callback) {
async.mapSeries(collection, iterator, callback);
}
},
'mapSeries:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, n);
});
};
},
func: function(async, callback) {
async.mapSeries(collection, iterator, callback);
}
},
'mapLimit:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, n);
});
};
},
func: function(async, callback) {
async.mapLimit(collection, limit, iterator, callback);
}
},
'mapLimit:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, n);
});
};
},
func: function(async, callback) {
async.mapLimit(collection, limit, iterator, callback);
}
},
'mapValues:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, k, callback) {
callback(null, n);
};
},
func: function(async, callback) {
async.mapValues(collection, iterator, callback);
}
},
'mapValues:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, k, callback) {
callback(null, n);
};
},
func: function(async, callback) {
async.mapValues(collection, iterator, callback);
}
},
'mapValuesSeries:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, k, callback) {
process.nextTick(function() {
callback(null, n);
});
};
},
func: function(async, callback) {
async.mapValuesSeries(collection, iterator, callback);
}
},
'mapValuesSeries:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, k, callback) {
process.nextTick(function() {
callback(null, n);
});
};
},
func: function(async, callback) {
async.mapValuesSeries(collection, iterator, callback);
}
},
'mapValuesLimit:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, k, callback) {
process.nextTick(function() {
callback(null, n);
});
};
},
func: function(async, callback) {
async.mapValuesLimit(collection, limit, iterator, callback);
}
},
'mapValuesLimit:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, k, callback) {
process.nextTick(function() {
callback(null, n);
});
};
},
func: function(async, callback) {
async.mapValuesLimit(collection, limit, iterator, callback);
}
},
'filter:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, callback) {
callback(null, n % 2);
};
},
func: function(async, callback) {
async.filter(collection, iterator, callback);
}
},
'filter:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, callback) {
callback(null, n % 2);
};
},
func: function(async, callback) {
async.filter(collection, iterator, callback);
}
},
'filterSeries:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, n % 2);
});
};
},
func: function(async, callback) {
async.filterSeries(collection, iterator, callback);
}
},
'filterSeries:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, n % 2);
});
};
},
func: function(async, callback) {
async.filterSeries(collection, iterator, callback);
}
},
'filterLimit:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, n % 2);
});
};
},
func: function(async, callback) {
async.filterLimit(collection, limit, iterator, callback);
}
},
'filterLimit:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, n % 2);
});
};
},
func: function(async, callback) {
async.filterLimit(collection, limit, iterator, callback);
}
},
'reject:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, callback) {
callback(null, n % 2);
};
},
func: function(async, callback) {
async.reject(collection, iterator, callback);
}
},
'reject:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, callback) {
callback(null, n % 2);
};
},
func: function(async, callback) {
async.reject(collection, iterator, callback);
}
},
'rejectSeries:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, n % 2);
});
};
},
func: function(async, callback) {
async.rejectSeries(collection, iterator, callback);
}
},
'rejectSeries:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, n % 2);
});
};
},
func: function(async, callback) {
async.rejectSeries(collection, iterator, callback);
}
},
'rejectLimit:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, n % 2);
});
};
},
func: function(async, callback) {
async.rejectLimit(collection, limit, iterator, callback);
}
},
'rejectLimit:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, n % 2);
});
};
},
func: function(async, callback) {
async.rejectLimit(collection, limit, iterator, callback);
}
},
'detect:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, callback) {
callback(null, false);
};
},
func: function(async, callback) {
async.detect(collection, iterator, callback);
}
},
'detect:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, callback) {
callback(null, false);
};
},
func: function(async, callback) {
async.detect(collection, iterator, callback);
}
},
'detectSeries:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, false);
});
};
},
func: function(async, callback) {
async.detectSeries(collection, iterator, callback);
}
},
'detectSeries:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, false);
});
};
},
func: function(async, callback) {
async.detectSeries(collection, iterator, callback);
}
},
'detectLimit:array': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, false);
});
};
},
func: function(async, callback) {
async.detectLimit(collection, limit, iterator, callback);
}
},
'reduce:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(result, n, callback) {
process.nextTick(function() {
callback(null, result + n);
});
};
},
func: function(async, callback) {
async.reduce(collection, 0, iterator, callback);
}
},
'reduce:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(result, n, callback) {
process.nextTick(function() {
callback(null, result + n);
});
};
},
func: function(async, callback) {
async.reduce(collection, 0, iterator, callback);
}
},
'reduceRight:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(result, n, callback) {
process.nextTick(function() {
callback(null, result + n);
});
};
},
func: function(async, callback) {
async.reduceRight(collection, 0, iterator, callback);
}
},
'reduceRight:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(result, n, callback) {
process.nextTick(function() {
callback(null, result + n);
});
};
},
func: function(async, callback) {
async.reduceRight(collection, 0, iterator, callback);
}
},
'transform:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(result, n, index, callback) {
result[index] = n;
callback();
};
},
func: function(async, callback) {
async.transform(collection, iterator, callback);
}
},
'transform:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(result, n, index, callback) {
result[index] = n;
callback();
};
},
func: function(async, callback) {
async.transform(collection, iterator, callback);
}
},
'sortBy:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, callback) {
callback(null, n);
};
},
func: function(async, callback) {
async.sortBy(collection, iterator, callback);
}
},
'some:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, callback) {
callback(null, false);
};
},
func: function(async, callback) {
async.some(collection, iterator, callback);
}
},
'some:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, callback) {
callback(null, false);
};
},
func: function(async, callback) {
async.some(collection, iterator, callback);
}
},
'someSeries:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, false);
});
};
},
func: function(async, callback) {
async.someSeries(collection, iterator, callback);
}
},
'someSeries:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, false);
});
};
},
func: function(async, callback) {
async.someSeries(collection, iterator, callback);
}
},
'someLimit:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, false);
});
};
},
func: function(async, callback) {
async.someLimit(collection, limit, iterator, callback);
}
},
'someLimit:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, false);
});
};
},
func: function(async, callback) {
async.someLimit(collection, limit, iterator, callback);
}
},
'every:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, callback) {
callback(null, true);
};
},
func: function(async, callback) {
async.every(collection, iterator, callback);
}
},
'every:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, callback) {
callback(null, true);
};
},
func: function(async, callback) {
async.every(collection, iterator, callback);
}
},
'everySeries:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, true);
});
};
},
func: function(async, callback) {
async.everySeries(collection, iterator, callback);
}
},
'everySeries:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, true);
});
};
},
func: function(async, callback) {
async.everySeries(collection, iterator, callback);
}
},
'everyLimit:array': {
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, true);
});
};
},
func: function(async, callback) {
async.everyLimit(collection, limit, iterator, callback);
}
},
'everyLimit:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, true);
});
};
},
func: function(async, callback) {
async.everyLimit(collection, limit, iterator, callback);
}
},
'concat:array': {
times: 100000,
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, n);
});
};
},
func: function(async, callback) {
async.concat(collection, iterator, callback);
}
},
'concat:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, n);
});
};
},
func: function(async, callback) {
async.concat(collection, iterator, callback);
}
},
'concatSeries:array': {
times: 100000,
setup: function(count) {
collection = createArrayCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, n);
});
};
},
func: function(async, callback) {
async.concatSeries(collection, iterator, callback);
}
},
'concatSeries:object': {
setup: function(count) {
collection = createObjectCollection(count);
iterator = function(n, callback) {
process.nextTick(function() {
callback(null, n);
});
};
},
func: function(async, callback) {
async.concatSeries(collection, iterator, callback);
}
},
'parallel:array': {
setup: function(count) {
tasks = _.times(count, function(n) {
return function(done) {
done(null, n);
};
});
},
func: function(async, callback) {
async.parallel(tasks, callback);
}
},
'parallel:object': {
setup: function(count) {
tasks = _.mapValues(_.times(count, function(n) {
return function(done) {
process.nextTick(function() {
done(null, n);
});
};
}));
},
func: function(async, callback) {
async.parallel(tasks, callback);
}
},
'series:array': {
setup: function(count) {
tasks = _.times(count, function(n) {
return function(next) {
process.nextTick(function() {
next(null, n);
});
};
});
},
func: function(async, callback) {
async.series(tasks, callback);
}
},
'series:object': {
setup: function(count) {
tasks = _.mapValues(_.times(count, function(n) {
return function(next) {
process.nextTick(function() {
next(null, n);
});
};
}));
},
func: function(async, callback) {
async.series(tasks, callback);
}
},
'parallelLimit:array': {
setup: function(count) {
tasks = _.times(count, function(n) {
return function(done) {
process.nextTick(function() {
done(null, n);
});
};
});
},
func: function(async, callback) {
async.parallelLimit(tasks, limit, callback);
}
},
'parallelLimit:object': {
setup: function(count) {
tasks = _.mapValues(_.times(count, function(n) {
return function(done) {
process.nextTick(function() {
done(null, n);
});
};
}));
},
func: function(async, callback) {
async.parallelLimit(tasks, limit, callback);
}
},
'waterfall:simple': {
setup: function(count) {
tasks = _.times(count, function(n) {
if (n === 0) {
return function(done) {
process.nextTick(function() {
done(null, n);
});
};
}
return function(arg, done) {
process.nextTick(function() {
done(null, n);
});
};
});
},
func: function(async, callback) {
async.waterfall(tasks, callback);
}
},
'waterfall:multiple': {
setup: function(count) {
var argMax = 10;
tasks = _.times(count, function(n) {
return function() {
var done = _.last(arguments);
var args = Array((arguments.length + 1) % argMax);
if (args.length) {
args[args.length - 1] = n;
process.nextTick(function() {
done.apply(null, args);
});
} else {
process.nextTick(done);
}
};
});
},
func: function(async, callback) {
async.waterfall(tasks, callback);
}
},
'whilst': {
setup: function(count) {
test = function() {
return current++ < count;
};
iterator = function(callback) {
process.nextTick(callback);
};
},
func: function(async, callback) {
current = 0;
async.whilst(test, iterator, callback);
}
},
'doWhilst': {
setup: function(count) {
test = function() {
return ++current < count;
};
iterator = function(callback) {
process.nextTick(callback);
};
},
func: function(async, callback) {
current = 0;
async.doWhilst(iterator, test, callback);
}
},
'until': {
setup: function(count) {
test = function() {
return current++ === count;
};
iterator = function(callback) {
process.nextTick(callback);
};
},
func: function(async, callback) {
current = 0;
async.until(test, iterator, callback);
}
},
'doUntil': {
setup: function(count) {
test = function() {
return current++ === count;
};
iterator = function(callback) {
process.nextTick(callback);
};
},
func: function(async, callback) {
current = 0;
async.doUntil(iterator, test, callback);
}
},
'during': {
setup: function(count) {
test = function(callback) {
callback(null, ++current < count);
};
iterator = function(callback) {
callback();
};
},
func: function(async, callback) {
current = 0;
async.during(test, iterator, callback);
}
},
'doDuring': {
setup: function(count) {
test = function(callback) {
callback(null, ++current < count);
};
iterator = function(callback) {
callback();
};
},
func: function(async, callback) {
current = 0;
async.doDuring(iterator, test, callback);
}
},
'forever': {
setup: function(count) {
iterator = function(callback) {
callback(++current === count);
};
},
func: function(async, callback) {
current = 0;
async.forever(iterator, function() {
callback();
});
}
},
'compose': {
setup: function(count) {
tasks = _.times(count, function(n) {
return function(sum, done) {
done(null, sum + n);
};
});
},
func: function(async, callback) {
async.compose.apply(async, tasks)(0, callback);
}
},
'seq': {
setup: function(count) {
tasks = _.times(count, function(n) {
return function(sum, done) {
done(null, sum + n);
};
});
},
func: function(async, callback) {
async.seq.apply(async, tasks)(0, callback);
}
},
'apply': {
setup: function() {
func = function(arg1, callback) {
callback();
};
},
func: function(async, callback) {
async.apply(func, 1)(callback);
}
},
'applyEach': {
setup: function(count) {
tasks = _.times(count, function() {
return function(num, done) {
done();
};
});
},
func: function(async, callback) {
async.applyEach(tasks, 0, callback);
}
},
'applyEach:partial': {
setup: function(count) {
tasks = _.times(count, function() {
return function(num, done) {
done();
};
});
},
func: function(async, callback) {
async.applyEach(tasks)(0, callback);
}
},
'applyEachSeries': {
setup: function(count) {
tasks = _.times(count, function() {
return function(num, done) {
done();
};
});
},
func: function(async, callback) {
async.applyEachSeries(tasks, 0, callback);
}
},
'applyEachSeries:partial': {
setup: function(count) {
tasks = _.times(count, function() {
return function(num, done) {
done();
};
});
},
func: function(async, callback) {
async.applyEachSeries(tasks, 0, callback);
}
},
'queue': {
times: 1000,
setup: function() {
worker = function(data, callback) {
callback();
};
},
func: function(async, callback) {
var q = async.queue(worker, concurrency);
q.drain = function() {
callback();
};
_.times(1000, function(n) {
q.push(n, function() {});
});
}
},
'priorityQueue': {
times: 2000,
setup: function() {
worker = function(data, callback) {
callback();
};
},
func: function(async, callback) {
var q = async.priorityQueue(worker, concurrency);
q.drain = function() {
callback();
};
var max = 100;
_.times(max, function(n) {
q.push(n, max - n, function() {});
});
}
},
'times': {
setup: function(count) {
times = count;
iterator = function(n, done) {
done(null, n);
};
},
func: function(async, callback) {
async.times(times, iterator, callback);
}
},
'timesSeries': {
setup: function(count) {
times = count;
iterator = function(n, done) {
process.nextTick(function() {
done(null, n);
});
};
},
func: function(async, callback) {
async.timesSeries(times, iterator, callback);
}
},
'timesLimit': {
setup: function(count) {
times = count;
iterator = function(n, done) {
process.nextTick(function() {
done(null, n);
});
};
},
func: function(async, callback) {
async.timesLimit(times, limit, iterator, callback);
}
},
'auto': {
setup: function() {
tasks = {
task1: ['task2', function(results, callback) {
callback();
}],
task2: ['task3', function(results, callback) {
callback();
}],
task3: ['task5', function(results, callback) {
callback();
}],
task4: ['task1', 'task2', 'task3', 'task5', 'task6', 'task7', function(results, callback) {
callback();
}],
task5: function(callback) {
callback();
},
task6: ['task7', function(results, callback) {
callback();
}],
task7: function(callback) {
callback();
}
};
},
func: function(async, callback) {
async.auto(tasks, callback);
}
}
};
function createArrayCollection(count) {
return _.shuffle(_.times(count));
}
function createObjectCollection(count) {
return _.mapValues(_.shuffle(_.times(count)));
}
function createSetCollection(count) {
var set = new Set();
_.forOwn(createArrayCollection(count), function(v) {
set.add(v);
});
return set;
}
function createMapCollection(count) {
var map = new Map();
_.forOwn(createObjectCollection(count), function(v, k) {
map.set(k, v);
});
return map;
}
neo-async-2.6.1/perf/func-comparator/ 0000775 0000000 0000000 00000000000 13466145133 0017456 5 ustar 00root root 0000000 0000000 neo-async-2.6.1/perf/func-comparator/index.js 0000664 0000000 0000000 00000001172 13466145133 0021124 0 ustar 00root root 0000000 0000000 'use strict';
var _ = require('lodash');
var Comparator = require('func-comparator').Comparator;
module.exports = function(funcs, times) {
return function(callback) {
new Comparator()
.set(funcs)
.async()
.times(times)
.start()
.result(function(err, res) {
if (err) {
return callback(err);
}
var result = _.chain(res)
.map(function(data, name) {
return {
name: name,
mean: data.average
};
})
.sortBy('mean')
.value();
callback(null, result);
});
};
};
neo-async-2.6.1/perf/index.js 0000664 0000000 0000000 00000004671 13466145133 0016033 0 ustar 00root root 0000000 0000000 'use strict';
var _ = require('lodash');
var argv = require('minimist')(process.argv.slice(2));
var benchmark = argv.b || argv.benchmark; // ['benchmark', 'func-comparator'], -b func-comparator
var count = argv.c || argv.count;
var times = argv.t || argv.times;
var target = argv.target; // -t
var benchmarks = _.filter([
'benchmark',
'func-comparator'
], function(name) {
return benchmark ? RegExp(benchmark).test(name) : name;
});
benchmarks = _.transform(benchmarks, function(result, name) {
result[name] = require('./' + name);
}, {});
var async = require('../');
var functions = {
async: require('async'),
neo_async: async
};
functions.async.VERSION = require('async/package.json').version;
console.log('======================================');
_.forOwn(functions, function(obj, key) {
console.log('[%s], v%s', key, obj.VERSION);
});
var config = require('./config');
var defaults = config.defaults;
var tasks = _.omit(config, 'defaults');
if (target) {
var reg = new RegExp('^' + target + '$');
tasks = _.pickBy(tasks, function(obj, name) {
return reg.test(name) || reg.test(_.first(name.split(':')));
});
}
async.eachSeries(tasks, function(task, name, done) {
var avaiable = task.avaiable === undefined ? defaults.avaiable : task.avaiable;
if (!avaiable) {
return done();
}
var _count = count || _.get(task, 'count', defaults.count);
var _times = times || _.get(task, 'times', defaults.times);
var setup = _.get(task, 'setup', _.noop);
setup(_count);
console.log('======================================');
console.log('[' + name + '] Comparating... ');
var func = _.get(task, 'func', defaults.func);
async.eachSeries(benchmarks, function(benchmarker, benchmark, next) {
var funcs = _.mapValues(functions, function(async) {
return function(callback) {
func(async, callback);
};
});
console.log('--------------------------------------');
console.log('[%s] Executing...', benchmark);
benchmarker(funcs, _times)(function(err, res) {
if (err) {
return next(err);
}
_.forEach(res, function(data, index, array) {
var name = data.name;
var mean = data.mean;
var diff = (_.first(array).mean) / mean;
var rate = mean / (_.first(array).mean);
console.log('[%d] "%s" %sμs[%s][%s]', ++index, name, mean.toPrecision(3), diff.toPrecision(3), rate.toPrecision(3));
});
next();
});
}, done);
});
neo-async-2.6.1/test/ 0000775 0000000 0000000 00000000000 13466145133 0014401 5 ustar 00root root 0000000 0000000 neo-async-2.6.1/test/collections/ 0000775 0000000 0000000 00000000000 13466145133 0016717 5 ustar 00root root 0000000 0000000 neo-async-2.6.1/test/collections/test.concat.js 0000664 0000000 0000000 00000107752 13466145133 0021516 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var domain = require('domain');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var config = require('../config');
var async = global.async || require('../../');
var delay = config.delay;
var util = require('../util');
function concatIterator(order) {
return function(value, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
order.push(value);
var array = [];
while (num > 0) {
array.push(num--);
}
callback(null, array);
}, num * delay);
};
}
function concatIteratorWithKey(order) {
return function(value, key, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
order.push([value, key]);
var array = [];
while (num > 0) {
array.push(num--);
}
callback(null, array);
}, num * delay);
};
}
parallel('#concat', function() {
it('should execute iterator by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2];
async.concat(collection, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3, 2, 1, 2, 1]);
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should execute iterator by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2];
async.concat(collection, concatIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3, 2, 1, 2, 1]);
assert.deepStrictEqual(order, [
[1, 0],
[2, 2],
[3, 1]
]);
done();
});
});
it('should execute iterator by collection of object', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2
};
async.concat(collection, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3, 2, 1, 2, 1]);
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should execute iterator by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2
};
async.concat(collection, concatIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3, 2, 1, 2, 1]);
assert.deepStrictEqual(order, [
[1, 'a'],
[2, 'c'],
[3, 'b']
]);
done();
});
});
it('should execute iterator by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(3);
set.add(2);
async.concat(set, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3, 2, 1, 2, 1]);
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should execute iterator by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(3);
set.add(2);
async.concat(set, concatIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3, 2, 1, 2, 1]);
assert.deepStrictEqual(order, [
[1, 0],
[2, 2],
[3, 1]
]);
done();
});
});
it('should work even if the size is decreased', function(done) {
var order = [];
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.concat(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next();
};
async.concat(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 3);
map.set('c', 2);
async.concat(map, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3, 2, 1, 2, 1]);
assert.deepStrictEqual(order, [
['a', 1],
['c', 2],
['b', 3]
]);
done();
});
});
it('should execute iterator by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 3);
map.set('c', 2);
async.concat(map, concatIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3, 2, 1, 2, 1]);
assert.deepStrictEqual(order, [
[['a', 1], 0],
[['c', 2], 2],
[['b', 3], 1]
]);
done();
});
});
it('should execute iterator without binding', function(done) {
var order = [];
var collection = {
a: 1.5,
b: 3.5,
c: 2.5
};
async.concat(collection, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1.5, 0.5, 3.5, 2.5, 1.5, 0.5, 2.5, 1.5, 0.5]);
assert.deepStrictEqual(order, [1.5, 2.5, 3.5]);
done();
}, Math);
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, num);
}, num * delay);
};
async.concat(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 2]);
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = {};
async.concat(array, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should execute with an array of falthy', function(done) {
var array = [null, undefined, 0, ''];
async.concat(array, function(value, done) {
done(null, value);
}, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, array);
done();
});
});
it('should return an empty array if iterator does not pass the second argument', function(done) {
var array = [1, 2, 3];
async.concat(array, function(value, done) {
done();
}, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, []);
done();
});
});
it('should return an array of undefined if iterator passes the second argument', function(done) {
var array = [1, 2, 3];
async.concat(array, function(value, done) {
done(null, undefined);
}, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [undefined, undefined, undefined]);
done();
});
});
it('should pass multiple arguments', function(done) {
async.concat([1], function(value, done) {
done(null, 1, 2, 3);
}, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [1, 2, 3]);
done();
});
});
it('should not pass undefined if the second argument is empty', function(done) {
async.concat([1, 2], function(value, done) {
done();
}, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, []);
done();
});
});
it('should avoid double callback', function(done) {
var called = false;
async.concat([1, 2], function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
}
done();
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = [];
async.concat(object, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.concat(function() {}, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.concat(undefined, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.concat(null, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
});
parallel('#concatSeries', function() {
it('should execute iterator by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2];
async.concatSeries(collection, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3, 2, 1, 2, 1]);
assert.deepStrictEqual(order, [1, 3, 2]);
done();
});
});
it('should execute iterator by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2];
async.concatSeries(collection, concatIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3, 2, 1, 2, 1]);
assert.deepStrictEqual(order, [
[1, 0],
[3, 1],
[2, 2]
]);
done();
});
});
it('should execute iterator by collection of object', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2
};
async.concatSeries(collection, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3, 2, 1, 2, 1]);
assert.deepStrictEqual(order, [1, 3, 2]);
done();
});
});
it('should execute iterator by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2
};
async.concatSeries(collection, concatIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3, 2, 1, 2, 1]);
assert.deepStrictEqual(order, [
[1, 'a'],
[3, 'b'],
[2, 'c']
]);
done();
});
});
it('should execute iterator to series by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(3);
set.add(2);
async.concatSeries(set, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3, 2, 1, 2, 1]);
assert.deepStrictEqual(order, [1, 3, 2]);
done();
});
});
it('should execute iterator to series by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(3);
set.add(2);
async.concatSeries(set, concatIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3, 2, 1, 2, 1]);
assert.deepStrictEqual(order, [
[1, 0],
[3, 1],
[2, 2]
]);
done();
});
});
it('should work even if the size is decreased', function(done) {
var order = [];
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.concatSeries(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next();
};
async.concatSeries(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator to series by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 3);
map.set('c', 2);
async.concatSeries(map, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3, 2, 1, 2, 1]);
assert.deepStrictEqual(order, [
['a', 1],
['b', 3],
['c', 2]
]);
done();
});
});
it('should execute iterator to series by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 3);
map.set('c', 2);
async.concatSeries(map, concatIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3, 2, 1, 2, 1]);
assert.deepStrictEqual(order, [
[['a', 1], 0],
[['b', 3], 1],
[['c', 2], 2]
]);
done();
});
});
it('should execute iterator without binding', function(done) {
var order = [];
var collection = {
a: 1.5,
b: 3.5,
c: 2.5
};
async.concatSeries(collection, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1.5, 0.5, 3.5, 2.5, 1.5, 0.5, 2.5, 1.5, 0.5]);
assert.deepStrictEqual(order, [1.5, 3.5, 2.5]);
done();
}, Math);
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = {
a: 1,
b: 3,
c: 2
};
var iterator = function(n, key, callback) {
callback(null, n);
};
async.concatSeries(collection, iterator, function(err, result) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.deepStrictEqual(result, [1, 3, 2]);
done();
});
sync = false;
});
it('should execute with an array of falthy', function(done) {
var array = [null, undefined, 0, ''];
async.concatSeries(array, function(value, done) {
done(null, value);
}, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, array);
done();
});
});
it('should return an empty array if iterator does not pass the second argument', function(done) {
var array = [1, 2, 3];
async.concatSeries(array, function(value, done) {
done();
}, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, []);
done();
});
});
it('should return an array of undefined if iterator passes the second argument', function(done) {
var array = [1, 2, 3];
async.concatSeries(array, function(value, done) {
done(null, undefined);
}, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [undefined, undefined, undefined]);
done();
});
});
it('should pass multiple arguments', function(done) {
async.concatSeries([1], function(value, done) {
done(null, 1, 2, 3);
}, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [1, 2, 3]);
done();
});
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, num);
}, num * delay);
};
async.concatSeries(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3]);
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 4);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.concatSeries(collection, iterator);
});
});
it('should avoid double callback', function(done) {
var called = false;
async.concat([1, 2], function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
}
done();
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = {};
async.concatSeries(array, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = [];
async.concatSeries(object, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.concatSeries(function() {}, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.concatSeries(undefined, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.concatSeries(null, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
});
parallel('#concatLimit', function() {
it('should execute iterator by collection of array', function(done) {
var order = [];
var collection = [1, 5, 3, 4, 2];
async.concatLimit(collection, 2, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 5, 4, 3, 2, 1, 3, 2, 1, 4, 3, 2, 1, 2, 1]);
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 5, 3, 4, 2];
async.concatLimit(collection, 2, concatIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 5, 4, 3, 2, 1, 3, 2, 1, 4, 3, 2, 1, 2, 1]);
assert.deepStrictEqual(order, [
[1, 0],
[3, 2],
[5, 1],
[2, 4],
[4, 3]
]);
done();
});
});
it('should execute iterator by collection of object', function(done) {
var order = [];
var collection = {
a: 1,
b: 5,
c: 3,
d: 4,
e: 2
};
async.concatLimit(collection, 2, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 5, 4, 3, 2, 1, 3, 2, 1, 4, 3, 2, 1, 2, 1]);
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 1,
b: 5,
c: 3,
d: 4,
e: 2
};
async.concatLimit(collection, 2, concatIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 5, 4, 3, 2, 1, 3, 2, 1, 4, 3, 2, 1, 2, 1]);
assert.deepStrictEqual(order, [
[1, 'a'],
[3, 'c'],
[5, 'b'],
[2, 'e'],
[4, 'd']
]);
done();
});
});
it('should execute iterator in limited by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(5);
set.add(3);
set.add(4);
set.add(2);
async.concatLimit(set, 2, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 5, 4, 3, 2, 1, 3, 2, 1, 4, 3, 2, 1, 2, 1]);
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator in limited by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(5);
set.add(3);
set.add(4);
set.add(2);
async.concatLimit(set, 2, concatIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 5, 4, 3, 2, 1, 3, 2, 1, 4, 3, 2, 1, 2, 1]);
assert.deepStrictEqual(order, [
[1, 0],
[3, 2],
[5, 1],
[2, 4],
[4, 3]
]);
done();
});
});
it('should work with odd number of elements even if the size is decreased', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.concatLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [1, 3, 5]);
done();
});
});
it('should work with even number of elements even if the size is decreased', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5, 6]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.concatLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [1, 3, 5]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next();
};
async.concatLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator in limited by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 5);
map.set('c', 3);
map.set('d', 4);
map.set('e', 2);
async.concatLimit(map, 2, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 5, 4, 3, 2, 1, 3, 2, 1, 4, 3, 2, 1, 2, 1]);
assert.deepStrictEqual(order, [
['a', 1],
['c', 3],
['b', 5],
['e', 2],
['d', 4]
]);
done();
});
});
it('should execute iterator in limited by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 5);
map.set('c', 3);
map.set('d', 4);
map.set('e', 2);
async.concatLimit(map, 2, concatIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 5, 4, 3, 2, 1, 3, 2, 1, 4, 3, 2, 1, 2, 1]);
assert.deepStrictEqual(order, [
[ ['a', 1], 0],
[ ['c', 3], 2],
[ ['b', 5], 1],
[ ['e', 2], 4],
[ ['d', 4], 3]
]);
done();
});
});
it('should execute iterator without binding', function(done) {
var order = [];
var collection = {
a: 1.5,
b: 3.5,
c: 2.5
};
async.concatLimit(collection, 2, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1.5, 0.5, 3.5, 2.5, 1.5, 0.5, 2.5, 1.5, 0.5]);
assert.deepStrictEqual(order, [1.5, 3.5, 2.5]);
done();
}, Math);
});
it('should execute like parallel if limit is Infinity', function(done) {
var order = [];
var collection = [1, 3, 2];
async.concatLimit(collection, Infinity, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3, 2, 1, 2, 1]);
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = {
a: 1,
b: 3,
c: 2,
d: 4,
e: 5
};
var iterator = function(n, key, callback) {
callback(null, n);
};
async.concatLimit(collection, 2, iterator, function(err, result) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.deepStrictEqual(result, [1, 3, 2, 4, 5]);
done();
});
sync = false;
});
it('should execute with an array of falthy', function(done) {
var array = [null, undefined, 0, ''];
async.concatLimit(array, 2, function(value, done) {
done(null, value);
}, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, array);
done();
});
});
it('should return an empty array if iterator does not pass the second argument', function(done) {
var array = [1, 2, 3];
async.concatLimit(array, 2, function(value, done) {
done();
}, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, []);
done();
});
});
it('should return an array of undefined if iterator passes the second argument', function(done) {
var array = [1, 2, 3];
async.concatLimit(array, 2, function(value, done) {
done(null, undefined);
}, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [undefined, undefined, undefined]);
done();
});
});
it('should pass multiple arguments', function(done) {
async.concatLimit([1], 2, function(value, done) {
done(null, 1, 2, 3);
}, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [1, 2, 3]);
done();
});
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 2, 4, 5];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, num);
}, num * delay);
};
async.concatLimit(collection, 5, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 2]);
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should avoid double callback', function(done) {
var called = false;
async.concatLimit([1, 2], 2, function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
}
done();
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = {};
async.concatLimit(array, 2, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = [];
async.concatLimit(object, 2, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.concatLimit(function() {}, 2, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.concatLimit(undefined, 2, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.concatLimit(null, 2, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if limit is zero', function(done) {
var order = [];
var collection = [1, 3, 2];
async.concatLimit(collection, 0, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if limit is undefined', function(done) {
var order = [];
var collection = [1, 3, 2];
async.concatLimit(collection, undefined, concatIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
});
neo-async-2.6.1/test/collections/test.detect.js 0000664 0000000 0000000 00000100404 13466145133 0021502 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var domain = require('domain');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
var util = require('../util');
function detectIterator(order) {
return function(value, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
order.push(value);
callback(null, num % 2);
}, num * delay);
};
}
function detectIteratorWithKey(order) {
return function(value, key, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
order.push([value, key]);
callback(null, num % 2);
}, num * delay);
};
}
parallel('#detect', function() {
it('should execute iterator by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.detect(collection, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 1);
assert.deepStrictEqual(order, [1]);
done();
});
});
it('should execute iterator by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.detect(collection, detectIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 1);
assert.deepStrictEqual(order, [
[1, 0]
]);
done();
});
});
it('should execute iterator by collection of object', function(done) {
var order = [];
var collection = {
a: 5,
b: 3,
c: 2
};
async.detect(collection, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 3);
assert.deepStrictEqual(order, [2, 3]);
done();
});
});
it('should execute iterator by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 5,
b: 3,
c: 2
};
async.detect(collection, detectIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 3);
assert.deepStrictEqual(order, [
[2, 'c'],
[3, 'b']
]);
done();
});
});
it('should execute iterator by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(5);
set.add(3);
set.add(2);
async.detect(set, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 3);
assert.deepStrictEqual(order, [2, 3]);
done();
});
});
it('should execute iterator by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(5);
set.add(3);
set.add(2);
async.detect(set, detectIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 3);
assert.deepStrictEqual(order, [
[2, 2],
[3, 1]
]);
done();
});
});
it('should work even if the size is decreased', function(done) {
var order = [];
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.detect(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next();
};
async.detect(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 5);
map.set('b', 3);
map.set('c', 2);
async.detect(map, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, ['b', 3]);
assert.deepStrictEqual(order, [
['c', 2],
['b', 3]
]);
done();
});
});
it('should execute iterator by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 5);
map.set('b', 3);
map.set('c', 2);
async.detect(map, detectIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, ['b', 3]);
assert.deepStrictEqual(order, [
[ ['c', 2], 2],
[ ['b', 3], 1]
]);
done();
});
});
it('should execute iterator without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.6
};
async.detect(collection, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 1.1);
assert.deepStrictEqual(order, [1.1]);
done();
}, Math);
});
it('should not get item', function(done) {
var order = [];
var collection = [2, 6, 4];
async.detect(collection, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, [2, 4, 6]);
done();
});
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, false);
}, num * delay);
};
async.detect(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(res, undefined);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 4);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.detect(collection, iterator);
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 4);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.detect(collection, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
});
});
});
it('should avoid double callback', function(done) {
var called = false;
async.detect([1, 2], function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
}
done();
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = [];
async.detect(array, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = {};
async.detect(object, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.detect(function() {}, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.detect(undefined, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.detect(null, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, []);
done();
});
});
});
parallel('#detectSeries', function() {
it('should execute iterator to series by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.detectSeries(collection, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 1);
assert.deepStrictEqual(order, [1]);
done();
});
});
it('should execute iterator to series by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.detectSeries(collection, detectIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 1);
assert.deepStrictEqual(order, [
[1, 0]
]);
done();
});
});
it('should execute iterator to series by collection of object', function(done) {
var order = [];
var collection = {
a: 5,
b: 3,
c: 2
};
async.detectSeries(collection, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 5);
assert.deepStrictEqual(order, [5]);
done();
});
});
it('should execute iterator to series by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 5,
b: 3,
c: 2
};
async.detectSeries(collection, detectIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 5);
assert.deepStrictEqual(order, [
[5, 'a']
]);
done();
});
});
it('should execute iterator to series by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(5);
set.add(3);
set.add(2);
async.detectSeries(set, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 5);
assert.deepStrictEqual(order, [5]);
done();
});
});
it('should execute iterator to series by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(5);
set.add(3);
set.add(2);
async.detectSeries(set, detectIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 5);
assert.deepStrictEqual(order, [
[5, 0]
]);
done();
});
});
it('should work even if the size is decreased', function(done) {
var order = [];
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.detectSeries(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next();
};
async.detectSeries(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator to series by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 5);
map.set('b', 3);
map.set('c', 2);
async.detectSeries(map, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, ['a', 5]);
assert.deepStrictEqual(order, [
['a', 5]
]);
done();
});
});
it('should execute iterator to series by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 5);
map.set('b', 3);
map.set('c', 2);
async.detectSeries(map, detectIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, ['a', 5]);
assert.deepStrictEqual(order, [
[ ['a', 5], 0]
]);
done();
});
});
it('should execute iterator without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.6
};
async.detectSeries(collection, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 1.1);
assert.deepStrictEqual(order, [1.1]);
done();
}, Math);
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = {
a: 1,
b: 3,
c: 2
};
var iterator = function(n, key, callback) {
callback(null, key === 'c');
};
async.detectSeries(collection, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.strictEqual(res, 2);
done();
});
sync = false;
});
it('should not get item', function(done) {
var order = [];
var collection = [2, 6, 4];
async.detectSeries(collection, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, [2, 6, 4]);
done();
});
});
it('should not get item', function(done) {
var order = [];
var collection = [2, 6, 4];
async.detectSeries(collection, detectIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, [
[2, 0],
[6, 1],
[4, 2]
]);
done();
});
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, false);
}, num * delay);
};
async.detectSeries(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(res, undefined);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 4);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.detectSeries(collection, iterator);
});
});
it('should avoid double callback', function(done) {
var called = false;
async.detectSeries([1, 2], function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
}
done();
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 4);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.detectSeries(collection, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
});
});
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = [];
async.detectSeries(array, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = {};
async.detectSeries(object, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.detectSeries(function() {}, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.detectSeries(undefined, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.detectSeries(null, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, []);
done();
});
});
it('should not cause stack overflow', function(done) {
var array = _.range(10000);
var calls = 0;
async.detectSeries(array, function(data, callback) {
calls++;
setImmediate(function() {
callback(null, true);
});
}, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(calls, 1);
done();
});
});
});
parallel('#detectLimit', function() {
it('should execute iterator in limited by collection of array', function(done) {
var order = [];
var collection = [2, 4, 3, 2];
async.detectLimit(collection, 2, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 3);
assert.deepStrictEqual(order, [2, 4, 3]);
done();
});
});
it('should execute iterator in limited by collection of array with passing index', function(done) {
var order = [];
var collection = [2, 4, 3, 2];
async.detectLimit(collection, 2, detectIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 3);
assert.deepStrictEqual(order, [
[2, 0],
[4, 1],
[3, 2]
]);
done();
});
});
it('should execute iterator in limited by collection of object', function(done) {
var order = [];
var collection = {
a: 2,
b: 4,
c: 3,
d: 2
};
async.detectLimit(collection, 2, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 3);
assert.deepStrictEqual(order, [2, 4, 3]);
done();
});
});
it('should execute iterator in limited by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 2,
b: 4,
c: 3,
d: 2
};
async.detectLimit(collection, 2, detectIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 3);
assert.deepStrictEqual(order, [
[2, 'a'],
[4, 'b'],
[3, 'c']
]);
done();
});
});
it('should execute iterator in limited by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(2);
set.add(4);
set.add(3);
set.add(2);
async.detectLimit(set, 2, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 3);
assert.deepStrictEqual(order, [2, 4, 3]);
done();
});
});
it('should execute iterator in limited by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(2);
set.add(4);
set.add(3);
set.add(2);
async.detectLimit(set, 2, detectIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 3);
assert.deepStrictEqual(order, [
[2, 0],
[4, 1],
[3, 2]
]);
done();
});
});
it('should work with odd number of elements even if the size is decreased', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5]);
var iterator = function(value, index, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.detectLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [1, 3, 5]);
done();
});
});
it('should work with even number of elements even if the size is decreased', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5, 6]);
var iterator = function(value, index, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.detectLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [1, 3, 5]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next();
};
async.detectLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator in limited by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 2);
map.set('b', 4);
map.set('c', 3);
map.set('d', 2);
async.detectLimit(map, 2, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, ['c', 3]);
assert.deepStrictEqual(order, [
['a', 2],
['b', 4],
['c', 3]
]);
done();
});
});
it('should execute iterator in limited by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 2);
map.set('b', 4);
map.set('c', 3);
map.set('d', 2);
async.detectLimit(map, 2, detectIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, ['c', 3]);
assert.deepStrictEqual(order, [
[ ['a', 2], 0],
[ ['b', 4], 1],
[ ['c', 3], 2]
]);
done();
});
});
it('should execute iterator in limited without binding', function(done) {
var order = [];
var collection = {
a: 2.1,
b: 3.5,
c: 2.7
};
async.detectLimit(collection, 2, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 2.1);
assert.deepStrictEqual(order, [2.1]);
done();
}, Math);
});
it('should execute like parallel if limit is Infinity', function(done) {
var order = [];
var collection = [2, 3, 1];
async.detectLimit(collection, Infinity, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 1);
assert.deepStrictEqual(order, [1]);
done();
});
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = {
a: 1,
b: 3,
c: 2,
d: 4,
e: 5
};
var iterator = function(n, key, callback) {
callback(null, key === 'e');
};
async.detectLimit(collection, 2, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.strictEqual(res, 5);
done();
});
sync = false;
});
it('should not get item', function(done) {
var order = [];
var collection = [2, 8, 4];
async.detectLimit(collection, 2, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, [2, 4, 8]);
done();
});
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 4, 2, 3];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 4, false);
}, num * delay);
};
async.detectLimit(collection, 2, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, [1, 2, 4]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 4);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.detectLimit(collection, 2, iterator);
});
});
it('should avoid double callback', function(done) {
var called = false;
async.detectLimit([1, 2], 2, function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
}
done();
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 4);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.detectLimit(collection, 2, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
});
});
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = [];
async.detectLimit(array, 2, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = {};
async.detectLimit(object, 2, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.detectLimit(function() {}, 2, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.detectLimit(undefined, 2, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.detectLimit(null, 2, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if limit is zero', function(done) {
var order = [];
var collection = [1, 3, 2];
async.detectLimit(collection, 0, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if limit is undefined', function(done) {
var order = [];
var collection = [1, 3, 2];
async.detectLimit(collection, undefined, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, []);
done();
});
});
it('should stop execution', function(done) {
var order = [];
var collection = [2, 1, 3];
async.detectLimit(collection, 2, detectIterator(order), function(err, res) {
if (err) {
return done(err);
}
order.push('callback');
assert.strictEqual(res, 1);
});
setTimeout(function() {
assert.deepStrictEqual(order, [1, 'callback', 2]);
done();
}, 10 * delay);
});
it('should not cause stack overflow', function(done) {
var array = _.range(10000);
var calls = 0;
async.detectLimit(array, 100, function(data, callback) {
calls++;
setImmediate(function() {
callback(null, true);
});
}, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(calls, 100);
done();
});
});
});
neo-async-2.6.1/test/collections/test.each.js 0000664 0000000 0000000 00000076526 13466145133 0021153 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var domain = require('domain');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
var util = require('../util');
function eachIterator(order) {
return function(value, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
order.push(value);
callback();
}, num * delay);
};
}
function eachIteratorWithKey(order) {
return function(value, key, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
order.push([value, key]);
callback();
}, num * delay);
};
}
parallel('#each', function() {
it('should execute iterator by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2];
async.each(collection, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should execute with synchronous iterator', function(done) {
var collection = [1, 3, 2];
var iterator = function(value, done) {
done();
};
var called = 0;
async.each(collection, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
setTimeout(done, delay);
});
});
it('should execute iterator by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2];
async.each(collection, eachIteratorWithKey(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [
[1, 0],
[2, 2],
[3, 1]
]);
done();
});
});
it('should execute iterator by collection of object', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2
};
async.each(collection, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should execute iterator by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2
};
async.each(collection, eachIteratorWithKey(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [
[1, 'a'],
[2, 'c'],
[3, 'b']
]);
done();
});
});
it('should execute iterator by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(3);
set.add(2);
async.each(set, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should execute iterator by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(3);
set.add(2);
async.each(set, eachIteratorWithKey(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [
[1, 0],
[2, 2],
[3, 1]
]);
done();
});
});
it('should work properly even if elements are added in callback', function(done) {
var order = [];
var arr = [1, 3, 2];
var set = new util.Set(arr);
var iterator = function(value, next) {
order.push(value);
next(null, value);
};
async.each(set, iterator, function(err) {
if (err) {
return done(err);
}
setTimeout(function() {
assert.deepStrictEqual(order, arr);
done();
}, delay);
set.add(4);
});
});
it('should work even if the size is decreased', function(done) {
var order = [];
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.each(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next();
};
async.each(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 3);
map.set('c', 2);
async.each(map, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [
['a', 1],
['c', 2],
['b', 3]
]);
done();
});
});
it('should execute iterator by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 3);
map.set('c', 2);
async.each(map, eachIteratorWithKey(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [
[['a', 1], 0],
[['c', 2], 2],
[['b', 3], 1]
]);
done();
});
});
it('should execute iterator without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.7
};
async.each(collection, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1.1, 2.7, 3.5]);
done();
}, Math);
});
it('should execute iterator without binding with passing key', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.7
};
async.each(collection, eachIteratorWithKey(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [
[1.1, 'a'],
[2.7, 'c'],
[3.5, 'b']
]);
done();
}, Math);
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3);
}, num * delay);
};
async.each(collection, iterator, function(err) {
assert.ok(err);
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 4);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.each(collection, iterator);
});
});
it('should avoid double callback', function(done) {
var called = {
iterator: false,
callback: false
};
async.each([1, 2], function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
assert.strictEqual(called.iterator, false);
util.errorChecker(e);
called.iterator = true;
}
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called.callback, false);
called.callback = true;
async.nothing();
});
setTimeout(done, delay);
});
it('should break if respond equals false', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(null, num !== 3);
}, num * delay);
};
async.each(collection, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = [];
async.each(array, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = {};
async.each(object, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if a set instance is empty', function(done) {
var order = [];
var set = new util.Set();
async.each(set, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.each(function() {}, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.each(undefined, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.each(null, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, []);
done();
});
});
});
parallel('#eachSeries', function() {
it('should execute iterator to series by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2];
async.eachSeries(collection, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3, 2]);
done();
});
});
it('should execute iterator to series by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2];
async.eachSeries(collection, eachIteratorWithKey(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [
[1, 0],
[3, 1],
[2, 2]
]);
done();
});
});
it('should execute iterator to series by collection of object', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2
};
async.eachSeries(collection, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3, 2]);
done();
});
});
it('should execute iterator to series by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2
};
async.eachSeries(collection, eachIteratorWithKey(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [
[1, 'a'],
[3, 'b'],
[2, 'c']
]);
done();
});
});
it('should execute iterator to series by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(3);
set.add(2);
async.eachSeries(set, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3, 2]);
done();
});
});
it('should execute iterator to series by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(3);
set.add(2);
async.eachSeries(set, eachIteratorWithKey(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [
[1, 0],
[3, 1],
[2, 2]
]);
done();
});
});
it('should work properly even if elements are added in callback', function(done) {
var order = [];
var arr = [1, 3, 2];
var set = new util.Set(arr);
var iterator = function(value, next) {
order.push(value);
next(null, value);
};
async.eachSeries(set, iterator, function(err) {
if (err) {
return done(err);
}
setTimeout(function() {
assert.deepStrictEqual(order, arr);
done();
}, delay);
set.add(4);
});
});
it('should work even if the size is decreased', function(done) {
var order = [];
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.eachSeries(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next();
};
async.eachSeries(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator to series by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 3);
map.set('c', 2);
async.eachSeries(map, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [
['a', 1],
['b', 3],
['c', 2]
]);
done();
});
});
it('should execute iterator to series by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 3);
map.set('c', 2);
async.eachSeries(map, eachIteratorWithKey(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [
[['a', 1], 0],
[['b', 3], 1],
[['c', 2], 2]
]);
done();
});
});
it('should execute iterator to series without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.7
};
async.eachSeries(collection, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1.1, 3.5, 2.7]);
done();
}, Math);
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = {
a: 1,
b: 3,
c: 2
};
var iterator = function(n, callback) {
callback();
};
async.eachSeries(collection, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
done();
});
sync = false;
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3);
}, num * delay);
};
async.eachSeries(collection, iterator, function(err) {
assert.ok(err);
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 4);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
setImmediate(callback);
setImmediate(callback);
};
async.eachSeries(collection, iterator);
});
});
it('should break if respond equals false', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(null, num !== 3);
}, num * 10);
};
async.eachSeries(collection, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = [];
async.eachSeries(array, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = {};
async.eachSeries(object, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.eachSeries(function() {}, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.eachSeries(undefined, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.eachSeries(null, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, []);
done();
});
});
it('should avoid double callback', function(done) {
var called = false;
async.eachSeries([1, 2], function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
}
done();
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
});
parallel('#eachLimit', function() {
it('should execute iterator in limited by collection of array', function(done) {
var order = [];
var collection = [1, 5, 3, 4, 2];
async.eachLimit(collection, 2, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator in limited by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 5, 3, 4, 2];
async.eachLimit(collection, 2, eachIteratorWithKey(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [
[1, 0],
[3, 2],
[5, 1],
[2, 4],
[4, 3]
]);
done();
});
});
it('should execute iterator in limited by collection of object', function(done) {
var order = [];
var collection = {
a: 1,
b: 5,
c: 3,
d: 4,
e: 2
};
async.eachLimit(collection, 2, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator in limited by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 1,
b: 5,
c: 3,
d: 4,
e: 2
};
async.eachLimit(collection, 2, eachIteratorWithKey(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [
[1, 'a'],
[3, 'c'],
[5, 'b'],
[2, 'e'],
[4, 'd']
]);
done();
});
});
it('should execute iterator in limited by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(5);
set.add(3);
set.add(4);
set.add(2);
async.eachLimit(set, 2, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator in limited by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(5);
set.add(3);
set.add(4);
set.add(2);
async.eachLimit(set, 2, eachIteratorWithKey(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [
[1, 0],
[3, 2],
[5, 1],
[2, 4],
[4, 3]
]);
done();
});
});
it('should work properly even if elements are added in callback', function(done) {
var order = [];
var arr = [1, 5, 3, 4, 2];
var set = new util.Set(arr);
var iterator = function(value, next) {
order.push(value);
next(null, value);
};
async.eachLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
setTimeout(function() {
assert.deepStrictEqual(order, arr);
done();
}, delay);
set.add(6);
});
});
it('should work with odd number of elements even if the size is decreased', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.eachLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [1, 3, 5]);
done();
});
});
it('should work with even number of elements even if the size is decreased', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5, 6]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.eachLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [1, 3, 5]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next();
};
async.eachLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should work with odd number of elements even if the size is decreased', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5]);
var iterator = function(value, index, next) {
order.push([index, value]);
set.delete(value + 1);
next();
};
async.eachLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [[0, 1], [1, 3], [2, 5]]);
done();
});
});
it('should work with even number of elements even if the size is decreased', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5, 6]);
var iterator = function(value, index, next) {
order.push([index, value]);
set.delete(value + 1);
next();
};
async.eachLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [[0, 1], [1, 3], [2, 5]]);
done();
});
});
it('should work even if limit is less than set size', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2]);
var iterator = function(value, next) {
order.push(value);
next();
};
async.eachLimit(set, 10, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [1, 2]);
done();
});
});
it('should execute iterator in limited by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 5);
map.set('c', 3);
map.set('d', 4);
map.set('e', 2);
async.eachLimit(map, 2, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [
['a', 1],
['c', 3],
['b', 5],
['e', 2],
['d', 4]
]);
done();
});
});
it('should execute iterator in limited by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 5);
map.set('c', 3);
map.set('d', 4);
map.set('e', 2);
async.eachLimit(map, 2, eachIteratorWithKey(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [
[ ['a', 1], 0],
[ ['c', 3], 2],
[ ['b', 5], 1],
[ ['e', 2], 4],
[ ['d', 4], 3]
]);
done();
});
});
it('should execute iterator in limited without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.7
};
async.eachLimit(collection, 2, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1.1, 3.5, 2.7]);
done();
}, Math);
});
it('should execute like parallel if limit is Infinity', function(done) {
var order = [];
var collection = [1, 3, 4, 2, 3];
async.eachLimit(collection, Infinity, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 3, 4]);
done();
});
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = [1, 3, 4, 2, 3];
var iterator = function(n, callback) {
callback();
};
async.eachLimit(collection, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
done();
});
sync = false;
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3);
}, num * delay);
};
async.eachLimit(collection, 3, iterator, function(err) {
assert.ok(err);
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should avoid double callback', function(done) {
var called = false;
async.eachLimit([1, 2], 2, function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
}
done();
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should break if respond equals false', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(null, num !== 3);
}, num * delay);
};
async.eachLimit(collection, 3, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = [];
async.eachLimit(array, 3, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = {};
async.eachLimit(object, 3, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.eachLimit(function() {}, 2, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.eachLimit(undefined, 2, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.eachLimit(null, 2, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if limit is zero', function(done) {
var order = [];
var collection = [1, 3, 2];
async.eachLimit(collection, 0, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if limit is undefined', function(done) {
var order = [];
var collection = [1, 3, 2];
async.eachLimit(collection, undefined, eachIterator(order), function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, []);
done();
});
});
it('should work with generator', function(done) {
var limit = 2;
var collection = ['abc', 'def', 'ghi', 'jkl'];
var order = [];
var gen = util.makeGenerator(collection);
async.eachLimit(
gen,
limit,
function(v, i, cb) {
order.push(i);
setTimeout(cb, Math.random() * delay, null, v);
},
function(err) {
if (err) {
return done();
}
assert.deepStrictEqual(order, [0, 1, 2, 3]);
done();
}
);
});
});
neo-async-2.6.1/test/collections/test.every.js 0000664 0000000 0000000 00000062563 13466145133 0021401 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var domain = require('domain');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
var util = require('../util');
function everyIterator(order) {
return function(value, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
order.push(value);
callback(null, num % 2);
}, num * delay);
};
}
function everyIteratorWithKey(order) {
return function(value, key, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
order.push([value, key]);
callback(null, num % 2);
}, num * delay);
};
}
parallel('#every', function() {
it('should execute iterator by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.every(collection, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, [1, 2]);
done();
});
});
it('should execute iterator by collection of array', function(done) {
var order = [];
var collection = [1, 3, 1, 5];
async.every(collection, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [1, 1, 3, 5]);
done();
});
});
it('should execute iterator by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.every(collection, everyIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, [
[1, 0],
[2, 2]
]);
done();
});
});
it('should execute iterator by collection of object', function(done) {
var order = [];
var collection = {
a: 4,
b: 3,
c: 2
};
async.every(collection, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, [2]);
done();
});
});
it('should execute iterator by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 4,
b: 3,
c: 2
};
async.every(collection, everyIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, [
[2, 'c']
]);
done();
});
});
it('should execute iterator by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(5);
set.add(3);
set.add(2);
async.every(set, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, [2]);
done();
});
});
it('should execute iterator by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(4);
set.add(3);
set.add(2);
async.every(set, everyIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, [
[2, 2]
]);
done();
});
});
it('should work even if the size is decreased', function(done) {
var order = [];
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next(null, true);
};
async.every(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next(null, true);
};
async.every(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 4);
map.set('b', 3);
map.set('c', 2);
async.every(map, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, [
['c', 2]
]);
done();
});
});
it('should execute iterator by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 4);
map.set('b', 3);
map.set('c', 2);
async.every(map, everyIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, [
[ ['c', 2], 2]
]);
done();
});
});
it('should execute iterator without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.6
};
async.every(collection, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [1.1, 2.6, 3.5]);
done();
}, Math);
});
it('should avoid double callback', function(done) {
var called = false;
async.every([1, 2], function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
}
done();
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if collection is empty', function(done) {
var order = [];
async.every([], everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.every(function() {}, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.every(undefined, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.every(null, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return an error', function(done) {
var collection = [1, 3, 2, 4];
var iterator = function(value, key, callback) {
callback('error');
};
async.every(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(res, undefined);
done();
});
});
});
parallel('#everySeries', function() {
it('should execute iterator by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.everySeries(collection, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, [1, 3, 2]);
done();
});
});
it('should execute iterator by collection of array', function(done) {
var order = [];
var collection = [1, 3, 1, 5];
async.everySeries(collection, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [1, 3, 1, 5]);
done();
});
});
it('should execute iterator by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.everySeries(collection, everyIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, [
[1, 0],
[3, 1],
[2, 2]
]);
done();
});
});
it('should execute iterator by collection of object', function(done) {
var order = [];
var collection = {
a: 4,
b: 3,
c: 2
};
async.everySeries(collection, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, [4]);
done();
});
});
it('should execute iterator by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 4,
b: 3,
c: 2
};
async.everySeries(collection, everyIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, [
[4, 'a']
]);
done();
});
});
it('should execute iterator by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(4);
set.add(3);
set.add(2);
async.everySeries(set, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, [4]);
done();
});
});
it('should execute iterator by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(4);
set.add(3);
set.add(2);
async.everySeries(set, everyIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, [
[4, 0]
]);
done();
});
});
it('should work even if the size is decreased', function(done) {
var order = [];
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next(null, true);
};
async.everySeries(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next(null, true);
};
async.everySeries(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 4);
map.set('b', 3);
map.set('c', 2);
async.everySeries(map, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, [
['a', 4]
]);
done();
});
});
it('should execute iterator by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 4);
map.set('b', 3);
map.set('c', 2);
async.everySeries(map, everyIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, [
[ ['a', 4], 0]
]);
done();
});
});
it('should execute iterator without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.6
};
async.everySeries(collection, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [1.1, 3.5, 2.6]);
done();
}, Math);
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = {
a: 1,
b: 3,
c: 2
};
var iterator = function(n, key, callback) {
callback(null, true);
};
async.everySeries(collection, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.strictEqual(res, true);
done();
});
sync = false;
});
it('should return an error', function(done) {
var collection = [1, 3, 2, 4];
var iterator = function(value, key, callback) {
callback('error');
};
async.everySeries(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(res, undefined);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 4);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
process.nextTick(function() {
callback(null, true);
});
process.nextTick(function() {
callback(null, true);
});
};
async.everySeries(collection, iterator);
});
});
it('should avoid double callback', function(done) {
var called = false;
async.everySeries([1, 2], function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
}
done();
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if collection is empty', function(done) {
var order = [];
async.everySeries([], everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.everySeries(function() {}, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.everySeries(undefined, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.everySeries(null, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, []);
done();
});
});
});
parallel('#everyLimit', function() {
it('should execute iterator by collection of array', function(done) {
var order = [];
var collection = [1, 5, 2, 4];
async.everyLimit(collection, 2, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, [1, 2]);
done();
});
});
it('should execute iterator by collection of array passing index', function(done) {
var order = [];
var collection = [1, 5, 2, 4];
async.everyLimit(collection, 2, everyIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, [
[1, 0],
[2, 2]
]);
done();
});
});
it('should execute iterator by collection of object', function(done) {
var order = [];
var collection = {
a: 1,
b: 5,
c: 2,
d: 4
};
async.everyLimit(collection, 2, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, [1, 2]);
done();
});
});
it('should execute iterator by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 1,
b: 5,
c: 2,
d: 4
};
async.everyLimit(collection, 2, everyIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, [
[1, 'a'],
[2, 'c']
]);
done();
});
});
it('should execute iterator by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(5);
set.add(2);
set.add(4);
async.everyLimit(set, 2, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, [1, 2]);
done();
});
});
it('should execute iterator by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(5);
set.add(2);
set.add(4);
async.everyLimit(set, 2, everyIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, [
[1, 0],
[2, 2]
]);
done();
});
});
it('should work with odd number of elements even if the size is decreased', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next(null, true);
};
async.everyLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [1, 3, 5]);
done();
});
});
it('should work with even number of elements even if the size is decreased', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5, 6]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next(null, true);
};
async.everyLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [1, 3, 5]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next(null, true);
};
async.everyLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 5);
map.set('c', 2);
map.set('d', 4);
async.everyLimit(map, 2, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, [
['a', 1],
['c', 2]
]);
done();
});
});
it('should execute iterator by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 5);
map.set('c', 2);
map.set('d', 4);
async.everyLimit(map, 2, everyIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, [
[ ['a', 1], 0],
[ ['c', 2], 2]
]);
done();
});
});
it('should execute iterator without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.6
};
async.everyLimit(collection, 2, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [1.1, 3.5, 2.6]);
done();
}, Math);
});
it('should execute like parallel if limit is Infinity', function(done) {
var order = [];
var collection = [1, 3, 9, 5];
async.everyLimit(collection, Infinity, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [1, 3, 5, 9]);
done();
});
});
it('should avoid double callback', function(done) {
var called = false;
async.everyLimit([1, 2], 2, function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
}
done();
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if collection is empty', function(done) {
var order = [];
async.everyLimit([], 4, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.everyLimit(function() {}, 2, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.everyLimit(undefined, 0, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.everyLimit(null, 0, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if limit is zero', function(done) {
var order = [];
var collection = [1, 3, 2];
async.everyLimit(collection, 0, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if limit is undefined', function(done) {
var order = [];
var collection = [1, 3, 2];
async.everyLimit(collection, undefined, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return an error', function(done) {
var collection = [1, 3, 2, 4];
var iterator = function(value, key, callback) {
callback('error');
};
async.everyLimit(collection, 1, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(res, undefined);
done();
});
});
it('should stop execution', function(done) {
var order = [];
var collection = [3, 2, 1];
async.everyLimit(collection, 2, everyIterator(order), function(err, res) {
if (err) {
return done(err);
}
order.push('callback');
assert.strictEqual(res, false);
});
setTimeout(function() {
assert.deepStrictEqual(order, [2, 'callback', 3]);
done();
}, 10 * delay);
});
});
neo-async-2.6.1/test/collections/test.filter.js 0000664 0000000 0000000 00000106440 13466145133 0021525 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var domain = require('domain');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
var util = require('../util');
function filterIterator(order) {
return function(value, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
order.push(value);
callback(null, num % 2);
}, num * delay);
};
}
function filterIteratorWithKey(order) {
return function(value, key, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
order.push([value, key]);
callback(null, num % 2);
}, num * delay);
};
}
parallel('#filter', function() {
it('should execute iterator by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.filter(collection, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [1, 3]);
assert.deepStrictEqual(order, [1, 2, 3, 4]);
done();
});
});
it('should execute iterator by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.filter(collection, filterIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [1, 3]);
assert.deepStrictEqual(order, [
[1, 0],
[2, 2],
[3, 1],
[4, 3]
]);
done();
});
});
it('should execute iterator by collection of object', function(done) {
var order = [];
var collection = {
a: 4,
b: 3,
c: 2
};
async.filter(collection, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 1);
assert.deepStrictEqual(res, [3]);
assert.deepStrictEqual(order, [2, 3, 4]);
done();
});
});
it('should execute iterator by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 4,
b: 3,
c: 2
};
async.filter(collection, filterIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 1);
assert.deepStrictEqual(res, [3]);
assert.deepStrictEqual(order, [
[2, 'c'],
[3, 'b'],
[4, 'a']
]);
done();
});
});
it('should execute iterator by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(4);
set.add(3);
set.add(2);
async.filter(set, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 1);
assert.deepStrictEqual(res, [3]);
assert.deepStrictEqual(order, [2, 3, 4]);
done();
});
});
it('should execute iterator by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(4);
set.add(3);
set.add(2);
async.filter(set, filterIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 1);
assert.deepStrictEqual(res, [3]);
assert.deepStrictEqual(order, [
[2, 2],
[3, 1],
[4, 0]
]);
done();
});
});
it('should work even if the size is decreased', function(done) {
var order = [];
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.filter(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next();
};
async.filter(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 4);
map.set('b', 3);
map.set('c', 2);
async.filter(map, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 1);
assert.deepStrictEqual(res, [['b', 3]]);
assert.deepStrictEqual(order, [
['c', 2],
['b', 3],
['a', 4]
]);
done();
});
});
it('should execute iterator by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 4);
map.set('b', 3);
map.set('c', 2);
async.filter(map, filterIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 1);
assert.deepStrictEqual(res, [['b', 3]]);
assert.deepStrictEqual(order, [
[['c', 2], 2],
[['b', 3], 1],
[['a', 4], 0]
]);
done();
});
});
it('should execute iterator without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.6
};
async.filter(collection, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 3);
assert.deepStrictEqual(res, [1.1, 3.5, 2.6]);
assert.deepStrictEqual(order, [1.1, 2.6, 3.5]);
done();
}, Math);
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, true);
}, num * delay);
};
async.filter(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(res, undefined);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 4);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.filter(collection, iterator);
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 4);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.filter(collection, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
});
});
});
it('should avoid double callback', function(done) {
var called = false;
async.filter([1, 2], function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
}
done();
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should not throw error of double callback', function(done) {
var collection = [
'dir1',
'dir2',
'file1',
'file2'
];
var iterator = function(name, callback) {
var result = name.charAt(0) === 'd';
callback(null, result);
};
var called = false;
async.filter(collection, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(called, false);
called = true;
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, ['dir1', 'dir2']);
setImmediate(done);
});
});
it('should return response immediately if collection is empty', function(done) {
var order = [];
async.filter([], filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.filter(function() {}, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.filter(undefined, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.filter(null, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
});
parallel('#filterSeries', function() {
it('should execute iterator to series by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.filterSeries(collection, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [1, 3]);
assert.deepStrictEqual(order, [1, 3, 2, 4]);
done();
});
});
it('should execute iterator to series by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.filterSeries(collection, filterIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [1, 3]);
assert.deepStrictEqual(order, [
[1, 0],
[3, 1],
[2, 2],
[4, 3]
]);
done();
});
});
it('should execute iterator to series by collection of object', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2
};
async.filterSeries(collection, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [1, 3]);
assert.deepStrictEqual(order, [1, 3, 2]);
done();
});
});
it('should execute iterator to series by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2
};
async.filterSeries(collection, filterIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [1, 3]);
assert.deepStrictEqual(order, [
[1, 'a'],
[3, 'b'],
[2, 'c']
]);
done();
});
});
it('should execute iterator to series by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(4);
set.add(3);
set.add(2);
async.filterSeries(set, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 1);
assert.deepStrictEqual(res, [3]);
assert.deepStrictEqual(order, [4, 3, 2]);
done();
});
});
it('should execute iterator to series by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(4);
set.add(3);
set.add(2);
async.filterSeries(set, filterIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 1);
assert.deepStrictEqual(res, [3]);
assert.deepStrictEqual(order, [
[4, 0],
[3, 1],
[2, 2]
]);
done();
});
});
it('should work even if the size is decreased', function(done) {
var order = [];
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.filterSeries(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next();
};
async.filterSeries(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator to series by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 4);
map.set('b', 3);
map.set('c', 2);
async.filterSeries(map, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 1);
assert.deepStrictEqual(res, [['b', 3]]);
assert.deepStrictEqual(order, [
['a', 4],
['b', 3],
['c', 2]
]);
done();
});
});
it('should execute iterator to series by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 4);
map.set('b', 3);
map.set('c', 2);
async.filterSeries(map, filterIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 1);
assert.deepStrictEqual(res, [['b', 3]]);
assert.deepStrictEqual(order, [
[['a', 4], 0],
[['b', 3], 1],
[['c', 2], 2]
]);
done();
});
});
it('should execute iterator to series without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.6
};
async.filterSeries(collection, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 3);
assert.deepStrictEqual(res, [1.1, 3.5, 2.6]);
assert.deepStrictEqual(order, [1.1, 3.5, 2.6]);
done();
}, Math);
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = {
a: 1,
b: 3,
c: 2
};
var iterator = function(n, callback) {
callback(null, true);
};
async.filterSeries(collection, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.deepStrictEqual(res, [1, 3, 2]);
done();
});
sync = false;
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, true);
}, num * delay);
};
async.filterSeries(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(res, undefined);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 4);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.filterSeries(collection, iterator);
});
});
it('should avoid double callback', function(done) {
var called = false;
async.filterSeries([1, 2], function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
}
done();
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if collection is empty', function(done) {
var order = [];
async.filterSeries([], filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.filterSeries(function() {}, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.filterSeries(undefined, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.filterSeries(null, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
});
parallel('#filterLimit', function() {
it('should execute iterator in limited by collection of array', function(done) {
var order = [];
var collection = [1, 5, 3, 2, 4];
async.filterLimit(collection, 2, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 3);
assert.deepStrictEqual(res, [1, 5, 3]);
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator in limited by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 5, 3, 2, 4];
async.filterLimit(collection, 2, filterIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 3);
assert.deepStrictEqual(res, [1, 5, 3]);
assert.deepStrictEqual(order, [
[1, 0],
[3, 2],
[5, 1],
[2, 3],
[4, 4]
]);
done();
});
});
it('should execute iterator in limited by collection of object', function(done) {
var order = [];
var collection = {
a: 1,
b: 5,
c: 3,
d: 2,
e: 4
};
async.filterLimit(collection, 2, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 3);
assert.deepStrictEqual(res, [1, 5, 3]);
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator in limited by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 1,
b: 5,
c: 3,
d: 2,
e: 4
};
async.filterLimit(collection, 2, filterIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 3);
assert.deepStrictEqual(res, [1, 5, 3]);
assert.deepStrictEqual(order, [
[1, 'a'],
[3, 'c'],
[5, 'b'],
[2, 'd'],
[4, 'e']
]);
done();
});
});
it('should execute iterator in limited by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(5);
set.add(3);
set.add(2);
set.add(4);
async.filterLimit(set, 2, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 3);
assert.deepStrictEqual(res, [1, 5, 3]);
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator in limited by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(5);
set.add(3);
set.add(2);
set.add(4);
async.filterLimit(set, 2, filterIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 3);
assert.deepStrictEqual(res, [1, 5, 3]);
assert.deepStrictEqual(order, [
[1, 0],
[3, 2],
[5, 1],
[2, 3],
[4, 4]
]);
done();
});
});
it('should work with odd number of elements even if the size is decreased', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5]);
var iterator = function(value, index, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.filterLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [1, 3, 5]);
done();
});
});
it('should work with even number of elements even if the size is decreased', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5, 6]);
var iterator = function(value, index, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.filterLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [1, 3, 5]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next();
};
async.filterLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator in limited by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 5);
map.set('c', 3);
map.set('d', 2);
map.set('e', 4);
async.filterLimit(map, 2, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 3);
assert.deepStrictEqual(res, [
['a', 1],
['b', 5],
['c', 3]
]);
assert.deepStrictEqual(order, [
['a', 1],
['c', 3],
['b', 5],
['d', 2],
['e', 4]
]);
done();
});
});
it('should execute iterator in limited by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 5);
map.set('c', 3);
map.set('d', 2);
map.set('e', 4);
async.filterLimit(map, 2, filterIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 3);
assert.deepStrictEqual(res, [
['a', 1],
['b', 5],
['c', 3]
]);
assert.deepStrictEqual(order, [
[['a', 1], 0],
[['c', 3], 2],
[['b', 5], 1],
[['d', 2], 3],
[['e', 4], 4]
]);
done();
});
});
it('should execute iterator in limited without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.7
};
async.filterLimit(collection, 2, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 3);
assert.deepStrictEqual(res, [1.1, 3.5, 2.7]);
assert.deepStrictEqual(order, [1.1, 3.5, 2.7]);
done();
}, Math);
});
it('should execute like parallel if limit is Infinity', function(done) {
var order = [];
var collection = [1, 3, 4, 2, 3, 1];
async.filterLimit(collection, Infinity, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 4);
assert.deepStrictEqual(res, [1, 3, 3, 1]);
assert.deepStrictEqual(order, [1, 1, 2, 3, 3, 4]);
done();
});
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = [1, 3, 4, 2, 3, 1];
var iterator = function(n, callback) {
callback(null, n % 2);
};
async.filterLimit(collection, 2, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.deepStrictEqual(res, [1, 3, 3, 1]);
done();
});
sync = false;
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 5, 3, 2, 4];
var iterator = function(num, index, callback) {
setTimeout(function() {
order.push([num, index]);
callback(num === 5, num % 2);
}, num * delay);
};
async.filterLimit(collection, 2, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, [
[1, 0],
[3, 2],
[5, 1]
]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 5);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 5, 3, 2, 4];
var iterator = function(num, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.filterLimit(collection, 2, iterator);
});
});
it('should throw error if callback has 2nd argument and called twice', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 5);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 5, 3, 2, 4];
var iterator = function(num, index, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.filterLimit(collection, 2, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
});
});
});
it('should avoid double callback', function(done) {
var called = false;
async.filterLimit([1, 2], 2, function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
}
done();
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if collection is empty', function(done) {
var order = [];
async.filterLimit([], 2, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is empty object', function(done) {
var order = [];
async.filterLimit({}, 2, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.filterLimit(function() {}, 2, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.filterLimit(undefined, 2, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.filterLimit(null, 2, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if limit is zero', function(done) {
var order = [];
var collection = [1, 3, 2];
async.filterLimit(collection, 0, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if limit is undefined', function(done) {
var order = [];
var collection = [1, 3, 2];
async.filterLimit(collection, undefined, filterIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
});
neo-async-2.6.1/test/collections/test.groupBy.js 0000664 0000000 0000000 00000076233 13466145133 0021675 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var domain = require('domain');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
var util = require('../util');
function groupByIterator(order) {
return function(value, callback) {
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
order.push(value);
callback(null, Math.floor(num));
}, num * delay);
};
}
function groupByIteratorWithKey(order) {
return function(value, key, callback) {
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
order.push([value, key]);
callback(null, Math.floor(num));
}, num * delay);
};
}
parallel('#groupBy', function() {
it('should execute iterator by collection of array', function(done) {
var order = [];
var collection = [4.2, 6.4, 6.1];
async.groupBy(collection, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'4': [4.2],
'6': [6.1, 6.4]
});
assert.deepStrictEqual(order, [4.2, 6.1, 6.4]);
done();
});
});
it('should execute iterator by collection of array with passing index', function(done) {
var order = [];
var collection = [4.2, 6.4, 6.1];
async.groupBy(collection, groupByIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'4': [4.2],
'6': [6.1, 6.4]
});
assert.deepStrictEqual(order, [
[4.2, 0],
[6.1, 2],
[6.4, 1]
]);
done();
});
});
it('should execute iterator by collection of object', function(done) {
var order = [];
var collection = {
a: 4.2,
b: 6.4,
c: 6.1
};
async.groupBy(collection, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'4': [4.2],
'6': [6.1, 6.4]
});
assert.deepStrictEqual(order, [4.2, 6.1, 6.4]);
done();
});
});
it('should execute iterator by collection of object with key', function(done) {
var order = [];
var collection = {
a: 4.2,
b: 6.4,
c: 6.1
};
async.groupBy(collection, groupByIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'4': [4.2],
'6': [6.1, 6.4]
});
assert.deepStrictEqual(order, [
[4.2, 'a'],
[6.1, 'c'],
[6.4, 'b']
]);
done();
});
});
it('should execute iterator to series by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(4.2);
set.add(6.4);
set.add(6.1);
async.groupBy(set, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'4': [4.2],
'6': [6.1, 6.4]
});
assert.deepStrictEqual(order, [4.2, 6.1, 6.4]);
done();
});
});
it('should execute iterator to series by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(4.2);
set.add(6.4);
set.add(6.1);
async.groupBy(set, groupByIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'4': [4.2],
'6': [6.1, 6.4]
});
assert.deepStrictEqual(order, [
[4.2, 0],
[6.1, 2],
[6.4, 1]
]);
done();
});
});
it('should work even if the size is decreased', function(done) {
var order = [];
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.groupBy(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next();
};
async.groupBy(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator to series by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 4.2);
map.set('b', 6.4);
map.set('c', 6.1);
async.groupBy(map, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'4': [['a',4.2]],
'6': [['c', 6.1], ['b', 6.4]]
});
assert.deepStrictEqual(order, [
['a', 4.2],
['c', 6.1],
['b', 6.4]
]);
done();
});
});
it('should execute iterator to series by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 4.2);
map.set('b', 6.4);
map.set('c', 6.1);
async.groupBy(map, groupByIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'4': [['a',4.2]],
'6': [['c', 6.1], ['b', 6.4]]
});
assert.deepStrictEqual(order, [
[['a', 4.2], 0],
[['c', 6.1], 2],
[['b', 6.4], 1]
]);
done();
});
});
it('should throw error', function(done) {
var order = [];
var collection = [4.4, 6.4, 4, 5];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 5, Math.floor(num));
}, num * delay);
};
async.groupBy(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'4': [4, 4.4]
});
assert.deepStrictEqual(order, [4, 4.4, 5]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 2);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3];
var iterator = function(num, callback) {
process.nextTick(function() {
callback(null, num);
});
process.nextTick(function() {
callback(null, num);
});
};
async.groupBy(collection, iterator);
});
});
it('should avoid double callback', function(done) {
var called = false;
async.groupBy([1, 2, 3], function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
done();
}
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = [];
async.groupBy(array, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = {};
async.groupBy(object, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.groupBy(function() {}, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.groupBy(undefined, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.groupBy(null, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
});
parallel('#groupBySeries', function() {
it('should execute iterator by collection of array', function(done) {
var order = [];
var collection = [4.2, 6.4, 6.1];
async.groupBySeries(collection, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'4': [4.2],
'6': [6.4, 6.1]
});
assert.deepStrictEqual(order, [4.2, 6.4, 6.1]);
done();
});
});
it('should execute iterator by collection of array with passing index', function(done) {
var order = [];
var collection = [4.2, 6.4, 6.1];
async.groupBySeries(collection, groupByIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'4': [4.2],
'6': [6.4, 6.1]
});
assert.deepStrictEqual(order, [
[4.2, 0],
[6.4, 1],
[6.1, 2]
]);
done();
});
});
it('should execute iterator by collection of object', function(done) {
var order = [];
var collection = {
a: 4.2,
b: 6.4,
c: 6.1
};
async.groupBySeries(collection, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'4': [4.2],
'6': [6.4, 6.1]
});
assert.deepStrictEqual(order, [4.2, 6.4, 6.1]);
done();
});
});
it('should execute iterator by collection of object with key', function(done) {
var order = [];
var collection = {
a: 4.2,
b: 6.4,
c: 6.1
};
async.groupBySeries(collection, groupByIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'4': [4.2],
'6': [6.4, 6.1]
});
assert.deepStrictEqual(order, [
[4.2, 'a'],
[6.4, 'b'],
[6.1, 'c']
]);
done();
});
});
it('should execute iterator to series by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(4.2);
set.add(6.4);
set.add(6.1);
async.groupBySeries(set, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'4': [4.2],
'6': [6.4, 6.1]
});
assert.deepStrictEqual(order, [4.2, 6.4, 6.1]);
done();
});
});
it('should execute iterator to series by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(4.2);
set.add(6.4);
set.add(6.1);
async.groupBySeries(set, groupByIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'4': [4.2],
'6': [6.4, 6.1]
});
assert.deepStrictEqual(order, [
[4.2, 0],
[6.4, 1],
[6.1, 2]
]);
done();
});
});
it('should work even if the size is decreased', function(done) {
var order = [];
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.groupBySeries(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next();
};
async.groupBySeries(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator to series by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 4.2);
map.set('b', 6.4);
map.set('c', 6.1);
async.groupBySeries(map, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'4': [['a',4.2]],
'6': [['b', 6.4], ['c', 6.1]]
});
assert.deepStrictEqual(order, [
['a', 4.2],
['b', 6.4],
['c', 6.1]
]);
done();
});
});
it('should execute iterator to series by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 4.2);
map.set('b', 6.4);
map.set('c', 6.1);
async.groupBySeries(map, groupByIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'4': [['a',4.2]],
'6': [['b', 6.4], ['c', 6.1]]
});
assert.deepStrictEqual(order, [
[['a', 4.2], 0],
[['b', 6.4], 1],
[['c', 6.1], 2]
]);
done();
});
});
it('should throw error', function(done) {
var order = [];
var collection = [4.4, 6.4, 4, 5];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 5, Math.floor(num));
}, num * delay);
};
async.groupBySeries(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'4': [4.4, 4],
'6': [6.4]
});
assert.deepStrictEqual(order, [4.4, 6.4, 4, 5]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 2);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3];
var iterator = function(num, callback) {
process.nextTick(function() {
callback(null, num);
});
process.nextTick(function() {
callback(null, num);
});
};
async.groupBySeries(collection, iterator);
});
});
it('should avoid double callback', function(done) {
var called = false;
async.groupBySeries([1, 2, 3], function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
done();
}
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = [];
async.groupBySeries(array, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = {};
async.groupBySeries(object, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.groupBySeries(function() {}, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.groupBySeries(undefined, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.groupBySeries(null, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
});
parallel('#groupByLimit', function() {
it('should execute iterator by collection of array', function(done) {
var order = [];
var collection = [1.1, 5.9, 3.2, 3.9, 2.1];
async.groupByLimit(collection, 2, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'1': [1.1],
'3': [3.2, 3.9],
'5': [5.9],
'2': [2.1]
});
assert.deepStrictEqual(order, [1.1, 3.2, 5.9, 2.1, 3.9]);
done();
});
});
it('should execute iterator by collection of array with passing index', function(done) {
var order = [];
var collection = [1.1, 5.9, 3.2, 3.9, 2.1];
async.groupByLimit(collection, 2, groupByIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'1': [1.1],
'3': [3.2, 3.9],
'5': [5.9],
'2': [2.1]
});
assert.deepStrictEqual(order, [
[1.1, 0],
[3.2, 2],
[5.9, 1],
[2.1, 4],
[3.9, 3]
]);
done();
});
});
it('should execute iterator by collection of object', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 5.9,
c: 3.2,
d: 3.9,
e: 2.1
};
async.groupByLimit(collection, 2, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'1': [1.1],
'3': [3.2, 3.9],
'5': [5.9],
'2': [2.1]
});
assert.deepStrictEqual(order, [1.1, 3.2, 5.9, 2.1, 3.9]);
done();
});
});
it('should execute iterator by collection of object with key', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 5.9,
c: 3.2,
d: 3.9,
e: 2.1
};
async.groupByLimit(collection, 2, groupByIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'1': [1.1],
'3': [3.2, 3.9],
'5': [5.9],
'2': [2.1]
});
assert.deepStrictEqual(order, [
[1.1, 'a'],
[3.2, 'c'],
[5.9, 'b'],
[2.1, 'e'],
[3.9, 'd']
]);
done();
});
});
it('should execute iterator to series by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(1.1);
set.add(5.9);
set.add(3.2);
set.add(3.9);
set.add(2.1);
async.groupByLimit(set, 2, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'1': [1.1],
'3': [3.2, 3.9],
'5': [5.9],
'2': [2.1]
});
assert.deepStrictEqual(order, [1.1, 3.2, 5.9, 2.1, 3.9]);
done();
});
});
it('should execute iterator to series by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(1.1);
set.add(5.9);
set.add(3.2);
set.add(3.9);
set.add(2.1);
async.groupByLimit(set, 2, groupByIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'1': [1.1],
'3': [3.2, 3.9],
'5': [5.9],
'2': [2.1]
});
assert.deepStrictEqual(order, [
[1.1, 0],
[3.2, 2],
[5.9, 1],
[2.1, 4],
[3.9, 3]
]);
done();
});
});
it('should work with odd number of elements even if the size is decreased', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.groupByLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [1, 3, 5]);
done();
});
});
it('should work with even number of elements even if the size is decreased', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5, 6]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.groupByLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [1, 3, 5]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next();
};
async.groupByLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator to series by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1.1);
map.set('b', 5.9);
map.set('c', 3.2);
map.set('d', 3.9);
map.set('e', 2.1);
async.groupByLimit(map, 2, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'1': [['a',1.1]],
'3': [['c', 3.2], ['d', 3.9]],
'5': [['b', 5.9]],
'2': [['e', 2.1]]
});
assert.deepStrictEqual(order, [
['a', 1.1],
['c', 3.2],
['b', 5.9],
['e', 2.1],
['d', 3.9]
]);
done();
});
});
it('should execute iterator to series by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1.1);
map.set('b', 5.9);
map.set('c', 3.2);
map.set('d', 3.9);
map.set('e', 2.1);
async.groupByLimit(map, 2, groupByIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'1': [['a',1.1]],
'3': [['c', 3.2], ['d', 3.9]],
'5': [['b', 5.9]],
'2': [['e', 2.1]]
});
assert.deepStrictEqual(order, [
[['a', 1.1], 0],
[['c', 3.2], 2],
[['b', 5.9], 1],
[['e', 2.1], 4],
[['d', 3.9], 3]
]);
done();
});
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = [1.1, 5.9, 3.2, 3.9, 2.1];
var iterator = function(value, next) {
next(null, value);
};
async.groupByLimit(collection, 2, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.strictEqual(sync, false);
done();
});
sync = false;
});
it('should throw error', function(done) {
var order = [];
var collection = [1.1, 5.9, 3.2, 3.9, 2.1];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 2.1, Math.floor(num));
}, num * delay);
};
async.groupByLimit(collection, 2, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'1': [1.1],
'3': [3.2],
'5': [5.9]
});
assert.deepStrictEqual(order, [1.1, 3.2, 5.9, 2.1]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 2);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3];
var iterator = function(num, callback) {
process.nextTick(function() {
callback(null, num);
});
process.nextTick(function() {
callback(null, num);
});
};
async.groupByLimit(collection, 2, iterator);
});
});
it('should avoid double callback', function(done) {
var called = false;
async.groupByLimit([1, 2, 3], 2, function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
done();
}
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = [];
async.groupByLimit(array, 2, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = {};
async.groupByLimit(object, 2, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.groupByLimit(function() {}, 2, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.groupByLimit(undefined, 2, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.groupByLimit(null, 2, groupByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
});
neo-async-2.6.1/test/collections/test.map.js 0000664 0000000 0000000 00000104723 13466145133 0021017 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var domain = require('domain');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
var util = require('../util');
function mapIterator(order) {
return function(value, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
order.push(value);
callback(null, num * 2);
}, num * delay);
};
}
function mapIteratorWithKey(order) {
return function(value, key, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
order.push([value, key]);
callback(null, num * 2);
}, num * delay);
};
}
parallel('#map', function() {
it('should execute iterator by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2];
async.map(collection, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2, 6, 4]);
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should execute iterator by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2];
async.map(collection, mapIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2, 6, 4]);
assert.deepStrictEqual(order, [[1, 0], [2, 2], [3, 1]]);
done();
});
});
it('should execute iterator by collection of object', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2
};
async.map(collection, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2, 6, 4]);
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should execute iterator by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2
};
async.map(collection, mapIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2, 6, 4]);
assert.deepStrictEqual(order, [[1, 'a'], [2, 'c'], [3, 'b']]);
done();
});
});
it('should execute iterator by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(3);
set.add(2);
async.map(set, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2, 6, 4]);
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should execute iterator by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(3);
set.add(2);
async.map(set, mapIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2, 6, 4]);
assert.deepStrictEqual(order, [[1, 0], [2, 2], [3, 1]]);
done();
});
});
it('should work properly even if elements are added in callback', function(done) {
var order = [];
var arr = [1, 3, 2];
var set = new util.Set(arr);
var iterator = function(value, next) {
order.push(value);
next(null, value);
};
async.map(set, iterator, function(err, res) {
if (err) {
return done(err);
}
setTimeout(function() {
assert.deepStrictEqual(order, arr);
assert.deepStrictEqual(res, arr);
done();
}, delay);
set.add(4);
});
});
it('shoult work even if the size is decreased', function(done) {
var order = [];
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next(null, value);
};
async.map(set, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3]);
assert.deepStrictEqual(res, [1, 3]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next(null, value);
};
async.map(set, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [1, 2, 3, 4, 5, 6, 7]);
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator by collection of Map', function(done) {
var order = [];
var collection = new util.Map();
collection.set('a', 1);
collection.set('b', 3);
collection.set('c', 2);
async.map(collection, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2, 6, 4]);
assert.deepStrictEqual(order, [['a', 1], ['c', 2], ['b', 3]]);
done();
});
});
it('should execute iterator by collection of Map with passing key', function(done) {
var order = [];
var collection = new util.Map();
collection.set('a', 1);
collection.set('b', 3);
collection.set('c', 2);
async.map(collection, mapIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2, 6, 4]);
assert.deepStrictEqual(order, [[['a', 1], 0], [['c', 2], 2], [['b', 3], 1]]);
done();
});
});
it('should execute iterator without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.7
};
async.map(
collection,
mapIterator(order),
function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2.2, 7, 5.4]);
assert.deepStrictEqual(order, [1.1, 2.7, 3.5]);
done();
},
Math
);
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, num);
}, num * delay);
};
async.map(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, undefined, 2, undefined]);
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 2);
done();
}, delay);
domain
.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3];
var iterator = function(num, callback) {
process.nextTick(function() {
callback(null, num);
});
process.nextTick(function() {
callback(null, num);
});
};
async.map(collection, iterator);
});
});
it('should avoid double callback', function(done) {
var called = {
iterator: false,
callback: false
};
async.map(
[1, 2],
function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch (e) {
assert.ok(e);
assert.strictEqual(called.iterator, false);
util.errorChecker(e);
called.iterator = true;
}
}
},
function(err) {
assert.ok(err);
assert.strictEqual(called.callback, false);
called.callback = true;
async.nothing();
}
);
setTimeout(done, delay);
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = [];
async.map(array, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = {};
async.map(object, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.map(function() {}, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.map(undefined, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.map(null, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
});
parallel('#mapSeries', function() {
it('should execute iterator to series by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2];
async.mapSeries(collection, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2, 6, 4]);
assert.deepStrictEqual(order, [1, 3, 2]);
done();
});
});
it('should execute iterator to series by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2];
async.mapSeries(collection, mapIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2, 6, 4]);
assert.deepStrictEqual(order, [[1, 0], [3, 1], [2, 2]]);
done();
});
});
it('should execute iterator to series by collection of object', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2
};
async.mapSeries(collection, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2, 6, 4]);
assert.deepStrictEqual(order, [1, 3, 2]);
done();
});
});
it('should execute iterator to series by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2
};
async.mapSeries(collection, mapIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2, 6, 4]);
assert.deepStrictEqual(order, [[1, 'a'], [3, 'b'], [2, 'c']]);
done();
});
});
it('should execute iterator to series by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(3);
set.add(2);
async.mapSeries(set, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2, 6, 4]);
assert.deepStrictEqual(order, [1, 3, 2]);
done();
});
});
it('should execute iterator to series by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(3);
set.add(2);
async.mapSeries(set, mapIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2, 6, 4]);
assert.deepStrictEqual(order, [[1, 0], [3, 1], [2, 2]]);
done();
});
});
it('should work properly even if elements are added in callback', function(done) {
var order = [];
var arr = [1, 3, 2];
var set = new util.Set(arr);
var iterator = function(value, next) {
order.push(value);
next(null, value);
};
async.mapSeries(set, iterator, function(err, res) {
if (err) {
return done(err);
}
setTimeout(function() {
assert.deepStrictEqual(order, arr);
assert.deepStrictEqual(res, arr);
done();
}, delay);
set.add(4);
});
});
it('shoult work even if the size is decreased', function(done) {
var order = [];
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next(null, value);
};
async.mapSeries(set, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3]);
assert.deepStrictEqual(res, [1, 3]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next(null, value);
};
async.mapSeries(set, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [1, 2, 3, 4, 5, 6, 7]);
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator to series by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 3);
map.set('c', 2);
async.mapSeries(map, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2, 6, 4]);
assert.deepStrictEqual(order, [['a', 1], ['b', 3], ['c', 2]]);
done();
});
});
it('should execute iterator to series by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 3);
map.set('c', 2);
async.mapSeries(map, mapIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2, 6, 4]);
assert.deepStrictEqual(order, [[['a', 1], 0], [['b', 3], 1], [['c', 2], 2]]);
done();
});
});
it('should execute iterator to series without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.7
};
async.mapSeries(
collection,
mapIterator(order),
function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2.2, 7, 5.4]);
assert.deepStrictEqual(order, [1.1, 3.5, 2.7]);
done();
},
Math
);
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = {
a: 1,
b: 3,
c: 2
};
var iterator = function(n, callback) {
callback(null, n);
};
async.mapSeries(collection, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3, 2]);
done();
});
sync = false;
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, num);
}, num * delay);
};
async.mapSeries(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, undefined, undefined, undefined]);
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 2);
done();
}, delay);
domain
.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3];
var iterator = function(num, callback) {
process.nextTick(function() {
callback(null, num);
});
process.nextTick(function() {
callback(null, num);
});
};
async.mapSeries(collection, iterator);
});
});
it('should avoid double callback', function(done) {
var called = false;
async.mapSeries(
[1, 2],
function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch (e) {
assert.ok(e);
util.errorChecker(e);
done();
}
}
},
function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
}
);
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = [];
async.mapSeries(array, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = {};
async.mapSeries(object, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.mapSeries(function() {}, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.mapSeries(undefined, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.mapSeries(null, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
});
parallel('#mapLimit', function() {
it('should execute iterator in limited by collection of array', function(done) {
var order = [];
var collection = [1, 5, 3, 4, 2];
async.mapLimit(collection, 2, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2, 10, 6, 8, 4]);
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator in limited by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 5, 3, 4, 2];
async.mapLimit(collection, 2, mapIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2, 10, 6, 8, 4]);
assert.deepStrictEqual(order, [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]);
done();
});
});
it('should execute iterator in limited by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(5);
set.add(3);
set.add(4);
set.add(2);
async.mapLimit(set, 2, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2, 10, 6, 8, 4]);
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator in limited by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(5);
set.add(3);
set.add(4);
set.add(2);
async.mapLimit(set, 2, mapIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2, 10, 6, 8, 4]);
assert.deepStrictEqual(order, [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next();
};
async.mapLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should work with odd number of elements even if the size is decreased', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5]);
var iterator = function(value, index, next) {
order.push([index, value]);
set.delete(value + 1);
next();
};
async.mapLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [[0, 1], [1, 3], [2, 5]]);
done();
});
});
it('should work with even number of elements even if the size is decreased', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5, 6]);
var iterator = function(value, index, next) {
order.push([index, value]);
set.delete(value + 1);
next();
};
async.mapLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [[0, 1], [1, 3], [2, 5]]);
done();
});
});
it('should execute iterator in limited by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 5);
map.set('c', 3);
map.set('d', 4);
map.set('e', 2);
async.mapLimit(map, 2, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2, 10, 6, 8, 4]);
assert.deepStrictEqual(order, [['a', 1], ['c', 3], ['b', 5], ['e', 2], ['d', 4]]);
done();
});
});
it('should execute iterator in limited by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 5);
map.set('c', 3);
map.set('d', 4);
map.set('e', 2);
async.mapLimit(map, 2, mapIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2, 10, 6, 8, 4]);
assert.deepStrictEqual(order, [
[['a', 1], 0],
[['c', 3], 2],
[['b', 5], 1],
[['e', 2], 4],
[['d', 4], 3]
]);
done();
});
});
it('should execute iterator in limited by collection of object', function(done) {
var order = [];
var collection = {
a: 1,
b: 5,
c: 3,
d: 4,
e: 2
};
async.mapLimit(collection, 2, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2, 10, 6, 8, 4]);
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator in limited by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 1,
b: 5,
c: 3,
d: 4,
e: 2
};
async.mapLimit(collection, 2, mapIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2, 10, 6, 8, 4]);
assert.deepStrictEqual(order, [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]);
done();
});
});
it('should execute iterator in limited without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.7
};
async.mapLimit(
collection,
2,
mapIterator(order),
function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2.2, 7, 5.4]);
assert.deepStrictEqual(order, [1.1, 3.5, 2.7]);
done();
},
Math
);
});
it('should execute like parallel if limit is Infinity', function(done) {
var order = [];
var collection = [1, 3, 4, 2, 3];
async.mapLimit(collection, Infinity, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2, 6, 8, 4, 6]);
assert.deepStrictEqual(order, [1, 2, 3, 3, 4]);
done();
});
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = {
a: 1,
b: 5,
c: 3,
d: 4,
e: 2
};
var iterator = function(n, callback) {
callback(null, n);
};
async.mapLimit(collection, 2, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 5, 3, 4, 2]);
done();
});
sync = false;
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 5, 2, 4, 2];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, num);
}, num * delay);
};
async.mapLimit(collection, 4, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, undefined, undefined, 2, undefined, undefined]);
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain
.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3, 2];
var iterator = function(num, callback) {
process.nextTick(function() {
callback(null, num);
});
process.nextTick(function() {
callback(null, num);
});
};
async.mapLimit(collection, 2, iterator);
});
});
it('should avoid double callback', function(done) {
var called = false;
async.mapLimit(
[1, 2],
2,
function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch (e) {
assert.ok(e);
util.errorChecker(e);
done();
}
}
},
function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
}
);
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = [];
async.mapLimit(array, 3, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = {};
async.mapLimit(object, 2, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.mapLimit(function() {}, 3, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.mapLimit(undefined, 3, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.mapLimit(null, 3, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if limit is zero', function(done) {
var order = [];
var collection = [1, 3, 2];
async.mapLimit(collection, 0, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if limit is undefined', function(done) {
var order = [];
var collection = [1, 3, 2];
async.mapLimit(collection, undefined, mapIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
/**
* @see https://github.com/suguru03/neo-async/issues/69
*/
it('should work with generator', function(done) {
var limit = 2;
var collection = ['abc', 'def', 'ghi', 'jkl'];
var gen = util.makeGenerator(collection);
async.mapLimit(
gen,
limit,
function(v, cb) {
setTimeout(cb, Math.random() * delay, null, v);
},
function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, collection);
done();
}
);
});
});
neo-async-2.6.1/test/collections/test.mapValues.js 0000664 0000000 0000000 00000106232 13466145133 0022174 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var domain = require('domain');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
var util = require('../util');
function mapValuesIterator(order) {
return function(value, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
order.push(value);
callback(null, num * 2);
}, num * delay);
};
}
function mapValuesIteratorWithKey(order) {
return function(value, key, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
order.push([value, key]);
callback(null, num * 2);
}, num * delay);
};
}
parallel('#mapValues', function() {
it('should execute iterator by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2];
async.mapValues(collection, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 2,
'1': 6,
'2': 4
});
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should execute iterator by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2];
async.mapValues(collection, mapValuesIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 2,
'1': 6,
'2': 4
});
assert.deepStrictEqual(order, [
[1, 0],
[2, 2],
[3, 1]
]);
done();
});
});
it('should execute iterator by collection of object', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2
};
async.mapValues(collection, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 2,
b: 6,
c: 4
});
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should execute iterator by collection of object with key', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2
};
async.mapValues(collection, mapValuesIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 2,
b: 6,
c: 4
});
assert.deepStrictEqual(order, [
[1, 'a'],
[2, 'c'],
[3, 'b']
]);
done();
});
});
it('should execute iterator to series by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(3);
set.add(2);
async.mapValues(set, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 2,
'1': 6,
'2': 4
});
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should execute iterator to series by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(3);
set.add(2);
async.mapValues(set, mapValuesIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 2,
'1': 6,
'2': 4
});
assert.deepStrictEqual(order, [
[1, 0],
[2, 2],
[3, 1]
]);
done();
});
});
it('shoult work even if the size is decreased', function(done) {
var order = [];
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next(null, value);
};
async.mapValues(set, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3]);
assert.deepStrictEqual(res, { '0': 1, '1': 3 });
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next(null, value);
};
async.mapValues(set, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
assert.deepStrictEqual(res, { '0': 1, '1': 2, '2': 3, '3': 4, '4': 5, '5': 6, '6': 7 });
done();
});
});
it('should execute iterator to series by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 3);
map.set('c', 2);
async.mapValues(map, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 2,
'1': 6,
'2': 4
});
assert.deepStrictEqual(order, [
['a', 1],
['c', 2],
['b', 3]
]);
done();
});
});
it('should execute iterator to series by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 3);
map.set('c', 2);
async.mapValues(map, mapValuesIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 2,
'1': 6,
'2': 4
});
assert.deepStrictEqual(order, [
[['a', 1], 0],
[['c', 2], 2],
[['b', 3], 1]
]);
done();
});
});
it('should execute iterator without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.7
};
async.mapValues(collection, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 2.2,
b: 7,
c: 5.4
});
assert.deepStrictEqual(order, [1.1, 2.7, 3.5]);
done();
}, Math);
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, num);
}, num * delay);
};
async.mapValues(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 1,
'2': 2
});
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 2);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3];
var iterator = function(num, callback) {
process.nextTick(function() {
callback(null, num);
});
process.nextTick(function() {
callback(null, num);
});
};
async.mapValues(collection, iterator);
});
});
it('should avoid double callback', function(done) {
var called = false;
async.mapValues([1, 2, 3], function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
done();
}
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = [];
async.mapValues(array, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = {};
async.mapValues(object, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.mapValues(function() {}, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.mapValues(undefined, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.mapValues(null, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
});
parallel('#mapValuesSeries', function() {
it('should execute iterator to series by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2];
async.mapValuesSeries(collection, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 2,
'1': 6,
'2': 4
});
assert.deepStrictEqual(order, [1, 3, 2]);
done();
});
});
it('should execute iterator to series by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2];
async.mapValuesSeries(collection, mapValuesIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 2,
'1': 6,
'2': 4
});
assert.deepStrictEqual(order, [
[1, 0],
[3, 1],
[2, 2]
]);
done();
});
});
it('should execute iterator to series by collection of object', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2
};
async.mapValuesSeries(collection, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 2,
b: 6,
c: 4
});
assert.deepStrictEqual(order, [1, 3, 2]);
done();
});
});
it('should execute iterator to series by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2
};
async.mapValuesSeries(collection, mapValuesIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 2,
b: 6,
c: 4
});
assert.deepStrictEqual(order, [
[1, 'a'],
[3, 'b'],
[2, 'c']
]);
done();
});
});
it('should execute iterator by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(3);
set.add(2);
async.mapValuesSeries(set, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 2,
'1': 6,
'2': 4
});
assert.deepStrictEqual(order, [1, 3, 2]);
done();
});
});
it('should execute iterator by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(3);
set.add(2);
async.mapValuesSeries(set, mapValuesIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 2,
'1': 6,
'2': 4
});
assert.deepStrictEqual(order, [
[1, 0],
[3, 1],
[2, 2]
]);
done();
});
});
it('shoult work even if the size is decreased', function(done) {
var order = [];
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next(null, value);
};
async.mapValuesSeries(set, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3]);
assert.deepStrictEqual(res, { '0': 1, '1': 3 });
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next(null, value);
};
async.mapValuesSeries(set, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
assert.deepStrictEqual(res, { '0': 1, '1': 2, '2': 3, '3': 4, '4': 5, '5': 6, '6': 7 });
done();
});
});
it('should execute iterator by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 3);
map.set('c', 2);
async.mapValuesSeries(map, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 2,
'1': 6,
'2': 4
});
assert.deepStrictEqual(order, [
['a', 1],
['b', 3],
['c', 2]
]);
done();
});
});
it('should execute iterator by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 3);
map.set('c', 2);
async.mapValuesSeries(map, mapValuesIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 2,
'1': 6,
'2': 4
});
assert.deepStrictEqual(order, [
[['a', 1], 0],
[['b', 3], 1],
[['c', 2], 2]
]);
done();
});
});
it('should execute iterator to series without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.7
};
async.mapValuesSeries(collection, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 2.2,
b: 7,
c: 5.4
});
assert.deepStrictEqual(order, [1.1, 3.5, 2.7]);
done();
}, Math);
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = {
a: 1,
b: 3,
c: 2
};
var iterator = function(n, callback) {
callback(null, n);
};
async.mapValuesSeries(collection, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 1,
b: 3,
c: 2
});
done();
});
sync = false;
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, num);
}, num * delay);
};
async.mapValuesSeries(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 1
});
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 2);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3];
var iterator = function(num, callback) {
process.nextTick(function() {
callback(null, num);
});
process.nextTick(function() {
callback(null, num);
});
};
async.mapValuesSeries(collection, iterator);
});
});
it('should avoid double callback', function(done) {
var called = false;
async.mapValuesSeries([1, 2, 3], function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
done();
}
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = [];
async.mapValuesSeries(array, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = {};
async.mapValuesSeries(object, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.mapValuesSeries(function() {}, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.mapValuesSeries(undefined, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.mapValuesSeries(null, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
});
parallel('#mapValuesLimit', function() {
it('should execute iterator in limited by collection of array', function(done) {
var order = [];
var collection = [1, 5, 3, 4, 2];
async.mapValuesLimit(collection, 2, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 2,
'1': 10,
'2': 6,
'3': 8,
'4': 4
});
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator in limited by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 5, 3, 4, 2];
async.mapValuesLimit(collection, 2, mapValuesIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 2,
'1': 10,
'2': 6,
'3': 8,
'4': 4
});
assert.deepStrictEqual(order, [
[1, 0],
[3, 2],
[5, 1],
[2, 4],
[4, 3]
]);
done();
});
});
it('should execute iterator in limited by collection of object', function(done) {
var order = [];
var collection = {
a: 1,
b: 5,
c: 3,
d: 4,
e: 2
};
async.mapValuesLimit(collection, 2, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 2,
b: 10,
c: 6,
d: 8,
e: 4
});
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator in limited by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 1,
b: 5,
c: 3,
d: 4,
e: 2
};
async.mapValuesLimit(collection, 2, mapValuesIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 2,
b: 10,
c: 6,
d: 8,
e: 4
});
assert.deepStrictEqual(order, [
[1, 'a'],
[3, 'c'],
[5, 'b'],
[2, 'e'],
[4, 'd']
]);
done();
});
});
it('should execute iterator in limited by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(5);
set.add(3);
set.add(4);
set.add(2);
async.mapValuesLimit(set, 2, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 2,
'1': 10,
'2': 6,
'3': 8,
'4': 4
});
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator in limited by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(5);
set.add(3);
set.add(4);
set.add(2);
async.mapValuesLimit(set, 2, mapValuesIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 2,
'1': 10,
'2': 6,
'3': 8,
'4': 4
});
assert.deepStrictEqual(order, [
[1, 0],
[3, 2],
[5, 1],
[2, 4],
[4, 3]
]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next();
};
async.mapValuesLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should work with odd number of elements even if the size is decreased', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5]);
var iterator = function(value, index, next) {
order.push([index, value]);
set.delete(value + 1);
next();
};
async.mapValuesLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [[0, 1], [1, 3], [2, 5]]);
done();
});
});
it('should work with even number of elements even if the size is decreased', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5, 6]);
var iterator = function(value, index, next) {
order.push([index, value]);
set.delete(value + 1);
next();
};
async.mapValuesLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [[0, 1], [1, 3], [2, 5]]);
done();
});
});
it('should execute iterator in limited by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 5);
map.set('c', 3);
map.set('d', 4);
map.set('e', 2);
async.mapValuesLimit(map, 2, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 2,
'1': 10,
'2': 6,
'3': 8,
'4': 4
});
assert.deepStrictEqual(order, [
['a', 1],
['c', 3],
['b', 5],
['e', 2],
['d', 4]
]);
done();
});
});
it('should execute iterator in limited by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 5);
map.set('c', 3);
map.set('d', 4);
map.set('e', 2);
async.mapValuesLimit(map, 2, mapValuesIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 2,
'1': 10,
'2': 6,
'3': 8,
'4': 4
});
assert.deepStrictEqual(order, [
[['a', 1], 0],
[['c', 3], 2],
[['b', 5], 1],
[['e', 2], 4],
[['d', 4], 3]
]);
done();
});
});
it('should execute iterator without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.7
};
async.mapValuesLimit(collection, 2, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 2.2,
b: 7,
c: 5.4
});
assert.deepStrictEqual(order, [1.1, 3.5, 2.7]);
done();
}, Math);
});
it('should execute like parallel if limit is Infinity', function(done) {
var order = [];
var collection = [1, 3, 4, 2, 3];
async.mapValuesLimit(collection, Infinity, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 2,
'1': 6,
'2': 8,
'3': 4,
'4': 6
});
assert.deepStrictEqual(order, [1, 2, 3, 3, 4]);
done();
});
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = [1, 3, 4, 2, 3];
var iterator = function(n, callback) {
callback(null, n);
};
async.mapValuesLimit(collection, 2, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 1,
'1': 3,
'2': 4,
'3': 2,
'4': 3
});
done();
});
sync = false;
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 5, 2, 4, 2];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, num);
}, num * delay);
};
async.mapValuesLimit(collection, 4, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 1,
'3': 2
});
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3, 2];
var iterator = function(num, callback) {
process.nextTick(function() {
callback(null, num);
});
process.nextTick(function() {
callback(null, num);
});
};
async.mapValuesLimit(collection, 2, iterator);
});
});
it('should avoid double callback', function(done) {
var called = false;
async.mapValuesLimit([1, 2], 2, function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
done();
}
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = [];
async.mapValuesLimit(array, 3, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = {};
async.mapValuesLimit(object, 2, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.mapValuesLimit(function() {}, 3, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.mapValuesLimit(undefined, 3, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.mapValuesLimit(null, 3, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if limit is zero', function(done) {
var order = [];
var collection = [1, 3, 2];
async.mapValuesLimit(collection, 0, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if limit is undefined', function(done) {
var order = [];
var collection = [1, 3, 2];
async.mapValuesLimit(collection, undefined, mapValuesIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
});
neo-async-2.6.1/test/collections/test.omit.js 0000664 0000000 0000000 00000115071 13466145133 0021210 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var domain = require('domain');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
var util = require('../util');
function omitIterator(order) {
return function(value, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
order.push(value);
callback(null, num % 2);
}, num * delay);
};
}
function omitIteratorWithKey(order) {
return function(value, key, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
order.push([value, key]);
callback(null, num % 2);
}, num * delay);
};
}
parallel('#omit', function() {
it('should execute iterator by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.omit(collection, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'2': 2,
'3': 4
});
assert.deepStrictEqual(order, [1, 2, 3, 4]);
done();
});
});
it('should execute iterator by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.omit(collection, omitIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'2': 2,
'3': 4
});
assert.deepStrictEqual(order, [
[1, 0],
[2, 2],
[3, 1],
[4, 3]
]);
done();
});
});
it('should execute iterator by collection of object', function(done) {
var order = [];
var collection = {
a: 4,
b: 3,
c: 2
};
async.omit(collection, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 4,
c: 2
});
assert.deepStrictEqual(order, [2, 3, 4]);
done();
});
});
it('should execute iterator by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 4,
b: 3,
c: 2
};
async.omit(collection, omitIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 4,
c: 2
});
assert.deepStrictEqual(order, [
[2, 'c'],
[3, 'b'],
[4, 'a']
]);
done();
});
});
it('should execute iterator by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(4);
set.add(3);
set.add(2);
async.omit(set, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 4,
'2': 2
});
assert.deepStrictEqual(order, [2, 3, 4]);
done();
});
});
it('should execute iterator by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(4);
set.add(3);
set.add(2);
async.omit(set, omitIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 4,
'2': 2
});
assert.deepStrictEqual(order, [
[2, 2],
[3, 1],
[4, 0]
]);
done();
});
});
it('should execute iterator by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 4);
map.set('b', 3);
map.set('c', 2);
async.omit(map, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': ['a', 4],
'2': ['c', 2]
});
assert.deepStrictEqual(order, [
['c', 2],
['b', 3],
['a', 4]
]);
done();
});
});
it('should execute iterator by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 4);
map.set('b', 3);
map.set('c', 2);
async.omit(map, omitIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': ['a', 4],
'2': ['c', 2]
});
assert.deepStrictEqual(order, [
[['c', 2], 2],
[['b', 3], 1],
[['a', 4], 0]
]);
done();
});
});
it('should execute iterator without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.6
};
async.omit(collection, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, [1.1, 2.6, 3.5]);
done();
}, Math);
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, num % 2);
}, num * delay);
};
async.omit(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'2': 2
});
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should throw error', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2,
d: 4
};
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, num % 2);
}, num * delay);
};
async.omit(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
c: 2
});
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [2, 1, 3];
var iterator = function(item, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.omit(collection, iterator);
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [2, 1, 3];
var iterator = function(item, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.omit(collection, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 2,
'1': 1,
'2': 3
});
});
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = {
a: 4,
b: 3,
c: 2
};
var iterator = function(item, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.omit(collection, iterator);
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = {
a: 4,
b: 3,
c: 2
};
var iterator = function(item, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.omit(collection, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 4,
b: 3,
c: 2
});
});
});
});
it('should avoid double callback', function(done) {
var called = false;
async.omit([1, 2, 3], function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
done();
}
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = [];
async.omit(array, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = {};
async.omit(object, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.omit(function() {}, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.omit(undefined, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.omit(null, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
});
parallel('#omitSeries', function() {
it('should execute iterator to series by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.omitSeries(collection, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'2': 2,
'3': 4
});
assert.deepStrictEqual(order, [1, 3, 2, 4]);
done();
});
});
it('should execute iterator to series by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.omitSeries(collection, omitIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'2': 2,
'3': 4
});
assert.deepStrictEqual(order, [
[1, 0],
[3, 1],
[2, 2],
[4, 3]
]);
done();
});
});
it('should execute iterator to series by collection of object', function(done) {
var order = [];
var collection = {
a: 4,
b: 3,
c: 2
};
async.omitSeries(collection, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 4,
c: 2
});
assert.deepStrictEqual(order, [4, 3, 2]);
done();
});
});
it('should execute iterator to series by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 4,
b: 3,
c: 2
};
async.omitSeries(collection, omitIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 4,
c: 2
});
assert.deepStrictEqual(order, [
[4, 'a'],
[3, 'b'],
[2, 'c']
]);
done();
});
});
it('should execute iterator to series by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(4);
set.add(3);
set.add(2);
async.omitSeries(set, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 4,
'2': 2
});
assert.deepStrictEqual(order, [4, 3, 2]);
done();
});
});
it('should execute iterator to series by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(4);
set.add(3);
set.add(2);
async.omitSeries(set, omitIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 4,
'2': 2
});
assert.deepStrictEqual(order, [
[4, 0],
[3, 1],
[2, 2]
]);
done();
});
});
it('should execute iterator to series by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 4);
map.set('b', 3);
map.set('c', 2);
async.omitSeries(map, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': ['a', 4],
'2': ['c', 2]
});
assert.deepStrictEqual(order, [
['a', 4],
['b', 3],
['c', 2]
]);
done();
});
});
it('should execute iterator to series by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 4);
map.set('b', 3);
map.set('c', 2);
async.omitSeries(map, omitIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': ['a', 4],
'2': ['c', 2]
});
assert.deepStrictEqual(order, [
[['a', 4], 0],
[['b', 3], 1],
[['c', 2], 2]
]);
done();
});
});
it('should execute iterator to series without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.6
};
async.omitSeries(collection, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, [1.1, 3.5, 2.6]);
done();
}, Math);
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = {
a: 1,
b: 3,
c: 2
};
var iterator = function(n, key, callback) {
callback(null, n % 2);
};
async.omitSeries(collection, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.deepStrictEqual(res, {
c: 2
});
done();
});
sync = false;
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, num % 2);
}, num * delay);
};
async.omitSeries(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should throw error', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2,
d: 4
};
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, num % 2);
}, num * delay);
};
async.omitSeries(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [2, 1, 3];
var iterator = function(item, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.omitSeries(collection, iterator);
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [2, 1, 3];
var iterator = function(item, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.omitSeries(collection, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 2,
'1': 1,
'2': 3
});
});
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = {
a: 4,
b: 3,
c: 2
};
var iterator = function(item, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.omitSeries(collection, iterator);
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = {
a: 4,
b: 3,
c: 2
};
var iterator = function(item, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.omitSeries(collection, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 4,
b: 3,
c: 2
});
});
});
});
it('should avoid double callback', function(done) {
var called = false;
async.omitSeries([1, 2, 3], function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
done();
}
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = [];
async.omitSeries(array, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = {};
async.omitSeries(object, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.omitSeries(function() {}, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.omitSeries(undefined, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.omitSeries(null, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
});
parallel('#omitLimit', function() {
it('should execute iterator in limited by collection of array', function(done) {
var order = [];
var collection = [1, 5, 3, 2, 4];
async.omitLimit(collection, 2, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'3': 2,
'4': 4
});
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator in limited by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 5, 3, 2, 4];
async.omitLimit(collection, 2, omitIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'3': 2,
'4': 4
});
assert.deepStrictEqual(order, [
[1, 0],
[3, 2],
[5, 1],
[2, 3],
[4, 4]
]);
done();
});
});
it('should execute iterator in limited by collection of object', function(done) {
var order = [];
var collection = {
a: 1,
b: 5,
c: 3,
d: 2,
e: 4
};
async.omitLimit(collection, 2, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
d: 2,
e: 4
});
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator in limited by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 1,
b: 5,
c: 3,
d: 2,
e: 4
};
async.omitLimit(collection, 2, omitIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
d: 2,
e: 4
});
assert.deepStrictEqual(order, [
[1, 'a'],
[3, 'c'],
[5, 'b'],
[2, 'd'],
[4, 'e']
]);
done();
});
});
it('should execute iterator in limited by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(5);
set.add(3);
set.add(2);
set.add(4);
async.omitLimit(set, 2, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'3': 2,
'4': 4
});
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator in limited by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(5);
set.add(3);
set.add(2);
set.add(4);
async.omitLimit(set, 2, omitIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'3': 2,
'4': 4
});
assert.deepStrictEqual(order, [
[1, 0],
[3, 2],
[5, 1],
[2, 3],
[4, 4]
]);
done();
});
});
it('should execute iterator in limited by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 5);
map.set('c', 3);
map.set('d', 2);
map.set('e', 4);
async.omitLimit(map, 2, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'3': ['d', 2],
'4': ['e', 4]
});
assert.deepStrictEqual(order, [
['a', 1],
['c', 3],
['b', 5],
['d', 2],
['e', 4]
]);
done();
});
});
it('should execute iterator in limited by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 5);
map.set('c', 3);
map.set('d', 2);
map.set('e', 4);
async.omitLimit(map, 2, omitIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'3': ['d', 2],
'4': ['e', 4]
});
assert.deepStrictEqual(order, [
[['a', 1], 0],
[['c', 3], 2],
[['b', 5], 1],
[['d', 2], 3],
[['e', 4], 4]
]);
done();
});
});
it('should execute iterator in limited without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.7
};
async.omitLimit(collection, 2, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, [1.1, 3.5, 2.7]);
done();
}, Math);
});
it('should execute like parallel if limit is Infinity', function(done) {
var order = [];
var collection = [1, 3, 4, 2, 3, 1, 3];
async.omitLimit(collection, Infinity, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'2': 4,
'3': 2
});
assert.deepStrictEqual(order, [1, 1, 2, 3, 3, 3, 4]);
done();
});
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = {
a: 1,
b: 3,
c: 2,
d: 4,
e: 5
};
var iterator = function(n, key, callback) {
callback(null, n % 2);
};
async.omitLimit(collection, 2, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.deepStrictEqual(res, {
c: 2,
d: 4
});
done();
});
sync = false;
});
it('should throw error', function(done) {
var order = [];
var collection = {
a: 2,
b: 1,
c: 3
};
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 2, num);
}, num * delay);
};
async.omitLimit(collection, 4, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, [1, 2]);
done();
});
});
it('should throw error', function(done) {
var order = [];
var collection = [2, 1, 3];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 2, num);
}, num * delay);
};
async.omitLimit(collection, 4, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, [1, 2]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [2, 1, 3];
var iterator = function(item, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.omitLimit(collection, 4, iterator);
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [2, 1, 3];
var iterator = function(item, index, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.omitLimit(collection, 4, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 2,
'1': 1,
'2': 3
});
});
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = {
a: 2,
b: 1,
c: 3
};
var iterator = function(item, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.omitLimit(collection, 4, iterator);
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = {
a: 2,
b: 1,
c: 3
};
var iterator = function(item, index, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.omitLimit(collection, 4, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 2,
b: 1,
c: 3
});
});
});
});
it('should avoid double callback', function(done) {
var called = false;
async.omitLimit([1, 2, 3], 2, function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
done();
}
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = [];
async.omitLimit(array, 3, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = {};
async.omitLimit(object, 2, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.omitLimit(function() {}, 2, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.omitLimit(undefined, 2, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.omitLimit(null, 2, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if limit is zero', function(done) {
var order = [];
var collection = [1, 3, 2];
async.omitLimit(collection, 0, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if limit is undefined', function(done) {
var order = [];
var collection = [1, 3, 2];
async.omitLimit(collection, undefined, omitIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
});
neo-async-2.6.1/test/collections/test.pick.js 0000664 0000000 0000000 00000123200 13466145133 0021157 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var domain = require('domain');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
var util = require('../util');
function pickIterator(order) {
return function(value, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
order.push(value);
callback(null, num % 2);
}, num * delay);
};
}
function pickIteratorWithKey(order) {
return function(value, key, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
order.push([value, key]);
callback(null, num % 2);
}, num * delay);
};
}
parallel('#pick', function() {
it('should execute iterator by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.pick(collection, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 1,
'1': 3
});
assert.deepStrictEqual(order, [1, 2, 3, 4]);
done();
});
});
it('should execute iterator by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.pick(collection, pickIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 1,
'1': 3
});
assert.deepStrictEqual(order, [
[1, 0],
[2, 2],
[3, 1],
[4, 3]
]);
done();
});
});
it('should execute iterator by collection of object', function(done) {
var order = [];
var collection = {
a: 4,
b: 3,
c: 2
};
async.pick(collection, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
b: 3
});
assert.deepStrictEqual(order, [2, 3, 4]);
done();
});
});
it('should execute iterator by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 4,
b: 3,
c: 2
};
async.pick(collection, pickIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
b: 3
});
assert.deepStrictEqual(order, [
[2, 'c'],
[3, 'b'],
[4, 'a']
]);
done();
});
});
it('should execute iterator by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(4);
set.add(3);
set.add(2);
async.pick(set, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'1': 3
});
assert.deepStrictEqual(order, [2, 3, 4]);
done();
});
});
it('should execute iterator by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(4);
set.add(3);
set.add(2);
async.pick(set, pickIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'1': 3
});
assert.deepStrictEqual(order, [
[2, 2],
[3, 1],
[4, 0]
]);
done();
});
});
it('should work even if the size is decreased', function(done) {
var order = [];
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.pick(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next();
};
async.pick(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 4);
map.set('b', 3);
map.set('c', 2);
async.pick(map, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'1': ['b', 3]
});
assert.deepStrictEqual(order, [
['c', 2],
['b', 3],
['a', 4]
]);
done();
});
});
it('should execute iterator by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 4);
map.set('b', 3);
map.set('c', 2);
async.pick(map, pickIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'1': ['b', 3]
});
assert.deepStrictEqual(order, [
[['c', 2], 2],
[['b', 3], 1],
[['a', 4], 0]
]);
done();
});
});
it('should execute iterator without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.6
};
async.pick(collection, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 1.1,
b: 3.5,
c: 2.6
});
assert.deepStrictEqual(order, [1.1, 2.6, 3.5]);
done();
}, Math);
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, num % 2);
}, num * delay);
};
async.pick(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 1
});
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should throw error', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2,
d: 4
};
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, num % 2);
}, num * delay);
};
async.pick(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 1
});
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [2, 1, 3];
var iterator = function(item, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.pick(collection, iterator);
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [2, 1, 3];
var iterator = function(item, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.pick(collection, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
});
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = {
a: 4,
b: 3,
c: 2
};
var iterator = function(item, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.pick(collection, iterator);
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = {
a: 4,
b: 3,
c: 2
};
var iterator = function(item, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.pick(collection, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
});
});
});
it('should avoid double callback', function(done) {
var called = false;
async.pick([1, 2, 3], function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
done();
}
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = [];
async.pick(array, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = {};
async.pick(object, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.pick(function() {}, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.pick(undefined, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.pick(null, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
});
parallel('#pickSeries', function() {
it('should execute iterator to series by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.pickSeries(collection, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 1,
'1': 3
});
assert.deepStrictEqual(order, [1, 3, 2, 4]);
done();
});
});
it('should execute iterator to series by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.pickSeries(collection, pickIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 1,
'1': 3
});
assert.deepStrictEqual(order, [
[1, 0],
[3, 1],
[2, 2],
[4, 3]
]);
done();
});
});
it('should execute iterator to series by collection of object', function(done) {
var order = [];
var collection = {
a: 4,
b: 3,
c: 2
};
async.pickSeries(collection, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
b: 3
});
assert.deepStrictEqual(order, [4, 3, 2]);
done();
});
});
it('should execute iterator to series by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 4,
b: 3,
c: 2
};
async.pickSeries(collection, pickIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
b: 3
});
assert.deepStrictEqual(order, [
[4, 'a'],
[3, 'b'],
[2, 'c']
]);
done();
});
});
it('should execute iterator to series by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(4);
set.add(3);
set.add(2);
async.pickSeries(set, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'1': 3
});
assert.deepStrictEqual(order, [4, 3, 2]);
done();
});
});
it('should execute iterator to series by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(4);
set.add(3);
set.add(2);
async.pickSeries(set, pickIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'1': 3
});
assert.deepStrictEqual(order, [
[4, 0],
[3, 1],
[2, 2]
]);
done();
});
});
it('should work even if the size is decreased', function(done) {
var order = [];
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.pickSeries(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next();
};
async.pickSeries(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator to series by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 4);
map.set('b', 3);
map.set('c', 2);
async.pickSeries(map, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'1': ['b', 3]
});
assert.deepStrictEqual(order, [
['a', 4],
['b', 3],
['c', 2]
]);
done();
});
});
it('should execute iterator to series by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 4);
map.set('b', 3);
map.set('c', 2);
async.pickSeries(map, pickIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'1': ['b', 3]
});
assert.deepStrictEqual(order, [
[['a', 4], 0],
[['b', 3], 1],
[['c', 2], 2]
]);
done();
});
});
it('should execute iterator to series without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.6
};
async.pickSeries(collection, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 1.1,
b: 3.5,
c: 2.6
});
assert.deepStrictEqual(order, [1.1, 3.5, 2.6]);
done();
}, Math);
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = {
a: 1,
b: 3,
c: 2
};
var iterator = function(n, key, callback) {
callback(null, n % 2);
};
async.pickSeries(collection, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.deepStrictEqual(res, {
a: 1,
b: 3
});
done();
});
sync = false;
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, num % 2);
}, num * delay);
};
async.pickSeries(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 1
});
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should throw error', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2,
d: 4
};
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, num % 2);
}, num * delay);
};
async.pickSeries(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 1
});
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [2, 1, 3];
var iterator = function(item, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.pickSeries(collection, iterator);
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [2, 1, 3];
var iterator = function(item, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.pickSeries(collection, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
});
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = {
a: 4,
b: 3,
c: 2
};
var iterator = function(item, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.pickSeries(collection, iterator);
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = {
a: 4,
b: 3,
c: 2
};
var iterator = function(item, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.pickSeries(collection, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
});
});
});
it('should avoid double callback', function(done) {
var called = false;
async.pickSeries([1, 2, 3], function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
done();
}
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = [];
async.pickSeries(array, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = {};
async.pickSeries(object, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.pickSeries(function() {}, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.pickSeries(undefined, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.pickSeries(null, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
});
parallel('#pickLimit', function() {
it('should execute iterator in limited by collection of array', function(done) {
var order = [];
var collection = [1, 5, 3, 2, 4];
async.pickLimit(collection, 2, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 1,
'1': 5,
'2': 3
});
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator in limited by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 5, 3, 2, 4];
async.pickLimit(collection, 2, pickIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 1,
'1': 5,
'2': 3
});
assert.deepStrictEqual(order, [
[1, 0],
[3, 2],
[5, 1],
[2, 3],
[4, 4]
]);
done();
});
});
it('should execute iterator in limited by collection of object', function(done) {
var order = [];
var collection = {
a: 1,
b: 5,
c: 3,
d: 2,
e: 4
};
async.pickLimit(collection, 2, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 1,
b: 5,
c: 3
});
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator in limited by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 1,
b: 5,
c: 3,
d: 2,
e: 4
};
async.pickLimit(collection, 2, pickIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 1,
b: 5,
c: 3
});
assert.deepStrictEqual(order, [
[1, 'a'],
[3, 'c'],
[5, 'b'],
[2, 'd'],
[4, 'e']
]);
done();
});
});
it('should execute iterator in limited by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(5);
set.add(3);
set.add(2);
set.add(4);
async.pickLimit(set, 2, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 1,
'1': 5,
'2': 3
});
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator in limited by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(5);
set.add(3);
set.add(2);
set.add(4);
async.pickLimit(set, 2, pickIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 1,
'1': 5,
'2': 3
});
assert.deepStrictEqual(order, [
[1, 0],
[3, 2],
[5, 1],
[2, 3],
[4, 4]
]);
done();
});
});
it('should work with odd number of elements even if the size is decreased', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.pickLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [1, 3, 5]);
done();
});
});
it('should work with even number of elements even if the size is decreased', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5, 6]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.pickLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [1, 3, 5]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next();
};
async.pickLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator in limited by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 5);
map.set('c', 3);
map.set('d', 2);
map.set('e', 4);
async.pickLimit(map, 2, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': ['a', 1],
'1': ['b', 5],
'2': ['c', 3]
});
assert.deepStrictEqual(order, [
['a', 1],
['c', 3],
['b', 5],
['d', 2],
['e', 4]
]);
done();
});
});
it('should execute iterator in limited by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 5);
map.set('c', 3);
map.set('d', 2);
map.set('e', 4);
async.pickLimit(map, 2, pickIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': ['a', 1],
'1': ['b', 5],
'2': ['c', 3]
});
assert.deepStrictEqual(order, [
[['a', 1], 0],
[['c', 3], 2],
[['b', 5], 1],
[['d', 2], 3],
[['e', 4], 4]
]);
done();
});
});
it('should execute iterator in limited without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.7
};
async.pickLimit(collection, 2, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 1.1,
b: 3.5,
c: 2.7
});
assert.deepStrictEqual(order, [1.1, 3.5, 2.7]);
done();
}, Math);
});
it('should execute like parallel if limit is Infinity', function(done) {
var order = [];
var collection = [1, 3, 4, 2, 3, 1, 3];
async.pickLimit(collection, Infinity, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'0': 1,
'1': 3,
'4': 3,
'5': 1,
'6': 3
});
assert.deepStrictEqual(order, [1, 1, 2, 3, 3, 3, 4]);
done();
});
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = {
a: 1,
b: 3,
c: 2,
d: 4,
e: 5
};
var iterator = function(n, key, callback) {
callback(null, n % 2);
};
async.pickLimit(collection, 2, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.deepStrictEqual(res, {
a: 1,
b: 3,
e: 5
});
done();
});
sync = false;
});
it('should throw error', function(done) {
var order = [];
var collection = {
a: 2,
b: 1,
c: 3
};
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 2, num);
}, num * delay);
};
async.pickLimit(collection, 4, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
b: 1
});
assert.deepStrictEqual(order, [1, 2]);
done();
});
});
it('should throw error', function(done) {
var order = [];
var collection = [2, 1, 3];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 2, num);
}, num * delay);
};
async.pickLimit(collection, 4, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
'1': 1
});
assert.deepStrictEqual(order, [1, 2]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [2, 1, 3];
var iterator = function(item, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.pickLimit(collection, 4, iterator);
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [2, 1, 3];
var iterator = function(item, index, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.pickLimit(collection, 4, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
});
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = {
a: 2,
b: 1,
c: 3
};
var iterator = function(item, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.pickLimit(collection, 4, iterator);
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = {
a: 2,
b: 1,
c: 3
};
var iterator = function(item, index, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.pickLimit(collection, 4, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
});
});
});
it('should avoid double callback', function(done) {
var called = false;
async.pickLimit([1, 2, 3], 2, function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
done();
}
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = [];
async.pickLimit(array, 3, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = {};
async.pickLimit(object, 2, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.pickLimit(function() {}, 2, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.pickLimit(undefined, 2, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.pickLimit(null, 2, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if limit is zero', function(done) {
var order = [];
var collection = [1, 3, 2];
async.pickLimit(collection, 0, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if limit is undefined', function(done) {
var order = [];
var collection = [1, 3, 2];
async.pickLimit(collection, undefined, pickIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
});
neo-async-2.6.1/test/collections/test.reduce.js 0000664 0000000 0000000 00000044663 13466145133 0021517 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var domain = require('domain');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
var util = require('../util');
function reduceIterator(order) {
return function(memo, value, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
if (_.isArray(memo)) {
memo.push(value);
} else if (_.isNumber(memo)) {
memo += num;
} else {
memo[num] = value;
}
order.push(value);
callback(null, memo);
}, num * delay);
};
}
function reduceIteratorWithKey(order) {
return function(memo, value, key, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
if (_.isArray(memo)) {
memo.push(value);
} else if (_.isNumber(memo)) {
memo += num;
} else {
memo[num] = value;
}
order.push([value, key]);
callback(null, memo);
}, num * delay);
};
}
parallel('#reduce', function() {
it('should sum number by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.reduce(collection, 0, reduceIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 10);
assert.deepStrictEqual(order, [1, 3, 2, 4]);
done();
});
});
it('should get array by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.reduce(collection, [], reduceIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [1, 3, 2, 4]);
assert.deepStrictEqual(order, [1, 3, 2, 4]);
done();
});
});
it('should sum number by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.reduce(collection, 0, reduceIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 10);
assert.deepStrictEqual(order, [
[1, 0],
[3, 1],
[2, 2],
[4, 3]
]);
done();
});
});
it('should get object by collection of object', function(done) {
var order = [];
var collection = {
a: 5,
b: 3,
c: 2
};
async.reduce(collection, {}, reduceIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {
2: 2,
3: 3,
5: 5
});
assert.deepStrictEqual(order, [5, 3, 2]);
done();
});
});
it('should get object by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 5,
b: 3,
c: 2
};
async.reduce(collection, {}, reduceIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {
2: 2,
3: 3,
5: 5
});
assert.deepStrictEqual(order, [
[5, 'a'],
[3, 'b'],
[2, 'c']
]);
done();
});
});
it('should get object by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(5);
set.add(3);
set.add(2);
async.reduce(set, {}, reduceIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {
2: 2,
3: 3,
5: 5
});
assert.deepStrictEqual(order, [5, 3, 2]);
done();
});
});
it('should get object by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(5);
set.add(3);
set.add(2);
async.reduce(set, {}, reduceIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {
2: 2,
3: 3,
5: 5
});
assert.deepStrictEqual(order, [
[5, 0],
[3, 1],
[2, 2]
]);
done();
});
});
it('should get object by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 5);
map.set('b', 3);
map.set('c', 2);
async.reduce(map, {}, reduceIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {
2: ['c', 2],
3: ['b', 3],
5: ['a', 5]
});
assert.deepStrictEqual(order, [
['a', 5],
['b', 3],
['c', 2]
]);
done();
});
});
it('should get object by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 5);
map.set('b', 3);
map.set('c', 2);
async.reduce(map, {}, reduceIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {
2: ['c', 2],
3: ['b', 3],
5: ['a', 5]
});
assert.deepStrictEqual(order, [
[['a', 5], 0],
[['b', 3], 1],
[['c', 2], 2]
]);
done();
});
});
it('should execute iterator to series with binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.6
};
async.reduce(collection, {}, reduceIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {
'1.1': 1.1,
'2.6': 2.6,
'3.5': 3.5
});
assert.deepStrictEqual(order, [1.1, 3.5, 2.6]);
done();
}, Math);
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = {
a: 1,
b: 3,
c: 2,
d: 4,
e: 5
};
var iterator = function(memo, num, key, callback) {
callback(null, memo + num);
};
async.reduce(collection, 0, iterator, function(err, sum) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.strictEqual(sum, 15);
done();
});
sync = false;
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
var iterator = function(memo, num, callback) {
setTimeout(function() {
memo.push(num);
order.push(num);
callback(num === 3, memo);
}, num * delay);
};
async.reduce(collection, [], iterator, function(err, res) {
assert.ok(err);
assert.deepStrictEqual(res, [1, 3]);
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 4);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3, 2, 4];
var iterator = function(memo, num, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.reduce(collection, [], iterator);
});
});
it('should avoid double callback', function(done) {
var called = false;
async.reduce([1, 2, 3], 0, function(memo, item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
done();
}
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = [];
async.reduce(array, 0, reduceIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 0);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = {};
async.reduce(object, 0, reduceIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 0);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.reduce(function() {}, 0, reduceIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 0);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.reduce(undefined, 0, reduceIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 0);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.reduce(null, 0, reduceIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 0);
assert.deepStrictEqual(order, []);
done();
});
});
it('should work with generator', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
var gen = util.makeGenerator(collection);
async.reduce(
gen,
0,
reduceIterator(order),
function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, 10);
done();
}
);
});
});
parallel('#reduceRight', function() {
it('should sum number by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.reduceRight(collection, 0, reduceIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 10);
assert.deepStrictEqual(order, [4, 2, 3, 1]);
done();
});
});
it('should get array by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.reduceRight(collection, [], reduceIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [4, 2, 3, 1]);
assert.deepStrictEqual(order, [4, 2, 3, 1]);
done();
});
});
it('should sum number by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.reduceRight(collection, 0, reduceIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 10);
assert.deepStrictEqual(order, [
[4, 3],
[2, 2],
[3, 1],
[1, 0]
]);
done();
});
});
it('should get object by collection of object', function(done) {
var order = [];
var collection = {
a: 5,
b: 3,
c: 2
};
async.reduceRight(collection, {}, reduceIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {
2: 2,
3: 3,
5: 5
});
assert.deepStrictEqual(order, [2, 3, 5]);
done();
});
});
it('should get object by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 5,
b: 3,
c: 2
};
async.reduceRight(collection, {}, reduceIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {
2: 2,
3: 3,
5: 5
});
assert.deepStrictEqual(order, [
[2, 'c'],
[3, 'b'],
[5, 'a']
]);
done();
});
});
it('should get object by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(5);
set.add(3);
set.add(2);
async.reduceRight(set, {}, reduceIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {
2: 2,
3: 3,
5: 5
});
assert.deepStrictEqual(order, [2, 3, 5]);
done();
});
});
it('should get object by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(5);
set.add(3);
set.add(2);
async.reduceRight(set, {}, reduceIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {
2: 2,
3: 3,
5: 5
});
assert.deepStrictEqual(order, [
[2, 2],
[3, 1],
[5, 0]
]);
done();
});
});
it('should get object by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 5);
map.set('b', 3);
map.set('c', 2);
async.reduceRight(map, {}, reduceIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {
2: ['c', 2],
3: ['b', 3],
5: ['a', 5]
});
assert.deepStrictEqual(order, [
['c', 2],
['b', 3],
['a', 5]
]);
done();
});
});
it('should get object by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 5);
map.set('b', 3);
map.set('c', 2);
async.reduceRight(map, {}, reduceIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {
2: ['c', 2],
3: ['b', 3],
5: ['a', 5]
});
assert.deepStrictEqual(order, [
[['c', 2], 2],
[['b', 3], 1],
[['a', 5], 0]
]);
done();
});
});
it('should execute iterator to series without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.6
};
async.reduceRight(collection, [], reduceIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [2.6, 3.5, 1.1]);
assert.deepStrictEqual(order, [2.6, 3.5, 1.1]);
done();
}, Math);
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = {
a: 1,
b: 3,
c: 2,
d: 4,
e: 5
};
var iterator = function(memo, num, key, callback) {
callback(null, memo + num);
};
async.reduceRight(collection, 0, iterator, function(err, sum) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.strictEqual(sum, 15);
done();
});
sync = false;
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
var iterator = function(memo, num, callback) {
setTimeout(function() {
memo.push(num);
order.push(num);
callback(num === 3, memo);
}, num * delay);
};
async.reduceRight(collection, [], iterator, function(err, res) {
assert.ok(err);
assert.deepStrictEqual(res, [4, 2, 3]);
assert.deepStrictEqual(order, [4, 2, 3]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 4);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3, 2, 4];
var iterator = function(memo, num, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.reduceRight(collection, [], iterator);
});
});
it('should avoid double callback', function(done) {
var called = false;
async.reduceRight([1, 2, 3], 0, function(memo, item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
done();
}
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = [];
async.reduceRight(array, 0, reduceIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 0);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = {};
async.reduceRight(object, 0, reduceIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 0);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.reduceRight(function() {}, 0, reduceIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 0);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.reduceRight(undefined, 0, reduceIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 0);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.reduceRight(null, 0, reduceIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 0);
assert.deepStrictEqual(order, []);
done();
});
});
});
neo-async-2.6.1/test/collections/test.reject.js 0000664 0000000 0000000 00000100164 13466145133 0021511 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var domain = require('domain');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
var util = require('../util');
function rejectIterator(order) {
return function(value, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
order.push(value);
callback(null, num % 2);
}, num * delay);
};
}
function rejectIteratorWithKey(order) {
return function(value, key, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
order.push([value, key]);
callback(null, num % 2);
}, num * delay);
};
}
parallel('#reject', function() {
it('should execute iterator by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.reject(collection, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [2, 4]);
assert.deepStrictEqual(order, [1, 2, 3, 4]);
done();
});
});
it('should execute iterator by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.reject(collection, rejectIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [2, 4]);
assert.deepStrictEqual(order, [
[1, 0],
[2, 2],
[3, 1],
[4, 3]
]);
done();
});
});
it('should execute iterator by collection of object', function(done) {
var order = [];
var collection = {
a: 4,
b: 3,
c: 2
};
async.reject(collection, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [4, 2]);
assert.deepStrictEqual(order, [2, 3, 4]);
done();
});
});
it('should execute iterator by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 4,
b: 3,
c: 2
};
async.reject(collection, rejectIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [4, 2]);
assert.deepStrictEqual(order, [
[2, 'c'],
[3, 'b'],
[4, 'a']
]);
done();
});
});
it('should execute iterator by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(4);
set.add(3);
set.add(2);
async.reject(set, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [4, 2]);
assert.deepStrictEqual(order, [2, 3, 4]);
done();
});
});
it('should execute iterator by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(4);
set.add(3);
set.add(2);
async.reject(set, rejectIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [4, 2]);
assert.deepStrictEqual(order, [
[2, 2],
[3, 1],
[4, 0]
]);
done();
});
});
it('should work even if the size is decreased', function(done) {
var order = [];
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.reject(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next();
};
async.reject(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 4);
map.set('b', 3);
map.set('c', 2);
async.reject(map, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [
['a', 4],
['c', 2]
]);
assert.deepStrictEqual(order, [
['c', 2],
['b', 3],
['a', 4]
]);
done();
});
});
it('should execute iterator by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 4);
map.set('b', 3);
map.set('c', 2);
async.reject(map, rejectIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [
['a', 4],
['c', 2]
]);
assert.deepStrictEqual(order, [
[['c', 2], 2],
[['b', 3], 1],
[['a', 4], 0]
]);
done();
});
});
it('should execute iterator without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.6
};
async.reject(collection, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, [1.1, 2.6, 3.5]);
done();
}, Math);
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, true);
}, num * delay);
};
async.reject(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(res, undefined);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 2, 3];
var iterator = function(num, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.reject(collection, iterator);
});
});
it('should not throw error of double callback', function(done) {
var collection = [
'dir1',
'dir2',
'file1',
'file2'
];
var iterator = function(name, callback) {
var result = name.charAt(0) === 'd';
callback(null, result);
};
var called = false;
async.reject(collection, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(called, false);
called = true;
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, ['file1', 'file2']);
setImmediate(done);
});
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = [];
async.reject(array, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = {};
async.reject(object, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.reject(function() {}, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.reject(undefined, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.reject(null, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
});
parallel('#rejectSeries', function() {
it('should execute iterator to series by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.rejectSeries(collection, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [2, 4]);
assert.deepStrictEqual(order, [1, 3, 2, 4]);
done();
});
});
it('should execute iterator to series by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.rejectSeries(collection, rejectIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [2, 4]);
assert.deepStrictEqual(order, [
[1, 0],
[3, 1],
[2, 2],
[4, 3]
]);
done();
});
});
it('should execute iterator to series by collection of object', function(done) {
var order = [];
var collection = {
a: 4,
b: 3,
c: 2
};
async.rejectSeries(collection, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [4, 2]);
assert.deepStrictEqual(order, [4, 3, 2]);
done();
});
});
it('should execute iterator to series by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2
};
async.rejectSeries(collection, rejectIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 1);
assert.deepStrictEqual(res, [2]);
assert.deepStrictEqual(order, [
[1, 'a'],
[3, 'b'],
[2, 'c']
]);
done();
});
});
it('should execute iterator to series by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(4);
set.add(3);
set.add(2);
async.rejectSeries(set, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [4, 2]);
assert.deepStrictEqual(order, [4, 3, 2]);
done();
});
});
it('should execute iterator to series by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(4);
set.add(3);
set.add(2);
async.rejectSeries(set, rejectIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [4, 2]);
assert.deepStrictEqual(order, [
[4, 0],
[3, 1],
[2, 2]
]);
done();
});
});
it('should work even if the size is decreased', function(done) {
var order = [];
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.rejectSeries(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next();
};
async.rejectSeries(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator to series by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 4);
map.set('b', 3);
map.set('c', 2);
async.rejectSeries(map, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [
['a', 4],
['c', 2]
]);
assert.deepStrictEqual(order, [
['a', 4],
['b', 3],
['c', 2]
]);
done();
});
});
it('should execute iterator to series by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 4);
map.set('b', 3);
map.set('c', 2);
async.rejectSeries(map, rejectIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [
['a', 4],
['c', 2]
]);
assert.deepStrictEqual(order, [
[['a', 4], 0],
[['b', 3], 1],
[['c', 2], 2]
]);
done();
});
});
it('should execute iterator to series with binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.6
};
async.rejectSeries(collection, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, [1.1, 3.5, 2.6]);
done();
}, Math);
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = {
a: 1,
b: 3,
c: 2
};
var iterator = function(n, callback) {
callback(null, false);
};
async.rejectSeries(collection, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.deepStrictEqual(res, [1, 3, 2]);
done();
});
sync = false;
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, true);
}, num * delay);
};
async.rejectSeries(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(res, undefined);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 2, 3];
var iterator = function(num, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.rejectSeries(collection, iterator);
});
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = [];
async.rejectSeries(array, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = {};
async.rejectSeries(object, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.rejectSeries(function() {}, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.rejectSeries(undefined, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.rejectSeries(null, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
});
parallel('#rejectLimit', function() {
it('should execute iterator in limited by collection of array', function(done) {
var order = [];
var collection = [1, 5, 3, 2, 4];
async.rejectLimit(collection, 2, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [2, 4]);
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator in limited by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 5, 3, 2, 4];
async.rejectLimit(collection, 2, rejectIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [2, 4]);
assert.deepStrictEqual(order, [
[1, 0],
[3, 2],
[5, 1],
[2, 3],
[4, 4]
]);
done();
});
});
it('should execute iterator in limited by collection of object', function(done) {
var order = [];
var collection = {
a: 1,
b: 5,
c: 3,
d: 2,
e: 4
};
async.rejectLimit(collection, 2, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [2, 4]);
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator in limited by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 1,
b: 5,
c: 3,
d: 2,
e: 4
};
async.rejectLimit(collection, 2, rejectIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [2, 4]);
assert.deepStrictEqual(order, [
[1, 'a'],
[3, 'c'],
[5, 'b'],
[2, 'd'],
[4, 'e']
]);
done();
});
});
it('should execute iterator in limited by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(5);
set.add(3);
set.add(2);
set.add(4);
async.rejectLimit(set, 2, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [2, 4]);
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator in limited by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(5);
set.add(3);
set.add(2);
set.add(4);
async.rejectLimit(set, 2, rejectIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [2, 4]);
assert.deepStrictEqual(order, [
[1, 0],
[3, 2],
[5, 1],
[2, 3],
[4, 4]
]);
done();
});
});
it('should work with odd number of elements even if the size is decreased', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5]);
var iterator = function(value, index, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.rejectLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [1, 3, 5]);
done();
});
});
it('should work with even number of elements even if the size is decreased', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5, 6]);
var iterator = function(value, index, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.rejectLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [1, 3, 5]);
done();
});
});
it('should execute iterator in limited by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 5);
map.set('c', 3);
map.set('d', 2);
map.set('e', 4);
async.rejectLimit(map, 2, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [
['d', 2],
['e', 4]
]);
assert.deepStrictEqual(order, [
['a', 1],
['c', 3],
['b', 5],
['d', 2],
['e', 4]
]);
done();
});
});
it('should execute iterator in limited by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 5);
map.set('c', 3);
map.set('d', 2);
map.set('e', 4);
async.rejectLimit(map, 2, rejectIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [
['d', 2],
['e', 4]
]);
assert.deepStrictEqual(order, [
[['a', 1], 0],
[['c', 3], 2],
[['b', 5], 1],
[['d', 2], 3],
[['e', 4], 4]
]);
done();
});
});
it('should execute iterator in limited without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.7
};
async.rejectLimit(collection, 2, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, [1.1, 3.5, 2.7]);
done();
}, Math);
});
it('should execute like parallel if limit is Infinity', function(done) {
var order = [];
var collection = [1, 3, 4, 2, 3, 1];
async.rejectLimit(collection, Infinity, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 2);
assert.deepStrictEqual(res, [4, 2]);
assert.deepStrictEqual(order, [1, 1, 2, 3, 3, 4]);
done();
});
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = [1, 3, 4, 2, 3, 1];
var iterator = function(n, callback) {
callback(null, n % 2);
};
async.rejectLimit(collection, 2, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.deepStrictEqual(res, [4, 2]);
done();
});
sync = false;
});
it('should return response immediately if array is empty', function(done) {
var order = [];
var array = [];
async.rejectLimit(array, 2, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var order = [];
var object = {};
async.rejectLimit(object, 2, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.rejectLimit(function() {}, 2, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.rejectLimit(undefined, 2, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if limit is zero', function(done) {
var order = [];
var collection = [1, 3, 2];
async.rejectLimit(collection, 0, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if limit is undefined', function(done) {
var order = [];
var collection = [1, 3, 2];
async.rejectLimit(collection, undefined, rejectIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.strictEqual(res.length, 0);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, true);
}, num * delay);
};
async.rejectLimit(collection, 2, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(res, undefined);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 2, 3];
var iterator = function(num, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.rejectLimit(collection, 2, iterator);
});
});
});
neo-async-2.6.1/test/collections/test.some.js 0000664 0000000 0000000 00000052443 13466145133 0021206 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
var util = require('../util');
function someIterator(order) {
return function(value, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
order.push(value);
callback(null, num % 2);
}, num * delay);
};
}
function someIteratorWithKey(order) {
return function(value, key, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
order.push([value, key]);
callback(null, num % 2);
}, num * delay);
};
}
parallel('#some', function() {
it('should execute iterator by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.some(collection, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [1]);
done();
});
});
it('should execute iterator by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.some(collection, someIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [
[1, 0]
]);
done();
});
});
it('should execute iterator by collection of object', function(done) {
var order = [];
var collection = {
a: 5,
b: 3,
c: 2
};
async.some(collection, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [2, 3]);
done();
});
});
it('should execute iterator by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 5,
b: 3,
c: 2
};
async.some(collection, someIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [
[2, 'c'],
[3, 'b']
]);
done();
});
});
it('should execute iterator by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(5);
set.add(3);
set.add(2);
async.some(set, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [2, 3]);
done();
});
});
it('should execute iterator by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(5);
set.add(3);
set.add(2);
async.some(set, someIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [
[2, 2],
[3, 1]
]);
done();
});
});
it('should execute iterator by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 5);
map.set('b', 3);
map.set('c', 2);
async.some(map, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [
['c', 2],
['b', 3]
]);
done();
});
});
it('should execute iterator by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 5);
map.set('b', 3);
map.set('c', 2);
async.some(map, someIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [
[['c', 2], 2],
[['b', 3], 1]
]);
done();
});
});
it('should execute iterator without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.6
};
async.some(collection, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [1.1]);
done();
}, Math);
});
it('should return response immediately if collection is empty', function(done) {
var order = [];
async.some([], someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, []);
done();
});
});
it('should avoid double callback', function(done) {
var called = false;
async.some([1, 2, 3], function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
done();
}
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.some(function() {}, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.some(undefined, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.some(null, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return an error', function(done) {
var collection = [1, 3, 2, 4];
var iterator = function(value, key, callback) {
callback('error');
};
async.some(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(res, undefined);
done();
});
});
});
parallel('#someSeries', function() {
it('should execute iterator by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.someSeries(collection, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [1]);
done();
});
});
it('should execute iterator by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.someSeries(collection, someIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [
[1, 0]
]);
done();
});
});
it('should execute iterator by collection of object', function(done) {
var order = [];
var collection = {
a: 5,
b: 3,
c: 2
};
async.someSeries(collection, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [5]);
done();
});
});
it('should execute iterator by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 5,
b: 3,
c: 2
};
async.someSeries(collection, someIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [
[5, 'a']
]);
done();
});
});
it('should execute iterator by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(4);
set.add(3);
set.add(2);
async.someSeries(set, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [4, 3]);
done();
});
});
it('should execute iterator by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(4);
set.add(3);
set.add(2);
async.someSeries(set, someIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [
[4, 0],
[3, 1]
]);
done();
});
});
it('should execute iterator by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 4);
map.set('b', 3);
map.set('c', 2);
async.someSeries(map, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [
['a', 4],
['b', 3]
]);
done();
});
});
it('should execute iterator by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 4);
map.set('b', 3);
map.set('c', 2);
async.someSeries(map, someIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [
[['a', 4], 0],
[['b', 3], 1]
]);
done();
});
});
it('should execute iterator without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.6
};
async.someSeries(collection, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [1.1]);
done();
}, Math);
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = {
a: 1,
b: 3,
c: 2
};
var iterator = function(n, key, callback) {
callback(null, key === 'c');
};
async.someSeries(collection, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.strictEqual(res, true);
done();
});
sync = false;
});
it('should avoid double callback', function(done) {
var called = false;
async.someSeries([1, 2, 3], function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
done();
}
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if collection is empty', function(done) {
var order = [];
async.someSeries([], someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.someSeries(function() {}, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.someSeries(undefined, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.someSeries(null, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return an error', function(done) {
var collection = [1, 3, 2, 4];
var iterator = function(value, key, callback) {
callback('error');
};
async.someSeries(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(res, undefined);
done();
});
});
});
parallel('#someLimit', function() {
it('should execute iterator in limited by collection of array', function(done) {
var order = [];
var collection = [2, 4, 3, 2];
async.someLimit(collection, 2, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [2, 4, 3]);
done();
});
});
it('should execute iterator in limited by collection of array with passing index', function(done) {
var order = [];
var collection = [2, 4, 3, 2];
async.someLimit(collection, 2, someIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [
[2, 0],
[4, 1],
[3, 2]
]);
done();
});
});
it('should execute iterator in limited by collection of object', function(done) {
var order = [];
var collection = {
a: 2,
b: 4,
c: 3,
d: 2
};
async.someLimit(collection, 2, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [2, 4, 3]);
done();
});
});
it('should execute iterator in limited by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 2,
b: 4,
c: 3,
d: 2
};
async.someLimit(collection, 2, someIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [
[2, 'a'],
[4, 'b'],
[3, 'c']
]);
done();
});
});
it('should execute iterator in limited by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(2);
set.add(4);
set.add(3);
set.add(2);
async.someLimit(set, 2, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [2, 4, 3]);
done();
});
});
it('should execute iterator in limited by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(2);
set.add(4);
set.add(3);
set.add(2);
async.someLimit(set, 2, someIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [
[2, 0],
[4, 1],
[3, 2]
]);
done();
});
});
it('should execute iterator in limited by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 2);
map.set('b', 4);
map.set('c', 3);
map.set('d', 2);
async.someLimit(map, 2, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [
['a', 2],
['b', 4],
['c', 3]
]);
done();
});
});
it('should execute iterator in limited by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 2);
map.set('b', 4);
map.set('c', 3);
map.set('d', 2);
async.someLimit(map, 2, someIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [
[['a', 2], 0],
[['b', 4], 1],
[['c', 3], 2]
]);
done();
});
});
it('should execute iterator to series without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.7
};
async.someLimit(collection, 2, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [1.1]);
done();
}, Math);
});
it('should execute like parallel if limit is Infinity', function(done) {
var order = [];
var collection = [2, 3, 1];
async.someLimit(collection, Infinity, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, true);
assert.deepStrictEqual(order, [1]);
done();
});
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = {
a: 1,
b: 3,
c: 2,
d: 4,
e: 5
};
var iterator = function(n, key, callback) {
callback(null, key === 'e');
};
async.someLimit(collection, 2, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.strictEqual(res, true);
done();
});
sync = false;
});
it('should avoid double callback', function(done) {
var called = false;
async.someLimit([1, 2, 3], 2, function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
done();
}
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if collection is empty', function(done) {
var order = [];
async.someLimit([], 2, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.someLimit(function() {}, 2, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.someLimit(undefined, 2, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.someLimit(null, 2, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if limit is zero', function(done) {
var order = [];
var collection = [1, 3, 2];
async.someLimit(collection, 0, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if limit is undefined', function(done) {
var order = [];
var collection = [1, 3, 2];
async.someLimit(collection, undefined, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, false);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return an error', function(done) {
var collection = [1, 3, 2, 4];
var iterator = function(value, key, callback) {
callback('error');
};
async.someLimit(collection, 2, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(res, undefined);
done();
});
});
it('should stop execution', function(done) {
var order = [];
var collection = [2, 1, 3];
async.someLimit(collection, 2, someIterator(order), function(err, res) {
if (err) {
return done(err);
}
order.push('callback');
assert.strictEqual(res, true);
});
setTimeout(function() {
assert.deepStrictEqual(order, [1, 'callback', 2]);
done();
}, 10 * delay);
});
});
neo-async-2.6.1/test/collections/test.sortBy.js 0000664 0000000 0000000 00000071623 13466145133 0021526 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var domain = require('domain');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
var util = require('../util');
function sortByIterator(order) {
return function(value, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
order.push(value);
callback(null, num * 2);
}, num * delay);
};
}
function sortByIteratorWithKey(order) {
return function(value, key, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
order.push([value, key]);
callback(null, num * 2);
}, num * delay);
};
}
parallel('#sortBy', function() {
it('should execute iterator by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2];
async.sortBy(collection, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [1, 2, 3]);
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should execute iterator by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2];
async.sortBy(collection, sortByIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [1, 2, 3]);
assert.deepStrictEqual(order, [
[1, 0],
[2, 2],
[3, 1]
]);
done();
});
});
it('should execute iterator by collection of object', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2
};
async.sortBy(collection, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [1, 2, 3]);
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should execute iterator by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2
};
async.sortBy(collection, sortByIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [1, 2, 3]);
assert.deepStrictEqual(order, [
[1, 'a'],
[2, 'c'],
[3, 'b']
]);
done();
});
});
it('should execute iterator by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(3);
set.add(2);
async.sortBy(set, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 2, 3]);
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should execute iterator by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(3);
set.add(2);
async.sortBy(set, sortByIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 2, 3]);
assert.deepStrictEqual(order, [
[1, 0],
[2, 2],
[3, 1]
]);
done();
});
});
it('should work even if the size is decreased', function(done) {
var order = [];
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.sortBy(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next();
};
async.sortBy(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 3);
map.set('c', 2);
async.sortBy(map, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [
['a', 1],
['c', 2],
['b', 3]
]);
assert.deepStrictEqual(order, [
['a', 1],
['c', 2],
['b', 3]
]);
done();
});
});
it('should execute iterator by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 3);
map.set('c', 2);
async.sortBy(map, sortByIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [
['a', 1],
['c', 2],
['b', 3]
]);
assert.deepStrictEqual(order, [
[['a', 1], 0],
[['c', 2], 2],
[['b', 3], 1]
]);
done();
});
});
it('should execute iterator without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.7
};
async.sortBy(collection, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [1.1, 2.7, 3.5]);
assert.deepStrictEqual(order, [1.1, 2.7, 3.5]);
done();
}, Math);
});
it('should keep the order if criteria are same value', function(done) {
var collection = [{
a: 1, b: 1
}, {
a: 2, b: 2
}, {
a: 1, b: 3
}, {
a: 2, b: 4
}, {
a: 1, b: 5
}];
var iterator = function(obj, callback) {
callback(null, obj.a);
}
async.sortBy(collection, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [{
a: 1, b: 1
}, {
a: 1, b: 3
}, {
a: 1, b: 5
}, {
a: 2, b: 2
}, {
a: 2, b: 4
}]);
done();
});
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 2];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, num);
}, num * delay);
};
async.sortBy(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, [1, 2, 3]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3, 2];
var iterator = function(num, index, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.sortBy(collection, iterator);
});
});
it('should avoid double callback', function(done) {
var called = false;
async.sortBy([1, 2, 3], function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
done();
}
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.sortBy(function() {}, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.sortBy(undefined, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.sortBy(null, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
});
parallel('#sortBySeries', function() {
it('should execute iterator by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2];
async.sortBySeries(collection, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [1, 2, 3]);
assert.deepStrictEqual(order, [1, 3, 2]);
done();
});
});
it('should execute iterator by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2];
async.sortBySeries(collection, sortByIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [1, 2, 3]);
assert.deepStrictEqual(order, [
[1, 0],
[3, 1],
[2, 2]
]);
done();
});
});
it('should execute iterator by collection of object', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2
};
async.sortBySeries(collection, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [1, 2, 3]);
assert.deepStrictEqual(order, [1, 3, 2]);
done();
});
});
it('should execute iterator by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 1,
b: 3,
c: 2
};
async.sortBySeries(collection, sortByIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [1, 2, 3]);
assert.deepStrictEqual(order, [
[1, 'a'],
[3, 'b'],
[2, 'c']
]);
done();
});
});
it('should execute iterator to series by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(3);
set.add(2);
async.sortBySeries(set, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 2, 3]);
assert.deepStrictEqual(order, [1, 3, 2]);
done();
});
});
it('should execute iterator to series by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(3);
set.add(2);
async.sortBySeries(set, sortByIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 2, 3]);
assert.deepStrictEqual(order, [
[1, 0],
[3, 1],
[2, 2]
]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next();
};
async.sortBySeries(set, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator to series by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 3);
map.set('c', 2);
async.sortBySeries(map, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [
['a', 1],
['c', 2],
['b', 3]
]);
assert.deepStrictEqual(order, [
['a', 1],
['b', 3],
['c', 2]
]);
done();
});
});
it('should execute iterator to series by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 3);
map.set('c', 2);
async.sortBySeries(map, sortByIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [
['a', 1],
['c', 2],
['b', 3]
]);
assert.deepStrictEqual(order, [
[['a', 1], 0],
[['b', 3], 1],
[['c', 2], 2]
]);
done();
});
});
it('should execute iterator without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.7
};
async.sortBySeries(collection, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [1.1, 2.7, 3.5]);
assert.deepStrictEqual(order, [1.1, 3.5, 2.7]);
done();
}, Math);
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = {
a: 1,
b: 3,
c: 2
};
var iterator = function(num, key, callback) {
callback(null, num % 2);
};
async.sortBySeries(collection, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.deepStrictEqual(res, [2, 1, 3]);
done();
});
sync = false;
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 2];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, num);
}, num * delay);
};
async.sortBySeries(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 3, 2];
var iterator = function(num, index, callback) {
setTimeout(function() {
order.push([num, index]);
callback(num === 3, num);
}, num * delay);
};
async.sortBySeries(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, [
[1, 0],
[3, 1]
]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3, 2];
var iterator = function(num, index, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.sortBySeries(collection, iterator);
});
});
it('should avoid double callback', function(done) {
var called = false;
async.sortBySeries([1, 2, 3], function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
done();
}
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.sortBySeries(function() {}, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.sortBySeries(undefined, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.sortBySeries(null, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
});
parallel('#sortByLimit', function() {
it('should execute iterator by collection of array', function(done) {
var order = [];
var collection = [1, 5, 3, 2, 4];
async.sortByLimit(collection, 2, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [1, 2, 3, 4, 5]);
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 5, 3, 2, 4];
async.sortByLimit(collection, 2, sortByIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [1, 2, 3, 4, 5]);
assert.deepStrictEqual(order, [
[1, 0],
[3, 2],
[5, 1],
[2, 3],
[4, 4]
]);
done();
});
});
it('should execute iterator by collection of object', function(done) {
var order = [];
var collection = {
a: 1,
b: 5,
c: 3,
d: 2,
e: 4
};
async.sortByLimit(collection, 2, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [1, 2, 3, 4, 5]);
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator by collection of object', function(done) {
var order = [];
var collection = {
a: 1,
b: 5,
c: 3,
d: 2,
e: 4
};
async.sortByLimit(collection, 2, sortByIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [1, 2, 3, 4, 5]);
assert.deepStrictEqual(order, [
[1, 'a'],
[3, 'c'],
[5, 'b'],
[2, 'd'],
[4, 'e']
]);
done();
});
});
it('should execute iterator in limited by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(5);
set.add(3);
set.add(4);
set.add(2);
async.sortByLimit(set, 2, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 2, 3, 4, 5]);
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator in limited by collection of Set with passing key', function(done) {
var order = [];
var set = new util.Set();
set.add(1);
set.add(5);
set.add(3);
set.add(4);
set.add(2);
async.sortByLimit(set, 2, sortByIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 2, 3, 4, 5]);
assert.deepStrictEqual(order, [
[1, 0],
[3, 2],
[5, 1],
[2, 4],
[4, 3]
]);
done();
});
});
it('should work with odd number of elements even if the size is decreased', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5]);
var iterator = function(value, index, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.sortByLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [1, 3, 5]);
done();
});
});
it('should work with even number of elements even if the size is decreased', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5, 6]);
var iterator = function(value, index, next) {
order.push(value);
set.delete(value + 1);
next();
};
async.sortByLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [1, 3, 5]);
done();
});
});
it('should work even if the size is increased', function(done) {
var order = [];
var size = 4;
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(value, next) {
order.push(value);
value % 2 === 0 && set.add(++size);
next();
};
async.sortByLimit(set, 2, iterator, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5, 6, 7]);
done();
});
});
it('should execute iterator in limited by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 5);
map.set('c', 3);
map.set('d', 4);
map.set('e', 2);
async.sortByLimit(map, 2, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [
['a', 1],
['e', 2],
['c', 3],
['d', 4],
['b', 5]
]);
assert.deepStrictEqual(order, [
['a', 1],
['c', 3],
['b', 5],
['e', 2],
['d', 4]
]);
done();
});
});
it('should execute iterator in limited by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 5);
map.set('c', 3);
map.set('d', 4);
map.set('e', 2);
async.sortByLimit(map, 2, sortByIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [
['a', 1],
['e', 2],
['c', 3],
['d', 4],
['b', 5]
]);
assert.deepStrictEqual(order, [
[['a', 1], 0],
[['c', 3], 2],
[['b', 5], 1],
[['e', 2], 4],
[['d', 4], 3]
]);
done();
});
});
it('should execute iterator without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.7
};
async.sortByLimit(collection, 5, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [1.1, 2.7, 3.5]);
assert.deepStrictEqual(order, [1.1, 2.7, 3.5]);
done();
}, Math);
});
it('should execute like parallel if limit is Infinity', function(done) {
var order = [];
var collection = [1, 5, 3];
async.sortByLimit(collection, Infinity, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [1, 3, 5]);
assert.deepStrictEqual(order, [1, 3, 5]);
done();
});
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = {
a: 1,
b: 3,
c: 2,
d: 4,
e: 5
};
var iterator = function(num, key, callback) {
callback(null, num % 2);
};
async.sortByLimit(collection, 2, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.deepStrictEqual(res, [2, 4, 1, 3, 5]);
done();
});
sync = false;
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 5, 3];
var iterator = function(num, callback) {
setTimeout(function() {
order.push(num);
callback(num === 3, num);
}, num * delay);
};
async.sortByLimit(collection, 2, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 5, 3];
var iterator = function(num, index, callback) {
setTimeout(function() {
order.push([num, index]);
callback(num === 3, num);
}, num * delay);
};
async.sortByLimit(collection, 2, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(res, undefined);
assert.deepStrictEqual(order, [
[1, 0],
[3, 2]
]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 3);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3, 2];
var iterator = function(num, index, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.sortByLimit(collection, 2, iterator);
});
});
it('should avoid double callback', function(done) {
var called = false;
async.sortByLimit([1, 2, 3], 2, function(item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
done();
}
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.sortByLimit(function() {}, 2, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.sortByLimit(undefined, 2, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.sortByLimit(null, 2, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if limit is zero', function(done) {
var order = [];
var collection = [1, 3, 2];
async.sortByLimit(collection, 0, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if limit is undefined', function(done) {
var order = [];
var collection = [1, 3, 2];
async.sortByLimit(collection, undefined, sortByIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
});
neo-async-2.6.1/test/collections/test.transform.js 0000664 0000000 0000000 00000114755 13466145133 0022263 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var domain = require('domain');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
var util = require('../util');
function transformIterator(order) {
return function(memo, value, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
if (num % 2 === 1) {
if (_.isArray(memo)) {
memo.push(value);
}
}
order.push(value);
callback();
}, num * delay);
};
}
function transformIteratorWithKey(order) {
return function(memo, value, key, callback) {
var self = this;
var num = _.isArray(value) ? _.last(value) : value;
setTimeout(function() {
if (self && self.round) {
num = self.round(num);
}
if (num % 2 === 1) {
if (_.isArray(memo)) {
memo.push(value);
} else {
memo[key] = value;
}
}
order.push([value, key]);
if (key === 'break') {
return callback(null, false);
}
callback();
}, num * delay);
};
}
parallel('#transform', function() {
it('should execute iterator by collection of array', function(done) {
var order = [];
var collection = [1, 5, 3, 2, 4];
async.transform(collection, transformIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3, 5]);
assert.deepStrictEqual(order, [1, 2, 3, 4, 5]);
done();
});
});
it('should execute iterator by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 5, 3, 2, 4];
async.transform(collection, transformIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3, 5]);
assert.deepStrictEqual(order, [
[1, 0],
[2, 3],
[3, 2],
[4, 4],
[5, 1]
]);
done();
});
});
it('should execute iterator by collection of object', function(done) {
var order = [];
var collection = {
a: 5,
b: 3,
c: 2
};
async.transform(collection, [], transformIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [3, 5]);
assert.deepStrictEqual(order, [2, 3, 5]);
done();
});
});
it('should execute iterator by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 5,
b: 3,
c: 2
};
async.transform(collection, transformIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
b: 3,
a: 5
});
assert.deepStrictEqual(order, [
[2, 'c'],
[3, 'b'],
[5, 'a']
]);
done();
});
});
it('should execute iterator in limited by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(5);
set.add(3);
set.add(2);
async.transform(set, [], transformIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [3, 5]);
assert.deepStrictEqual(order, [2, 3, 5]);
done();
});
});
it('should execute iterator in limited by collection of Set with passing index', function(done) {
var order = [];
var set = new util.Set();
set.add(5);
set.add(3);
set.add(2);
async.transform(set, transformIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
0: 5,
1: 3
});
assert.deepStrictEqual(order, [
[2, 2],
[3, 1],
[5, 0]
]);
done();
});
});
it('should work properly even if elements are added in callback', function(done) {
var order = [];
var arr = [1, 3, 2];
var set = new util.Set(arr);
var iterator = function(acc, value, next) {
order.push(value);
acc.push(value);
next();
};
async.transform(set, [], iterator, function(err, res) {
if (err) {
return done(err);
}
setTimeout(function() {
assert.deepStrictEqual(order, arr);
assert.deepStrictEqual(res, arr);
done();
}, delay);
set.add(4);
});
});
it('should work even if the size is changed', function(done) {
var order = [];
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(acc, value, next) {
order.push(value);
set.delete(value + 1);
acc.push(value);
next();
};
async.transform(set, [], iterator, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3]);
assert.deepStrictEqual(res, [1, 3]);
done();
});
});
it('should execute iterator in limited by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 5);
map.set('b', 3);
map.set('c', 2);
async.transform(map, [], transformIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [
['b', 3],
['a', 5]
]);
assert.deepStrictEqual(order, [
['c', 2],
['b', 3],
['a', 5]
]);
done();
});
});
it('should execute iterator in limited by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 5);
map.set('b', 3);
map.set('c', 2);
async.transform(map, transformIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
0: ['a', 5],
1: ['b', 3]
});
assert.deepStrictEqual(order, [
[['c', 2], 2],
[['b', 3], 1],
[['a', 5], 0]
]);
done();
});
});
it('should execute iterator and break when callback is called "false"', function(done) {
var order = [];
var collection = [4, 3, 2];
var iterator = function(memo, num, callback) {
setTimeout(function() {
order.push(num);
memo.push(num);
callback(null, num !== 3);
}, num * delay);
};
async.transform(collection, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [2, 3]);
assert.deepStrictEqual(order, [2, 3]);
done();
});
});
it('should execute iterator and break when callback is called "false"', function(done) {
var order = [];
var collection = {
a: 5,
b: 3,
c: 2,
'break': 3.5
};
async.transform(collection, [], transformIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [3]);
assert.deepStrictEqual(order, [
[2, 'c'],
[3, 'b'],
[3.5, 'break']
]);
done();
});
});
it('should execute iterator without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.6
};
async.transform(collection, {}, transformIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, [
[1.1, 'a'],
[2.6, 'c'],
[3.5, 'b']
]);
done();
}, Math);
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 5, 3, 2, 4];
var iterator = function(memo, value, key, callback) {
setTimeout(function() {
memo.push(value);
order.push(value);
callback(value === 4);
}, value * delay);
};
async.transform(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 2, 3, 4]);
assert.deepStrictEqual(order, [1, 2, 3, 4]);
done();
});
});
it('should avoid double callback', function(done) {
var called = false;
async.transform([1, 2, 3], function(memo, item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
done();
}
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if array is empty', function(done) {
var iterator = function(memo, value, key, callback) {
callback();
};
async.transform([], iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var iterator = function(memo, value, key, callback) {
callback();
};
async.transform({}, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.transform(function() {}, transformIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.transform(undefined, transformIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.transform(null, transformIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return accumulator immediately if array is empty', function(done) {
var iterator = function(memo, value, key, callback) {
callback();
};
async.transform([], {}, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
done();
});
});
it('should return accumulator immediately if object is empty', function(done) {
var iterator = function(memo, value, key, callback) {
callback();
};
async.transform({}, [], iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
done();
});
});
});
parallel('#transformSeries', function() {
it('should execute iterator to series by collection of array', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.transformSeries(collection, transformIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3]);
assert.deepStrictEqual(order, [1, 3, 2, 4]);
done();
});
});
it('should execute iterator to series by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 3, 2, 4];
async.transformSeries(collection, transformIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3]);
assert.deepStrictEqual(order, [
[1, 0],
[3, 1],
[2, 2],
[4, 3]
]);
done();
});
});
it('should execute iterator to series by collection of object', function(done) {
var order = [];
var collection = {
a: 5,
b: 3,
c: 2
};
async.transformSeries(collection, [], transformIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [5, 3]);
assert.deepStrictEqual(order, [5, 3, 2]);
done();
});
});
it('should execute iterator to series by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 5,
b: 3,
c: 2
};
async.transformSeries(collection, transformIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 5,
b: 3
});
assert.deepStrictEqual(order, [
[5, 'a'],
[3, 'b'],
[2, 'c']
]);
done();
});
});
it('should execute iterator to series by collection of Set', function(done) {
var order = [];
var set = new util.Set();
set.add(5);
set.add(3);
set.add(2);
async.transformSeries(set, [], transformIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [5, 3]);
assert.deepStrictEqual(order, [5, 3, 2]);
done();
});
});
it('should execute iterator to series by collection of Set with passing index', function(done) {
var order = [];
var set = new util.Set();
set.add(5);
set.add(3);
set.add(2);
async.transformSeries(set, transformIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
0: 5,
1: 3
});
assert.deepStrictEqual(order, [
[5, 0],
[3, 1],
[2, 2]
]);
done();
});
});
it('should work properly even if elements are added in callback', function(done) {
var order = [];
var arr = [1, 3, 2];
var set = new util.Set(arr);
var iterator = function(acc, value, next) {
order.push(value);
acc.push(value);
next();
};
async.transformSeries(set, [], iterator, function(err, res) {
if (err) {
return done(err);
}
setTimeout(function() {
assert.deepStrictEqual(order, arr);
assert.deepStrictEqual(res, arr);
done();
}, delay);
set.add(4);
});
});
it('should work even if the size is changed', function(done) {
var order = [];
var set = new util.Set([1, 2, 3, 4]);
var iterator = function(acc, value, next) {
order.push(value);
set.delete(value + 1);
acc.push(value);
next();
};
async.transformSeries(set, [], iterator, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 3]);
assert.deepStrictEqual(res, [1, 3]);
done();
});
});
it('should execute iterator to series by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 5);
map.set('b', 3);
map.set('c', 2);
async.transformSeries(map, [], transformIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [
['a', 5],
['b', 3]
]);
assert.deepStrictEqual(order, [
['a', 5],
['b', 3],
['c', 2]
]);
done();
});
});
it('should execute iterator to series by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 5);
map.set('b', 3);
map.set('c', 2);
async.transformSeries(map, transformIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
0: ['a', 5],
1: ['b', 3]
});
assert.deepStrictEqual(order, [
[['a', 5], 0],
[['b', 3], 1],
[['c', 2], 2]
]);
done();
});
});
it('should execute iterator and break when callback is called "false"', function(done) {
var order = [];
var collection = {
a: 5,
'break': 3.5,
b: 3,
c: 2
};
async.transformSeries(collection, transformIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 5
});
assert.deepStrictEqual(order, [
[5, 'a'],
[3.5, 'break']
]);
done();
});
});
it('should execute iterator to series without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.6
};
async.transformSeries(collection, undefined, transformIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, [
[1.1, 'a'],
[3.5, 'b'],
[2.6, 'c']
]);
done();
});
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = {
a: 1,
b: 3,
c: 2,
d: 4,
e: 5
};
var iterator = function(result, num, key, callback) {
result[key] = num * 2;
callback();
};
async.transformSeries(collection, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.deepStrictEqual(res, {
a: 2,
b: 6,
c: 4,
d: 8,
e: 10
});
done();
});
sync = false;
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 5, 3, 2, 4];
var iterator = function(memo, value, key, callback) {
setTimeout(function() {
memo.push(value);
order.push(value);
callback(value === 4);
}, value * delay);
};
async.transformSeries(collection, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 5, 3, 2, 4]);
assert.deepStrictEqual(order, [1, 5, 3, 2, 4]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 4);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var collection = [1, 3, 2, 4];
var iterator = function(memo, value, key, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.transformSeries(collection, iterator, _.noop);
});
});
it('should avoid double callback', function(done) {
var called = false;
async.transformSeries([1, 2, 3], function(memo, item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
done();
}
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if array is empty', function(done) {
var iterator = function(memo, value, key, callback) {
callback();
};
async.transformSeries([], iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var iterator = function(memo, value, key, callback) {
callback();
};
async.transformSeries({}, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.transformSeries(function() {}, transformIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.transformSeries(undefined, transformIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.transformSeries(null, transformIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return accumulator immediately if array is empty', function(done) {
var iterator = function(memo, value, key, callback) {
callback();
};
async.transformSeries([], {}, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
done();
});
});
it('should return accumulator immediately if object is empty', function(done) {
var iterator = function(memo, value, key, callback) {
callback();
};
async.transformSeries({}, [], iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
done();
});
});
});
parallel('#transformLimit', function() {
it('should execute iterator in limited by collection of array', function(done) {
var order = [];
var collection = [1, 5, 3, 2, 4];
async.transformLimit(collection, 2, transformIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3, 5]);
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator in limited by collection of array with passing index', function(done) {
var order = [];
var collection = [1, 5, 3, 2, 4];
async.transformLimit(collection, 2, transformIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3, 5]);
assert.deepStrictEqual(order, [
[1, 0],
[3, 2],
[5, 1],
[2, 3],
[4, 4]
]);
done();
});
});
it('should execute iterator in limited by collection of object', function(done) {
var order = [];
var collection = {
a: 1,
b: 5,
c: 3,
d: 2,
e: 4
};
async.transformLimit(collection, 2, [], transformIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3, 5]);
assert.deepStrictEqual(order, [1, 3, 5, 2, 4]);
done();
});
});
it('should execute iterator in limited by collection of object with passing key', function(done) {
var order = [];
var collection = {
a: 1,
b: 5,
c: 3,
d: 2,
e: 4
};
async.transformLimit(collection, 2, transformIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
a: 1,
b: 5,
c: 3
});
assert.deepStrictEqual(order, [
[1, 'a'],
[3, 'c'],
[5, 'b'],
[2, 'd'],
[4, 'e']
]);
done();
});
});
it('should work properly even if elements are added in callback', function(done) {
var order = [];
var arr = [1, 5, 3, 2, 4];
var set = new util.Set(arr);
var iterator = function(acc, value, next) {
order.push(value);
acc.push(value);
next();
};
async.transformLimit(set, 2, [], iterator, function(err, res) {
if (err) {
return done(err);
}
setTimeout(function() {
assert.deepStrictEqual(order, arr);
assert.deepStrictEqual(res, arr);
done();
}, delay);
set.add(6);
});
});
it('should work with odd number of elements even if the size is changed', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5]);
var iterator = function(acc, value, next) {
order.push(value);
set.delete(value + 1);
acc.push(value);
next();
};
async.transformLimit(set, 2, [], iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [1, 3, 5]);
assert.deepStrictEqual(res, [1, 3, 5]);
done();
});
});
it('should work with even number of elements even if the size is changed', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5, 6]);
var iterator = function(acc, value, next) {
order.push(value);
set.delete(value + 1);
acc.push(value);
next();
};
async.transformLimit(set, 2, [], iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [1, 3, 5]);
assert.deepStrictEqual(res, [1, 3, 5]);
done();
});
});
it('should work with odd number of elements even if the size is changed', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5]);
var iterator = function(acc, value, index, next) {
order.push([index, value]);
set.delete(value + 1);
acc.push(value);
next();
};
async.transformLimit(set, 2, [], iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [[0, 1], [1, 3], [2, 5]]);
assert.deepStrictEqual(res, [1, 3, 5]);
done();
});
});
it('should work with even number of elements even if the size is changed', function(done) {
var called = 0;
var order = [];
var set = new util.Set([1, 2, 3, 4, 5, 6]);
var iterator = function(acc, value, index, next) {
order.push([index, value]);
set.delete(value + 1);
acc.push(value);
next();
};
async.transformLimit(set, 2, [], iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(++called, 1);
assert.deepStrictEqual(order, [[0, 1], [1, 3], [2, 5]]);
assert.deepStrictEqual(res, [1, 3, 5]);
done();
});
});
it('should execute iterator in limited by collection of Map', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 5);
map.set('c', 3);
map.set('d', 2);
map.set('e', 4);
async.transformLimit(map, 2, [], transformIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [
['a', 1],
['c', 3],
['b', 5]
]);
assert.deepStrictEqual(order, [
['a', 1],
['c', 3],
['b', 5],
['d', 2],
['e', 4]
]);
done();
});
});
it('should execute iterator in limited by collection of Map with passing key', function(done) {
var order = [];
var map = new util.Map();
map.set('a', 1);
map.set('b', 5);
map.set('c', 3);
map.set('d', 2);
map.set('e', 4);
async.transformLimit(map, 2, transformIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
0: ['a', 1],
1: ['b', 5],
2: ['c', 3]
});
assert.deepStrictEqual(order, [
[['a', 1], 0],
[['c', 3], 2],
[['b', 5], 1],
[['d', 2], 3],
[['e', 4], 4]
]);
done();
});
});
it('should execute iterator in limited and break when callback is called "false"', function(done) {
var order = [];
var collection = {
a: 5,
b: 3,
c: 2,
'break': 3.5,
d: 3
};
async.transformLimit(collection, 4, transformIteratorWithKey(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {
b: 3
});
assert.deepStrictEqual(order, [
[2, 'c'],
[3, 'b'],
[3.5, 'break']
]);
done();
});
});
it('should execute iterator in limited without binding', function(done) {
var order = [];
var collection = {
a: 1.1,
b: 3.5,
c: 2.7
};
async.transformLimit(collection, 2, [], transformIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, [1.1, 3.5, 2.7]);
done();
}, Math);
});
it('should execute like parallel if limit is Infinity', function(done) {
var order = [];
var collection = [1, 3, 4, 2, 3, 1, 1];
async.transformLimit(collection, Infinity, transformIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 1, 1, 3, 3]);
assert.deepStrictEqual(order, [1, 1, 1, 2, 3, 3, 4]);
done();
});
});
it('should execute on asynchronous', function(done) {
var sync = true;
var collection = {
a: 1,
b: 3,
c: 2,
d: 4,
e: 5
};
var iterator = function(result, num, key, callback) {
result[key] = num * 2;
callback();
};
async.transformLimit(collection, 2, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.deepStrictEqual(res, {
a: 2,
b: 6,
c: 4,
d: 8,
e: 10
});
done();
});
sync = false;
});
it('should throw error', function(done) {
var order = [];
var collection = [1, 5, 3, 2, 4];
var iterator = function(memo, value, key, callback) {
setTimeout(function() {
memo.push(value);
order.push(value);
callback(value === 3);
}, value * delay);
};
async.transformLimit(collection, 2, iterator, function(err, res) {
assert.ok(err);
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [1, 3]);
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should avoid double callback', function(done) {
var called = false;
async.transformLimit([1, 2, 3], 2, function(memo, item, callback) {
try {
callback(item);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
done();
}
}
}, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if array is empty', function(done) {
var iterator = function(memo, value, key, callback) {
callback();
};
async.transformLimit([], 3, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
done();
});
});
it('should return response immediately if object is empty', function(done) {
var iterator = function(memo, value, key, callback) {
callback();
};
async.transformLimit({}, 2, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
done();
});
});
it('should return response immediately if collection is function', function(done) {
var order = [];
async.transformLimit(function() {}, 2, transformIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is undefined', function(done) {
var order = [];
async.transformLimit(undefined, 2, transformIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if collection is null', function(done) {
var order = [];
async.transformLimit(null, 2, transformIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if limit is zero', function(done) {
var order = [];
var collection = [1, 3, 2];
async.transformLimit(collection, 0, transformIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(order, []);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return response immediately if limit is undefined', function(done) {
var order = [];
var collection = [1, 3, 2];
async.transformLimit(collection, undefined, transformIterator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(order, []);
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should return accumulator immediately if array is empty', function(done) {
var iterator = function(memo, value, key, callback) {
callback();
};
async.transformLimit([], 4, {}, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Object]');
assert.deepStrictEqual(res, {});
done();
});
});
it('should return accumulator immediately if object is empty', function(done) {
var iterator = function(memo, value, key, callback) {
callback();
};
async.transformLimit({}, 4, [], iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
done();
});
});
});
neo-async-2.6.1/test/config.js 0000664 0000000 0000000 00000000263 13466145133 0016205 0 ustar 00root root 0000000 0000000 'use strict';
if (typeof Symbol !== 'function') {
global.Symbol = function() {};
global.Symbol.iterator = 'symbol';
}
module.exports = {
delay: process.env.DELAY || 70
};
neo-async-2.6.1/test/controlFlow/ 0000775 0000000 0000000 00000000000 13466145133 0016711 5 ustar 00root root 0000000 0000000 neo-async-2.6.1/test/controlFlow/test.angelFall.js 0000664 0000000 0000000 00000016613 13466145133 0022121 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var domain = require('domain');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
var util = require('../util');
function createSimpleTasks(numbers) {
var first = true;
var tasks = _.transform(numbers, function(memo, num, key) {
if (first) {
first = false;
memo[key] = function(done) {
if (this === Math) {
num *= 2;
}
done(null, num);
};
} else {
memo[key] = function(sum, done) {
if (this === Math) {
num *= 2;
}
done(null, sum + num);
};
}
});
return tasks;
}
parallel('#angelFall', function() {
it('should execute to waterfall by collection of array', function(done) {
var numbers = [1, 3, 2, 4];
var tasks = createSimpleTasks(numbers);
async.angelFall(tasks, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 10);
done();
});
});
it('should execute simple tasks', function(done) {
var numbers = [1, 3, 2, 4, 7, 8, 6, 5];
var tasks = createSimpleTasks(numbers);
async.angelFall(tasks, function(err, result) {
if (err) {
return done(err);
}
assert.strictEqual(result, 36);
done();
});
});
it('should execute example tasks', function(done) {
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) {
if (err) {
return done(err);
}
assert.strictEqual(arg1, 1);
assert.strictEqual(arg2, 2);
assert.strictEqual(arg3, 3);
assert.strictEqual(arg4, 4);
done();
});
});
it('should execute complex tasks', function(done) {
var tasks = [
function(next) {
next(null, 1);
},
function(arg1, next) {
next(null, arg1, 2);
},
function(arg1, arg2, empty, next) {
next(null, arg1, arg2, 3);
},
function(arg1, arg2, arg3, empty1, empty2, empty3, empty4, next) {
next(null, arg1, arg2, arg3, 4);
},
function(arg1, next) {
next(null, arg1, 2, 3, 4, 5);
},
function(next) {
next(null, 1, 2, 3, 4, 5, 6, 7, 8);
},
function(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, empty, next) {
next(null, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, empty, next);
}
];
async.angelFall(tasks, function(err, a, b, c, d, e, f, g, h, empty) {
if (err) {
return done(err);
}
assert.strictEqual(a, 1);
assert.strictEqual(b, 2);
assert.strictEqual(c, 3);
assert.strictEqual(d, 4);
assert.strictEqual(e, 5);
assert.strictEqual(f, 6);
assert.strictEqual(g, 7);
assert.strictEqual(h, 8);
assert.strictEqual(empty, undefined);
done();
});
});
it('should execute even if task does not have an argument', function(done) {
var order = [];
async.angelFall([
function() {
order.push(1);
return 1;
},
function(next) {
order.push(2);
next();
},
function(arg, next) {
order.push(3);
next();
},
function() {
order.push(4);
return 4;
},
function(arg, next) {
assert.strictEqual(arg, 4);
order.push(5);
next();
}
], function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3, 4, 5]);
done();
});
});
it('should throw error', function(done) {
var numbers = [1, 3, 2, 4];
var tasks = createSimpleTasks(numbers);
var errorTask = function(res, next) {
next('error');
};
tasks.splice(2, 0, errorTask);
async.angelFall(tasks, function(err) {
assert.ok(err);
done();
});
});
it('should throw error if callback is called twice', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 1);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var array = [
function(next) {
setImmediate(function() {
next(null, 'one', 'two');
});
setImmediate(function() {
next(null, 'one', 'two');
});
},
function(arg1, arg2, next) {
next(null, arg1, arg2, 'three');
},
function(arg1, arg2, arg3, next) {
next(null, 'four');
},
function(arg1, next) {
next();
}
];
async.angelFall(array);
});
});
it('should throw error if task is not collection', function(done) {
async.angelFall(null, function(err) {
assert.strictEqual(err.message, 'First argument to waterfall must be an array of functions');
done();
});
});
it('should throw error with binding', function(done) {
var numbers = [1, 3, 2, 4];
var tasks = createSimpleTasks(numbers);
var errorTask = function(res, next) {
next('error');
};
tasks.splice(2, 0, errorTask);
async.angelFall(tasks, function(err) {
assert.ok(err);
done();
}, Math);
});
it('should throw error if task which does not have an argument throws error', function(done) {
var order = [];
async.angelFall([
function() {
order.push(1);
return 1;
},
function(next) {
order.push(2);
next();
},
function(arg, next) {
order.push(3);
next();
},
function() {
order.push(4);
throw new Error('error');
},
function(arg, next) {
order.push(5);
next();
}
], function(err) {
assert.ok(err);
assert.deepStrictEqual(order, [1, 2, 3, 4]);
done();
});
});
it('should avoid double callback', function(done) {
var called = false;
var tasks = _.times(3, function(n) {
return function(callback) {
try {
callback('error' + n);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
}
done();
}
};
});
async.angelFall(tasks, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if array task is empty', function(done) {
var tasks = [];
async.angelFall(tasks, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
done();
});
});
});
neo-async-2.6.1/test/controlFlow/test.apply.js 0000664 0000000 0000000 00000005471 13466145133 0021361 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
parallel('#apply', function() {
it('should apply arguments', function() {
var func = function() {
assert.deepStrictEqual(Array.prototype.slice.call(arguments), [1, 2, 3, 4]);
};
async.apply(func, 1, 2, 3, 4)();
async.apply(func, 1, 2, 3)(4);
async.apply(func, 1, 2)(3, 4);
async.apply(func, 1)(2, 3, 4);
var fn = async.apply(func);
fn(1, 2, 3, 4);
fn(1, 2, 3, 4);
assert.strictEqual(
async.apply(function(name) {
return 'hello ' + name;
}, 'world')(),
'hello world'
);
});
it('should apply long arguments', function() {
var func = function(a1, a2, a3, a4, a5, a6, a7, a8) {
assert.strictEqual(a8, 8);
assert.strictEqual(_.sum(arguments), 55);
};
var newFunc = async.apply(func, 1, 2, 3, 4, 5, 6, 7);
assert.strictEqual(func.length, 8);
assert.strictEqual(newFunc.length, 1);
newFunc(8, 9, 10);
});
it('should execute waterfall with apply', function(done) {
async.waterfall([
function(next) {
next(null, 1);
},
async.apply(function(arg1, arg2, next) {
assert.strictEqual(arg1, 0);
assert.strictEqual(arg2, 1);
next();
}, 0),
async.apply(function(arg1, arg2, arg3, arg4, next) {
assert.strictEqual(arg1, 'a');
assert.strictEqual(arg2, 'b');
assert.strictEqual(arg3, 'c');
assert.strictEqual(arg4, 'd');
next(null, 1, 2, 3);
}, 'a', 'b', 'c', 'd')
], function(err, res1, res2, res3) {
if (err) {
return done(err);
}
assert.strictEqual(res1, 1);
assert.strictEqual(res2, 2);
assert.strictEqual(res3, 3);
done();
});
});
it('should execute angelFall with apply', function(done) {
async.angelFall([
function(next) {
next(null, 1);
},
async.apply(function(arg1, arg2, arg3, next) {
assert.strictEqual(arg1, 0);
assert.strictEqual(arg2, 1);
assert.strictEqual(arg3, undefined);
next();
}, 0),
async.apply(function(arg1, arg2) {
return arg1 + arg2;
}, 1, 2),
async.apply(function(arg1, arg2, arg3, arg4, arg5, arg6, next) {
assert.strictEqual(arg1, 'a');
assert.strictEqual(arg2, 'b');
assert.strictEqual(arg3, 'c');
assert.strictEqual(arg4, 'd');
assert.strictEqual(arg5, 3);
next(null, 1, 2, 3);
}, 'a', 'b', 'c', 'd')
], function(err, res1, res2, res3) {
if (err) {
return done(err);
}
assert.strictEqual(res1, 1);
assert.strictEqual(res2, 2);
assert.strictEqual(res3, 3);
done();
});
});
});
neo-async-2.6.1/test/controlFlow/test.applyEach.js 0000664 0000000 0000000 00000007423 13466145133 0022141 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var util = require('../util');
parallel('#applyEach', function() {
it('should execute in parallel', function(done) {
var order = [];
var one = function(val, cb) {
assert.equal(val, 5);
setTimeout(function() {
order.push(1);
cb(null, 1);
}, 100);
};
var two = function(val, cb) {
assert.equal(val, 5);
setTimeout(function() {
order.push(2);
cb(null, 2);
}, 50);
};
var three = function(val, cb) {
assert.equal(val, 5);
setTimeout(function() {
order.push(3);
cb(null, 3);
}, 150);
};
async.applyEach([one, two, three], 5, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [2, 1, 3]);
assert.deepStrictEqual(res, [1, 2, 3]);
done();
});
});
it('should execute as a partial apprication', function(done) {
var order = [];
var one = function(val, cb) {
assert.equal(val, 5);
setTimeout(function() {
order.push(1);
cb(null, 1);
}, 100);
};
var two = function(val, cb) {
assert.equal(val, 5);
setTimeout(function() {
order.push(2);
cb(null, 2);
}, 50);
};
var three = function(val, cb) {
assert.equal(val, 5);
setTimeout(function() {
order.push(3);
cb(null, 3);
}, 150);
};
async.applyEach([one, two, three])(5, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [2, 1, 3]);
assert.deepStrictEqual(res, [1, 2, 3]);
done();
});
});
it('should avoid double callback', function(done) {
var called = false;
var tasks = _.times(3, function(n) {
return function(val, callback) {
try {
callback(val + n);
} catch(exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
}
done();
}
};
});
async.applyEach(tasks, 5, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
});
parallel('#applyEachSeries', function() {
it('should execute in series', function(done) {
var order = [];
var one = function(val, cb) {
assert.equal(val, 5);
setTimeout(function() {
order.push(1);
cb(null, 1);
}, 100);
};
var two = function(val, cb) {
assert.equal(val, 5);
setTimeout(function() {
order.push(2);
cb(null, 2);
}, 50);
};
var three = function(val, cb) {
assert.equal(val, 5);
setTimeout(function() {
order.push(3);
cb(null, 3);
}, 150);
};
async.applyEachSeries([one, two, three], 5, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [1, 2, 3]);
assert.deepStrictEqual(res, [1, 2, 3]);
done();
});
});
it('should avoid double callback', function(done) {
var called = false;
var tasks = _.times(3, function(n) {
return function(val, callback) {
try {
callback(val + n);
} catch(exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
}
done();
}
};
});
async.applyEachSeries(tasks, 5, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
});
neo-async-2.6.1/test/controlFlow/test.auto.js 0000664 0000000 0000000 00000027032 13466145133 0021201 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var domain = require('domain');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
var util = require('../util');
parallel('#auto', function() {
it('should execute in accordance with best order', function(done) {
var order = [];
var tasks = {
task1: ['task2', function(results, callback) {
setTimeout(function() {
order.push('task1');
callback();
}, 25);
}],
task2: function(callback) {
setTimeout(function() {
order.push('task2');
callback();
}, 50);
},
task3: ['task2', function(results, callback) {
order.push('task3');
callback();
}],
task4: ['task1', 'task2', function(results, callback) {
order.push('task4');
callback();
}],
task5: ['task2', function(results, callback) {
setTimeout(function() {
order.push('task5');
callback();
}, 0);
}],
task6: ['task2', function(results, callback) {
order.push('task6');
callback();
}]
};
async.auto(tasks, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [
'task2',
'task3',
'task6',
'task5',
'task1',
'task4'
]);
done();
});
});
it('should execute in accordance with best order and get results', function(done) {
var order = [];
async.auto({
task1: ['task2', function(results, callback) {
assert.strictEqual(results.task2, 'task2');
setTimeout(function() {
order.push('task1');
callback(null, 'task1a', 'task1b');
}, 25);
}],
task2: function(callback) {
setTimeout(function() {
order.push('task2');
callback(null, 'task2');
});
},
task3: ['task2', function(results, callback) {
assert.strictEqual(results.task2, 'task2');
order.push('task3');
callback();
}],
task4: ['task1', 'task2', function(results, callback) {
assert.deepStrictEqual(results.task1, ['task1a', 'task1b']);
assert.strictEqual(results.task2, 'task2');
order.push('task4');
callback(null, 'task4');
}]
}, function(err, results) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, ['task2', 'task3', 'task1', 'task4']);
assert.deepStrictEqual(results, {
task1: ['task1a', 'task1b'],
task2: 'task2',
task3: undefined,
task4: 'task4'
});
done();
});
});
it('should execute even if array task dosen\'t have nay dependencies', function(done) {
var order = [];
async.auto({
task1: function(callback) {
order.push('task1');
callback(null, 'task1');
},
task2: ['task3', function(task3, callback) {
order.push('task2');
callback(null, 'task2');
}],
task3: [function(callback) {
order.push('task3');
callback(null, 'task3');
}]
}, function(err, results) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [
'task1',
'task3',
'task2'
]);
assert.deepStrictEqual(results, {
task1: 'task1',
task2: 'task2',
task3: 'task3'
});
done();
});
});
it('should execute even if object is empty', function(done) {
async.auto({}, done);
});
it('should execute without callback', function(done) {
var tasks = {
task1: function(callback) {
callback();
},
task2: ['task1', function(results, callback) {
callback();
}]
};
async.auto(tasks);
setTimeout(done, delay);
});
it('should execute without callback', function(done) {
var tasks = {
task1: function(callback) {
callback();
},
task2: ['task1', function(results, callback) {
callback();
}]
};
async.auto(tasks, 1);
setTimeout(done, delay);
});
it('should throw error and get safe results', function(done) {
var order = [];
async.auto({
task1: ['task2', function(results, callback) {
assert.strictEqual(results.task2, 'task2');
setTimeout(function() {
order.push('task1');
callback(null, 'task1a', 'task1b');
}, 25);
}],
task2: function(callback) {
setTimeout(function() {
order.push('task2');
callback(null, 'task2');
});
},
task3: ['task2', function(results, callback) {
assert.strictEqual(results.task2, 'task2');
order.push('task3');
callback('error', 'task3');
}],
task4: ['task1', 'task2', function(results, callback) {
assert.deepStrictEqual(results.task1, ['task1a', 'task1b']);
assert.strictEqual(results.task2, 'task2');
order.push('task4');
callback(null, 'task4');
}]
}, function(err, results) {
assert.ok(err);
assert.deepStrictEqual(order, ['task2', 'task3']);
assert.deepStrictEqual(results, {
task2: 'task2',
task3: 'task3'
});
done();
});
});
it('should avoid double callback', function(done) {
var called = false;
var tasks = {
task1: function(callback) {
try {
callback('error');
} catch(exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
}
done();
}
}
};
async.auto(tasks, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should execute in limited by concurrency', function(done) {
var order = [];
var tasks = {
task1: function(callback) {
order.push('task1');
callback();
},
task2: ['task1', function(results, callback) {
setTimeout(function() {
order.push('task2');
callback();
}, delay * 2);
}],
task3: ['task1', function(results, callback) {
setTimeout(function() {
order.push('task3');
callback();
}, delay * 2);
}],
task4: ['task1', function(results, callback) {
setTimeout(function() {
order.push('task4');
callback();
}, delay * 1);
}],
task5: ['task1', function(results, callback) {
setTimeout(function() {
order.push('task5');
callback();
}, delay * 1);
}],
task6: ['task1', function(results, callback) {
setTimeout(function() {
order.push('task6');
callback();
}, delay * 1);
}]
};
async.auto(tasks, 2, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [
'task1',
'task2',
'task3',
'task4',
'task5',
'task6'
]);
done();
});
});
it('should throw error if double callback', function(done) {
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
done();
})
.run(function() {
async.auto({
task1: function(callback) {
setImmediate(function() {
callback();
callback();
});
},
task2: function(callback) {
callback();
}
});
});
});
it('should stop execution if a synchronous error occur', function(done) {
async.auto({
task1: function(callback) {
callback('error');
},
task2: function(callback) {
assert.ok(false);
callback();
}
}, 1, function(err) {
assert.strictEqual(err, 'error');
setTimeout(done, delay);
});
});
it('should avoid unnecessary deferrals', function(done) {
var sync = true;
async.auto({
task1: function(callback) {
callback(null, 1);
},
task2: ['task1', function(results, callback) {
callback();
}]
}, function(err) {
if (err) {
return done(err);
}
assert.ok(sync);
done();
});
sync = false;
});
it('auto prevent dead-locks due to inexistant dependencies', function() {
var err;
try {
async.auto({
task1: ['noexist', function(results, callback) {
callback(null, 'task1');
}]
});
} catch(e) {
err = e;
assert.ok(e);
assert(/^async.auto task `task1` has non-existent dependency/.test(e.message));
}
assert.ok(err);
});
it('auto prevent dead-locks due to all cyclic dependencies', function() {
var err;
try {
async.auto({
task1: ['task2', function(results, callback) {
callback(null, 'task1');
}],
task2: ['task1', function(results, callback) {
callback(null, 'task2');
}]
});
} catch(e) {
err = e;
assert.ok(e);
assert.strictEqual(e.message, 'async.auto task has cyclic dependencies');
}
assert.ok(err);
});
it('auto prevent dead-locks due to some cyclic dependencies', function() {
var err;
try {
async.auto({
task1: ['task2', function(results, callback) {
callback(null, 'task1');
}],
task2: ['task1', function(results, callback) {
callback(null, 'task2');
}],
task3: function(callback) {
callback(null, 'task3');
},
task4: ['task5', function(results, callback) {
callback(null, 'task4');
}],
task5: ['task4', function(results, callback) {
callback(null, 'task5');
}]
});
} catch(e) {
err = e;
assert.ok(e);
assert.strictEqual(e.message, 'async.auto task has cyclic dependencies');
}
assert.ok(err);
});
it('should throw an error if tasks have cyclic dependencies', function() {
var err;
var task = function(name) {
return function(results, callback) {
callback(null, 'task ' + name);
};
};
try {
async.auto({
a: ['c', task('a')],
b: ['a', task('b')],
c: ['b', task('c')]
});
} catch(e) {
err = e;
assert.ok(e);
assert.strictEqual(e.message, 'async.auto task has cyclic dependencies');
}
assert.ok(err);
});
it('should work even if reserved name is included', function(done) {
// var async = require('async');
var tasks = {
one: function(next) {
next(null, 1);
},
hasOwnProperty: function(next) {
next(null, 2);
}
};
async.auto(tasks, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {
one: 1,
hasOwnProperty: 2
});
done();
});
});
/**
* @see https://github.com/suguru03/neo-async/issues/57
*/
it('should work without cyclic dependencies error', function(done) {
var error = new Error('error');
async.auto({
task1: function(callback) {
setTimeout(callback, delay, error);
},
task2: function(callback) {
setTimeout(callback, delay * 2)
},
task3: ['task1', 'task2', function(callback) {
setTimeout(callback, delay * 2)
}]
}, function(err) {
assert.strictEqual(err, error);
setTimeout(done, delay * 3);
});
});
});
neo-async-2.6.1/test/controlFlow/test.autoInject.js 0000664 0000000 0000000 00000024072 13466145133 0022337 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
var util = require('../util');
parallel('#autoInject', function() {
it('should execute by auto injection', function(done) {
var order = [];
async.autoInject({
task1: function(task2, callback) {
assert.strictEqual(task2, 2);
setTimeout(function() {
order.push('task1');
callback(null, 1);
}, delay);
},
task2: function(callback) {
setTimeout(function() {
order.push('task2');
callback(null, 2);
}, delay * 2);
},
task3: function(task2, callback) {
assert.strictEqual(task2, 2);
order.push('task3');
callback(null, 3);
},
task4: function(task1, task2, callback) {
assert.strictEqual(task1, 1);
assert.strictEqual(task2, 2);
order.push('task4');
callback(null, 4);
},
task5: function(task2, callback) {
assert.strictEqual(task2, 2);
setTimeout(function() {
order.push('task5');
callback(null, 5);
});
},
task6: function(task2, callback) {
assert.strictEqual(task2, 2);
order.push('task6');
callback(null, 6);
}
}, function(err, result) {
if (err) {
return done(err);
}
assert.deepStrictEqual(result, {
task1: 1,
task2: 2,
task3: 3,
task4: 4,
task5: 5,
task6: 6
});
assert.deepStrictEqual(order, [
'task2',
'task3',
'task6',
'task5',
'task1',
'task4'
]);
done();
});
});
it('should work with array tasks', function(done) {
var order = [];
async.autoInject({
task1: [function(callback) {
order.push('task1');
callback(null, 1);
}],
task2: ['task3', function(task3, callback) {
assert.strictEqual(task3, 3);
order.push('task2');
callback(null, 2);
}],
task3: function(callback) {
order.push('task3');
callback(null, 3);
}
}, function(err, result) {
if (err) {
return done(err);
}
assert.deepStrictEqual(result, {
task1: 1,
task2: 2,
task3: 3
});
assert.deepStrictEqual(order, [
'task1',
'task3',
'task2'
]);
done();
});
});
it('should execute tasks', function(done) {
var order = [];
async.autoInject({
task1: function(callback) {
order.push('task1');
callback(null, 1);
},
task2: ['task3', function(task3, callback) {
order.push('task2');
assert.strictEqual(task3, 3);
callback(null, 2);
}],
task2_1: ['task3', function(arg1, callback) {
order.push('task2_1');
assert.strictEqual(arg1, 3);
assert.ok(_.isFunction(callback));
assert.strictEqual(arguments.length, 2);
callback();
}],
task2_2: function(task3, callback) {
order.push('task2_2');
assert.strictEqual(task3, 3);
callback();
},
task2_3: ['task1', 'task3', function(arg1, arg2, callback) {
order.push('task2_3');
assert.strictEqual(arg1, 1);
assert.strictEqual(arg2, 3);
callback();
}],
task2_4: ['task3', function(arg1, callback) {
order.push('task2_4');
assert.strictEqual(arg1, 3);
callback();
}],
task3: function (callback) {
order.push('task3');
callback(null, 3);
}
}, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [
'task1',
'task3',
'task2',
'task2_1',
'task2_2',
'task2_3',
'task2_4'
]);
done();
});
});
it('should execute complex tasks', function(done) {
var order = [];
async.autoInject({
task1: ['task3', 'task2', 'task5', 'task6', function(arg1, arg2, arg3, arg4, callback) {
order.push('task1');
assert.strictEqual(arg1, 3);
assert.strictEqual(arg2, 2);
assert.strictEqual(arg3, 5);
assert.strictEqual(arg4, 6);
callback(null, 1);
}],
task2: function(task3, callback) {
assert.strictEqual(task3, 3);
order.push('task2');
callback(null, 2);
},
task3: ['task5', function(arg1, callback) {
assert.strictEqual(arg1, 5);
order.push('task3');
callback(null, 3);
}],
task4: function(task1, task2, task7, callback) {
assert.strictEqual(task1, 1);
assert.strictEqual(task2, 2);
assert.strictEqual(task7, 7);
order.push('task4');
callback(null, 4);
},
task5: function(callback) {
setTimeout(function() {
order.push('task5');
callback(null, 5);
}, delay * 2);
},
task6: function(task7, callback) {
assert.strictEqual(task7, 7);
order.push('task6');
callback(null, 6);
},
task7: function(callback) {
setTimeout(function() {
order.push('task7');
callback(null, 7);
}, delay);
}
}, function(err, result) {
if (err) {
return done(err);
}
assert.deepStrictEqual(result, {
task1: 1,
task2: 2,
task3: 3,
task4: 4,
task5: 5,
task6: 6,
task7: 7
});
assert.deepStrictEqual(order, [
'task7',
'task6',
'task5',
'task3',
'task2',
'task1',
'task4'
]);
done();
});
});
it('should throw an error if task argument length is zero', function() {
var err;
try {
async.autoInject({
task1: function() {
},
task2: function(task1, callback) {
assert(false);
callback();
}
});
} catch(e) {
err = e;
assert.ok(e);
assert.strictEqual(e.message, 'autoInject task functions require explicit parameters.');
}
assert.ok(err);
});
it('should throw an error if array task length is empty', function() {
var err;
try {
async.autoInject({
task1: [],
task2: function(task1, callback) {
callback();
}
});
} catch(e) {
err = e;
assert.ok(e);
assert.strictEqual(e.message, 'autoInject task functions require explicit parameters.');
}
assert.ok(err);
});
var arrowSupport = true;
try {
/* jshint -W054 */
new Function('x => x');
/* jshint +W054 */
} catch (e) {
arrowSupport = false;
}
if (arrowSupport) {
// Needs to be run on ES6 only
/* jshint -W061 */
eval("(function() { " +
" it('should work with es6 arrow syntax', function (done) { " +
" async.autoInject({ " +
" task1: (cb) => cb(null, 1), " +
" task2: ( task3 , cb ) => cb(null, 2), " +
" task3: cb => cb(null, 3) " +
" }, (err, results) => { " +
" assert.deepStrictEqual(results, { " +
" task1: 1, " +
" task2: 2, " +
" task3: 3 " +
" }); " +
" done(); " +
" }); " +
" }); " +
"}) "
)();
/* jshint +W061 */
}
var defaultSupport = true;
try {
eval('function x(y = 1){ return y }');
}catch (e) {
defaultSupport = false;
}
if(arrowSupport && defaultSupport) {
// Needs to be run on ES6 only
/* eslint {no-eval: 0}*/
eval("(function() { " +
" it('should work with es6 obj method syntax', function (done) { " +
" async.autoInject({ " +
" task1 (cb) { cb(null, 1) }, " +
" task2 ( task3 , cb ) { cb(null, 2) }, " +
" task3 (cb) { cb(null, 3) }, " +
" task4 ( task2 , cb ) { cb(null) }, " +
" task5 ( task4 = 4 , cb ) { cb(null, task4 + 1) } " +
" }, (err, results) => { " +
" assert.strictEqual(results.task1, 1); " +
" assert.strictEqual(results.task3, 3); " +
" assert.strictEqual(results.task4, undefined); " +
" assert.strictEqual(results.task5, 5); " +
" done(); " +
" }); " +
" }); " +
"}) "
)();
}
it('should avoid double callback', function(done) {
var called = false;
var tasks = {
task1: function(callback) {
try {
callback('error');
} catch(exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
}
done();
}
}
};
async.autoInject(tasks, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
});
neo-async-2.6.1/test/controlFlow/test.cargo.js 0000664 0000000 0000000 00000017167 13466145133 0021334 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
var util = require('../util');
parallel('#cargo', function() {
it('should execute in accordance with payload', function(done) {
var order = [];
var delays = [4 * delay, 4 * delay, 2 * delay];
var iterator = function(tasks, callback) {
setTimeout(function() {
order.push('process ' + tasks.join(' '));
callback('err', 'arg');
}, delays.shift());
};
var cargo = async.cargo(iterator, 2);
cargo.push(1, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(cargo.length(), 3);
order.push('callback ' + 1);
});
cargo.push(2, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(cargo.length(), 3);
order.push('callback ' + 2);
});
assert.strictEqual(cargo.length(), 2);
setTimeout(function() {
cargo.push(3, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(cargo.length(), 1);
order.push('callback ' + 3);
});
}, 2 * delay);
setTimeout(function() {
cargo.push(4, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(cargo.length(), 1);
order.push('callback ' + 4);
});
assert.strictEqual(cargo.length(), 2);
cargo.push(5, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
order.push('callback ' + 5);
assert.strictEqual(cargo.length(), 0);
});
}, 3 * delay);
setTimeout(function() {
assert.deepStrictEqual(order, [
'process 1 2', 'callback 1', 'callback 2',
'process 3 4', 'callback 3', 'callback 4',
'process 5', 'callback 5'
]);
assert.strictEqual(cargo.length(), 0);
done();
}, 20 * delay);
});
it('should execute without callback', function(done) {
var order = [];
var delays = [
4 * delay,
2 * delay,
6 * delay,
2 * delay
];
var c = async.cargo(function(tasks, callback) {
setTimeout(function() {
order.push('process ' + tasks.join(' '));
callback('error', 'arg');
}, delays.shift());
}, 2);
c.push(1);
setTimeout(function() {
c.push(2);
}, 3 * delay);
setTimeout(function() {
c.push(3);
c.push(4);
c.push(5);
}, 4.5 * delay);
setTimeout(function() {
assert.deepStrictEqual(order, [
'process 1',
'process 2',
'process 3 4',
'process 5'
]);
done();
}, 20 * delay);
});
it('should execute with bulk tasks', function(done) {
var order = [];
var delays = [3 * delay, delay];
var c = async.cargo(function(tasks, callback) {
setTimeout(function() {
order.push('process ' + tasks.join(' '));
callback('error', tasks.join(' '));
}, delays.shift());
}, 3);
c.push([1, 2, 3, 4], function(err, arg) {
assert.strictEqual(err, 'error');
order.push('callback ' + arg);
});
assert.strictEqual(c.length(), 4);
setTimeout(function() {
assert.deepStrictEqual(order, [
'process 1 2 3',
'callback 1 2 3',
'callback 1 2 3',
'callback 1 2 3',
'process 4',
'callback 4'
]);
done();
}, 20 * delay);
});
it('should execute drain once', function(done) {
var order = [];
var c = async.cargo(function(tasks, callback) {
order.push(tasks);
callback();
}, 3);
var drainCounter = 0;
c.drain = function() {
drainCounter++;
};
var n = 10;
_.times(n, c.push);
assert.strictEqual(c.length(), 10);
setTimeout(function() {
assert.deepStrictEqual(order, [
[0, 1, 2],
[3, 4, 5],
[6, 7, 8],
[9]
]);
assert.strictEqual(drainCounter, 1);
done();
}, 120);
});
it('should execute drain twice', function(done) {
var order = [];
var c = async.cargo(function(tasks, callback) {
order.push(tasks);
assert.ok(c.running());
callback();
}, 3);
var drainCounter = 0;
c.drain = function() {
drainCounter++;
};
var saturated = false;
c.saturated = function() {
saturated = true;
};
var n = 10;
var loadCargo = _.times.bind(_, n, c.push);
loadCargo();
assert.strictEqual(c.length(), 10);
var empty = false;
c.empty = function() {
empty = true;
};
setTimeout(loadCargo, 5 * delay);
setTimeout(function() {
assert.deepStrictEqual(order, [
[0, 1, 2],
[3, 4, 5],
[6, 7, 8],
[9],
[0, 1, 2],
[3, 4, 5],
[6, 7, 8],
[9]
]);
assert.strictEqual(drainCounter, 2);
assert.ok(saturated);
assert.ok(empty);
done();
}, 10 * delay);
});
it('should get workers list', function(done) {
var order = [];
var workersList = [];
var tasks = [0, 1, 2, 3, 4];
var payload = 3;
var worker = function(tasks, callback) {
order.push(tasks);
workersList.push(_.cloneDeep(c.workersList()));
callback();
};
var c = async.cargo(worker, payload);
c.push(tasks);
c.drain = function() {
assert.deepStrictEqual(order, [
[0, 1, 2],
[3, 4]
]);
assert.strictEqual(workersList.length, 2);
assert.strictEqual(workersList[0].length, 3);
assert.strictEqual(workersList[1].length, 2);
done();
};
});
it('should check events', function (done) {
var calls = [];
var q = async.cargo(function(task, cb) {
// nop
calls.push('process ' + task);
async.setImmediate(cb);
}, 1);
q.concurrency = 3;
q.saturated = function() {
assert(q.running() === 3, 'cargo should be saturated now');
calls.push('saturated');
};
q.empty = function() {
assert(q.length() === 0, 'cargo should be empty now');
calls.push('empty');
};
q.drain = function() {
assert(
q.length() === 0 && q.running() === 0,
'cargo should be empty now and no more workers should be running'
);
calls.push('drain');
assert.deepStrictEqual(calls, [
'process foo',
'process bar',
'saturated',
'process zoo',
'foo cb',
'saturated',
'process poo',
'bar cb',
'empty',
'saturated',
'process moo',
'zoo cb',
'poo cb',
'moo cb',
'drain'
]);
done();
};
q.push('foo', function () {calls.push('foo cb');});
q.push('bar', function () {calls.push('bar cb');});
q.push('zoo', function () {calls.push('zoo cb');});
q.push('poo', function () {calls.push('poo cb');});
q.push('moo', function () {calls.push('moo cb');});
});
it('should avoid double callback', function(done) {
var called = false;
var iterator = function(task, callback) {
try {
callback('error');
} catch(exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
}
done();
}
};
var cargo = async.cargo(iterator);
cargo.push(1, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
});
neo-async-2.6.1/test/controlFlow/test.compose.js 0000664 0000000 0000000 00000005642 13466145133 0021701 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
parallel('#compose', function() {
it('should execute in order of insertion', function(done) {
var add2 = function(n, cb) {
assert.strictEqual(n, 3);
setTimeout(function() {
cb(null, n + 2);
}, 50);
};
var mul3 = function(n, cb) {
assert.strictEqual(n, 5);
setTimeout(function() {
cb(null, n * 3);
}, 15);
};
var add1 = function(n, cb) {
assert.strictEqual(n, 15);
setTimeout(function() {
cb(null, n + 1);
}, 100);
};
var add2mul3add1 = async.compose(add1, mul3, add2);
add2mul3add1(3, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 16);
done();
});
});
it('should execute in order of insertion with binding', function(done) {
var pow2 = function(n, cb) {
var self = this;
assert.strictEqual(n, 3);
setTimeout(function() {
cb(null, self.pow(n, 2));
}, 50);
};
var mul3 = function(n, cb) {
assert.strictEqual(n, 9);
setTimeout(function() {
cb(null, n * 3);
}, 15);
};
var pow3 = function(n, cb) {
var self = this;
assert.strictEqual(n, 27);
setTimeout(function() {
cb(null, self.pow(n, 3));
}, 100);
};
var add2mul3add1 = async.compose(pow3, mul3, pow2);
add2mul3add1.call(Math, 3, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 19683);
done();
});
});
it('should throw error', function(done) {
var add2 = function(n, cb) {
assert.strictEqual(n, 3);
setTimeout(function() {
cb(null, n + 2);
}, 50);
};
var mul3 = function(n, cb) {
assert.strictEqual(n, 5);
setTimeout(function() {
cb(new Error('error'));
}, 15);
};
var add1 = function(n, cb) {
setTimeout(function() {
cb(null, n + 1);
}, 100);
};
var add2mul3add1 = async.compose(add1, mul3, add2);
add2mul3add1(3, function(err) {
assert.ok(err);
done();
});
});
it('should execute with binding', function(done) {
var testContext = {
name: 'foo'
};
var add2 = function(n, cb) {
assert.strictEqual(this, testContext);
setTimeout(function() {
cb(null, n + 2);
}, 50);
};
var mul3 = function(n, cb) {
assert.strictEqual(this, testContext);
setTimeout(function() {
cb(null, n * 3);
}, 15);
};
var add2mul3add1 = async.compose(mul3, add2);
add2mul3add1.call(testContext, 3, function(err, result) {
if (err) {
return done(err);
}
assert.strictEqual(this, testContext);
assert.strictEqual(result, 15);
done();
});
});
});
neo-async-2.6.1/test/controlFlow/test.during.js 0000664 0000000 0000000 00000013752 13466145133 0021525 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
parallel('#during', function() {
it('should execute until asynchronous test is false', function(done) {
var order = [];
var count = 0;
var test = function(callback) {
order.push(['test', count]);
callback(null, count < 5);
};
var iterator = function(callback) {
order.push(['iterator', count]);
count++;
setTimeout(function() {
callback();
}, 10);
};
async.during(test, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(count, 5);
assert.deepStrictEqual(order, [
['test', 0],
['iterator', 0],
['test', 1],
['iterator', 1],
['test', 2],
['iterator', 2],
['test', 3],
['iterator', 3],
['test', 4],
['iterator', 4],
['test', 5]
]);
done();
});
});
it('should execute without binding until asynchronous test is false', function(done) {
var count = 0;
var sum = 0;
var test = function(callback) {
callback(null, count < 5);
};
var iterator = function(callback) {
count++;
sum += this && this.num || 3;
setTimeout(function() {
callback();
}, 10);
};
async.during(test, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(count, 5);
assert.strictEqual(sum, 15);
done();
}, {
num: 2
});
});
it('should throw error if error occurs in test', function(done) {
var count = 0;
var test = function(callback) {
callback(new Error('error'));
};
var iterator = function(callback) {
count++;
callback();
};
async.during(test, iterator, function(err) {
assert.ok(err);
assert.strictEqual(count, 0);
done();
});
});
it('should throw error if error occurs in iterator', function(done) {
var count = 0;
var test = function(callback) {
callback(null, count < 5);
};
var iterator = function(callback) {
count++;
callback(new Error('error'));
};
async.during(test, iterator, function(err) {
assert.ok(err);
assert.strictEqual(count, 1);
done();
});
});
});
parallel('#doDuring', function() {
it('should execute until asynchronous test is false', function(done) {
var order = [];
var count = 0;
var test = function(callback) {
order.push(['test', count]);
callback(null, count < 5);
};
var iterator = function(callback) {
order.push(['iterator', count]);
count++;
setTimeout(function() {
callback();
}, 10);
};
async.doDuring(iterator, test, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(count, 5);
assert.deepStrictEqual(order, [
['iterator', 0],
['test', 1],
['iterator', 1],
['test', 2],
['iterator', 2],
['test', 3],
['iterator', 3],
['test', 4],
['iterator', 4],
['test', 5]
]);
done();
});
});
it('should execute with binding until asynchronous test is false', function(done) {
var order = [];
var count = 0;
var sum = 0;
var test = function(callback) {
order.push(['test', count]);
callback(null, count < 5);
};
var iterator = function(callback) {
order.push(['iterator', count]);
count++;
sum += this && this.num || 3;
setTimeout(function() {
callback();
}, 10);
};
async.doDuring(iterator, test, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(count, 5);
assert.strictEqual(sum, 15);
assert.deepStrictEqual(order, [
['iterator', 0],
['test', 1],
['iterator', 1],
['test', 2],
['iterator', 2],
['test', 3],
['iterator', 3],
['test', 4],
['iterator', 4],
['test', 5]
]);
done();
}, {
num: 2
});
});
it('should execute with some arguments', function(done) {
var order = [];
var count = 0;
var test = function() {
order.push(['test', count]);
if (count % 2) {
assert.strictEqual(arguments.length, 2);
} else {
assert.strictEqual(arguments.length, 3);
}
var callback = _.slice(arguments).pop();
callback(null, count < 5);
};
var iterator = function(callback) {
order.push(['iterator', count]);
count++;
setTimeout(function() {
if (count % 2) {
callback(null, 1);
} else {
callback(null, 1, 2);
}
}, 10);
};
async.doDuring(iterator, test, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order, [
['iterator', 0],
['test', 1],
['iterator', 1],
['test', 2],
['iterator', 2],
['test', 3],
['iterator', 3],
['test', 4],
['iterator', 4],
['test', 5]
]);
done();
});
});
it('should throw error if error occurs in test', function(done) {
var count = 0;
var test = function(callback) {
callback(new Error('error'));
};
var iterator = function(callback) {
count++;
callback();
};
async.doDuring(iterator, test, function(err) {
assert.ok(err);
assert.strictEqual(count, 1);
done();
});
});
it('should throw error if error occurs in iterator', function(done) {
var count = 0;
var test = function(callback) {
callback(null, count < 5);
};
var iterator = function(callback) {
count++;
callback(new Error('error'));
};
async.doDuring(iterator, test, function(err) {
assert.ok(err);
assert.strictEqual(count, 1);
done();
});
});
});
neo-async-2.6.1/test/controlFlow/test.forever.js 0000664 0000000 0000000 00000004266 13466145133 0021705 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var domain = require('domain');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
parallel('#forever', function() {
it('should execute until error occurs', function(done) {
var count = 0;
var limit = 5;
var order = [];
var iterator = function(callback) {
order.push(count++);
if (count === limit) {
return callback(new Error('end'));
}
callback();
};
async.forever(iterator, function(err) {
assert.ok(err);
assert.deepStrictEqual(order, [0, 1, 2, 3, 4]);
done();
});
});
it('should execute without binding until error occurs', function(done) {
var count = 0;
var limit = 5;
var order = [];
var result = [];
var iterator = function(callback) {
assert.strictEqual(this, undefined);
result.push(count * count);
order.push(count++);
if (count === limit) {
return callback(new Error('end'));
}
callback();
};
async.forever(iterator, function(err) {
assert.ok(err);
assert.deepStrictEqual(order, [0, 1, 2, 3, 4]);
assert.deepStrictEqual(result, [0, 1, 4, 9, 16]);
done();
}, Math);
});
it('should execute on asynchronous', function(done) {
var sync = true;
var count = 0;
var limit = 5;
var iterator = function(callback) {
if (count++ === limit) {
return callback(new Error('end'));
}
callback();
};
async.forever(iterator, function(err) {
assert.ok(err);
assert.strictEqual(sync, false);
done();
});
sync = false;
});
it('should throw error', function(done) {
var count = 0;
var limit = 5;
var order = [];
var iterator = function(callback) {
order.push(count++);
if (count === limit) {
return callback(new Error('end'));
}
callback();
};
domain.create()
.on('error', function(err) {
assert.strictEqual(err.message, 'end');
assert.deepStrictEqual(order, [0, 1, 2, 3, 4]);
done();
})
.run(function() {
async.forever(iterator);
});
});
});
neo-async-2.6.1/test/controlFlow/test.iterator.js 0000664 0000000 0000000 00000005127 13466145133 0022063 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
parallel('#iterator', function() {
it('should execute iterators', function(done) {
var order = [];
var iterator = async.iterator([
function() {
order.push(1);
},
function(arg1) {
assert.strictEqual(arg1, 'arg1');
order.push(2);
},
function(arg1, arg2) {
assert.strictEqual(arg1, 'arg1');
assert.strictEqual(arg2, 'arg2');
order.push(3);
}
]);
iterator();
assert.deepStrictEqual(order, [1]);
var iterator2 = iterator();
assert.deepStrictEqual(order, [1, 1]);
var iterator3 = iterator2('arg1');
assert.deepStrictEqual(order, [1, 1, 2]);
var iterator4 = iterator3('arg1', 'arg2');
assert.deepStrictEqual(order, [1, 1, 2, 3]);
assert.strictEqual(iterator4, null);
done();
});
it('should execute object iterators', function(done) {
var order = [];
var iterator = async.iterator({
a: function() {
order.push(1);
},
b: function(arg1) {
assert.strictEqual(arg1, 'arg1');
order.push(2);
},
c: function(arg1, arg2) {
assert.strictEqual(arg1, 'arg1');
assert.strictEqual(arg2, 'arg2');
order.push(3);
}
});
iterator();
assert.deepStrictEqual(order, [1]);
var iterator2 = iterator();
assert.deepStrictEqual(order, [1, 1]);
var iterator3 = iterator2('arg1');
assert.deepStrictEqual(order, [1, 1, 2]);
var iterator4 = iterator3('arg1', 'arg2');
assert.deepStrictEqual(order, [1, 1, 2, 3]);
assert.strictEqual(iterator4, null);
done();
});
it('should get undefined if array is empty', function(done) {
var iterator = async.iterator([]);
assert.deepStrictEqual(iterator(), null);
assert.deepStrictEqual(iterator.next(), null);
done();
});
it('should get next iterator', function(done) {
var order = [];
var iterator = async.iterator([
function() {
order.push(1);
},
function(arg1) {
assert.strictEqual(arg1, 'arg1');
order.push(2);
},
function(arg1, arg2) {
assert.strictEqual(arg1, 'arg1');
assert.strictEqual(arg2, 'arg2');
order.push(3);
}
]);
var fn = iterator.next();
var iterator2 = fn('arg1');
assert.deepStrictEqual(order, [2]);
iterator2('arg1', 'arg2');
assert.deepStrictEqual(order, [2, 3]);
assert.deepStrictEqual(iterator2.next(), null);
done();
});
});
neo-async-2.6.1/test/controlFlow/test.parallel.js 0000664 0000000 0000000 00000024472 13466145133 0022032 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var domain = require('domain');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
var util = require('../util');
function createTasks(order, numbers) {
return _.transform(numbers, function(memo, num, index) {
memo[index] = function(callback) {
var self = this;
setTimeout(function() {
order.push(num);
if (self && self.round) {
num = self.round(num);
}
callback(null, num * 2);
}, num * delay);
};
});
}
parallel('#parallel', function() {
it('should execute in parallel by tasks of array', function(done) {
var order = [];
var numbers = [1, 3, 2, 4];
var tasks = createTasks(order, numbers);
tasks.push(function(cb) {
setTimeout(function() {
order.push(5);
cb(null, 5, 5);
}, delay * 5);
});
async.parallel(tasks, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [2, 6, 4, 8, [5, 5]]);
assert.deepStrictEqual(order, [1, 2, 3, 4, 5]);
done();
});
});
it('should execute in parallel by tasks of object', function(done) {
var order = [];
var numbers = {
a: 4,
b: 2,
c: 1,
d: 3
};
var tasks = createTasks(order, numbers);
async.parallel(tasks, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {
c: 2,
b: 4,
d: 6,
a: 8
});
assert.deepStrictEqual(order, [1, 2, 3, 4]);
done();
});
});
it('should execute in parallel by tasks of array without binding', function(done) {
var order = [];
var numbers = [1.2, 2.4, 1.5, 3.6];
var tasks = createTasks(order, numbers);
async.parallel(tasks, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [2.4, 4.8, 3, 7.2]);
assert.deepStrictEqual(order, [1.2, 1.5, 2.4, 3.6]);
done();
}, Math);
});
it('should execute in parallel by tasks of object without binding', function(done) {
var order = [];
var numbers = {
a: 1.2,
b: 2.4,
c: 1.5,
d: 3.6
};
var tasks = createTasks(order, numbers);
async.parallel(tasks, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {
a: 2.4,
c: 3,
b: 4.8,
d: 7.2
});
assert.deepStrictEqual(order, [1.2, 1.5, 2.4, 3.6]);
done();
}, Math);
});
it('should return response immediately if array task is empty', function(done) {
var tasks = [];
async.parallel(tasks, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, []);
done();
});
});
it('should return response immediately if object task is empty', function(done) {
var tasks = {};
async.parallel(tasks, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {});
done();
});
});
it('should return response immediately if task is not collection', function(done) {
async.parallel(null, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
done();
});
});
it('should throw error', function(done) {
var order = [];
var numbers = [1, 3, 2, 4];
var tasks = createTasks(order, numbers);
var error = function(callback) {
setTimeout(function() {
callback('error');
}, delay * 2.5);
};
tasks.splice(2, 0, error);
async.parallel(tasks, function(err) {
assert.ok(err);
assert.deepStrictEqual(order, [1, 2]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 1);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var tasks = [function(next) {
process.nextTick(next);
process.nextTick(next);
}];
async.parallel(tasks);
});
});
it('should throw error only once', function(done) {
var error = function(callback) {
setTimeout(function() {
callback('error');
}, delay);
};
var called = false;
var tasks = [error, error, error, error];
async.parallel(tasks, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
setTimeout(done, delay * 2);
});
});
it('should avoid double callback', function(done) {
var called = false;
var tasks = _.times(3, function(n) {
return function(callback) {
try {
callback('error' + n);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
}
done();
}
};
});
async.parallel(tasks, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
});
parallel('#parallelLimit', function() {
it('should execute in limited by tasks of array', function(done) {
var order = [];
var numbers = [1, 4, 2, 3, 1];
var tasks = createTasks(order, numbers);
tasks.push(function(cb) {
setTimeout(function() {
order.push(5);
cb(null, 5, 5);
}, delay * 1.5);
});
async.parallelLimit(tasks, 2, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [2, 8, 4, 6, 2, [5, 5]]);
assert.deepStrictEqual(order, [1, 2, 4, 1, 3, 5]);
done();
});
});
it('should execute in limited by tasks of object', function(done) {
var order = [];
var numbers = {
a: 4,
b: 2,
c: 1,
d: 3,
e: 1
};
var tasks = createTasks(order, numbers);
async.parallelLimit(tasks, 2, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {
b: 4,
a: 8,
c: 2,
d: 6,
e: 2
});
assert.deepStrictEqual(order, [2, 1, 4, 1, 3]);
done();
});
});
it('should execute in parallel by tasks of array without binding', function(done) {
var order = [];
var numbers = [1.2, 2.4, 1.5, 3.6];
var tasks = createTasks(order, numbers);
async.parallelLimit(tasks, 3, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [2.4, 4.8, 3, 7.2]);
assert.deepStrictEqual(order, [1.2, 1.5, 2.4, 3.6]);
done();
}, Math);
});
it('should execute in parallel by tasks of object without binding', function(done) {
var order = [];
var numbers = {
a: 1.2,
b: 2.4,
c: 1.5,
d: 3.6
};
var tasks = createTasks(order, numbers);
async.parallelLimit(tasks, 3, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {
a: 2.4,
c: 3,
b: 4.8,
d: 7.2
});
assert.deepStrictEqual(order, [1.2, 1.5, 2.4, 3.6]);
done();
}, Math);
});
it('should execute on asynchronous', function(done) {
var sync = true;
var numbers = {
a: 4,
b: 2,
c: 1,
d: 3,
e: 1
};
var tasks = _.mapValues(numbers, function(value) {
return function(done) {
done(null, value * 2);
};
});
async.parallelLimit(tasks, 2, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.deepStrictEqual(res, {
b: 4,
a: 8,
c: 2,
d: 6,
e: 2
});
done();
});
sync = false;
});
it('should return response immediately if array task is empty', function(done) {
var tasks = [];
async.parallelLimit(tasks, 2, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, []);
done();
});
});
it('should return response immediately if object task is empty', function(done) {
var tasks = {};
async.parallelLimit(tasks, 2, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {});
done();
});
});
it('should return response immediately if task is not collection', function(done) {
async.parallelLimit(null, 2, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
done();
});
});
it('should throw error', function(done) {
var order = [];
var numbers = [1, 3, 2, 4];
var tasks = createTasks(order, numbers);
var error = function(callback) {
setTimeout(function() {
callback('error');
}, delay * 2.5);
};
tasks.splice(2, 0, error);
async.parallelLimit(tasks, 2, function(err) {
assert.ok(err);
assert.deepStrictEqual(order, [1, 3]);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 1);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var tasks = [function(next) {
process.nextTick(next);
process.nextTick(next);
}];
async.parallelLimit(tasks, 4);
});
});
it('should avoid double callback', function(done) {
var called = false;
var tasks = _.times(3, function(n) {
return function(callback) {
try {
callback('error' + n);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
}
done();
}
};
});
async.parallelLimit(tasks, 2, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
});
neo-async-2.6.1/test/controlFlow/test.queue.js 0000664 0000000 0000000 00000065434 13466145133 0021365 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var domain = require('domain');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
var util = require('../util');
parallel('#queue', function() {
it('should execute queue', function(done) {
var order = {
callback: [],
process: []
};
var delays = [160, 80, 240, 80];
var worker = function piyo(data, callback) {
setTimeout(function() {
order.process.push(data);
callback('err', 'arg');
}, delays.shift());
};
var concurrency = 2;
var queue = async.queue(worker, concurrency);
queue.push(1, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(queue.length(), 1);
order.callback.push(1);
});
queue.push(2, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(queue.length(), 2);
order.callback.push(2);
});
queue.push(3, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(queue.length(), 0);
order.callback.push(3);
});
queue.push(4, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(queue.length(), 0);
order.callback.push(4);
});
assert.strictEqual(queue.length(), 4);
assert.strictEqual(queue.concurrency, concurrency);
queue.drain = function() {
assert.deepStrictEqual(order.callback, [2, 1, 4, 3]);
assert.deepStrictEqual(order.process, [2, 1, 4, 3]);
assert.strictEqual(queue.length(), 0);
assert.strictEqual(queue.concurrency, concurrency);
done();
};
});
it('should execute even if task name is zero', function(done) {
var order = {
callback: [],
process: []
};
var worker = function(data, callback) {
order.process.push(data);
callback('err', 'arg');
};
var queue = async.queue(worker);
queue.push(0, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(queue.length(), 1);
order.callback.push(0);
});
queue.push(1, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(queue.length(), 0);
order.callback.push(1);
});
queue.drain = function() {
assert.deepStrictEqual(order.callback, [0, 1]);
assert.deepStrictEqual(order.process, [0, 1]);
assert.strictEqual(queue.length(), 0);
done();
};
});
it('should execute queue with default concurrency', function(done) {
var order = {
callback: [],
process: []
};
var delays = [160, 80, 240, 80];
var worker = function(data, callback) {
setTimeout(function() {
order.process.push(data);
callback('err', 'arg');
}, delays.shift());
};
var queue = async.queue(worker);
queue.push(1, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(queue.length(), 3);
order.callback.push(1);
});
queue.push(2, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(queue.length(), 2);
order.callback.push(2);
});
queue.push(3, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(queue.length(), 1);
order.callback.push(3);
});
queue.push(4, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(queue.length(), 0);
order.callback.push(4);
});
assert.strictEqual(queue.length(), 4);
assert.strictEqual(queue.concurrency, 1);
queue.drain = function() {
assert.deepStrictEqual(order.callback, [1, 2, 3, 4]);
assert.deepStrictEqual(order.process, [1, 2, 3, 4]);
assert.strictEqual(queue.length(), 0);
assert.strictEqual(queue.concurrency, 1);
done();
};
});
it('should execute queue and throw error', function(done) {
var results = [];
var iterator = function(task, callback) {
if (task.name === 'fuga') {
return callback(new Error('error'));
}
callback();
};
var queue = async.queue(iterator);
queue.drain = function() {
assert.deepStrictEqual(results, ['hoge', 'fugaError', 'piyo']);
done();
};
var names = ['hoge', 'fuga', 'piyo'];
_.forEach(names, function(name) {
queue.push({
name: name
}, function(err) {
if (err) {
results.push(name + 'Error');
} else {
results.push(name);
}
});
});
});
it('should throw error if concurrency is zero', function(done) {
domain.create()
.on('error', function(err) {
assert.strictEqual(err.message, 'Concurrency must not be zero');
done();
})
.run(function() {
var order = {
callback: [],
process: []
};
var delays = [160, 80, 240, 80];
var worker = function(data, callback) {
setTimeout(function() {
order.process.push(data);
callback('err', 'arg');
}, delays.shift());
};
setImmediate(function() {
async.queue(worker, 0);
});
});
});
it('should call global error handler', function(done) {
var results = [];
var q = async.queue(function (task, callback) {
callback(task.name === 'foo' ? new Error('fooError') : null);
}, 2);
q.error = function(err, task) {
assert.ok(err);
assert.strictEqual(err.message, 'fooError');
assert.strictEqual(task.name, 'foo');
results.push('fooError');
};
q.drain = function() {
assert.deepStrictEqual(results, ['fooError', 'bar']);
done();
};
q.push({ name: 'foo' });
q.push({ name: 'bar' }, function(err) {
if (err) {
return done(err);
}
results.push('bar');
});
});
it('should avoid double callback', function(done) {
var called = false;
var iterator = function(task, callback) {
try {
callback('error');
} catch(exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
}
done();
}
};
var queue = async.queue(iterator);
queue.push(1, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should execute while changing concurrency', function(done) {
var order = {
callback: [],
process: []
};
var delays = [160, 80, 240, 80];
var worker = function(data, callback) {
setTimeout(function() {
order.process.push(data);
callback('err', 'arg');
}, delays.shift());
};
var queue = async.queue(worker, 2);
queue.push(1, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(queue.length(), 1);
queue.concurrency = 1;
order.callback.push(1);
});
queue.push(2, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(queue.length(), 2);
order.callback.push(2);
});
queue.push(3, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(queue.length(), 1);
order.callback.push(3);
});
queue.push(4, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(queue.length(), 0);
order.callback.push(4);
});
assert.strictEqual(queue.length(), 4);
assert.strictEqual(queue.concurrency, 2);
queue.drain = function() {
assert.deepStrictEqual(order.callback, [2, 1, 3, 4]);
assert.deepStrictEqual(order.process, [2, 1, 3, 4]);
assert.strictEqual(queue.length(), 0);
assert.strictEqual(queue.concurrency, 1);
done();
};
});
it('should execute using unshift', function(done) {
var order = {
callback: [],
process: []
};
var delays = [160, 80, 240, 80];
var worker = function(data, callback) {
setTimeout(function() {
order.process.push(data);
callback('err', 'arg');
}, delays.shift());
};
var queue = async.queue(worker, 2);
queue.saturated = function() {
setTimeout(function() {
assert.strictEqual(queue.running(), 2);
}, 40);
};
queue.unshift(1, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(queue.length(), 0);
queue.concurrency = 1;
order.callback.push(1);
});
queue.push(2, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(queue.length(), 0);
order.callback.push(2);
});
queue.unshift(3, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(queue.length(), 2);
order.callback.push(3);
});
queue.unshift(4, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(queue.length(), 1);
order.callback.push(4);
});
assert.strictEqual(queue.length(), 4);
assert.strictEqual(queue.concurrency, 2);
queue.drain = function() {
assert.deepStrictEqual(order.callback, [3, 4, 2, 1]);
assert.deepStrictEqual(order.process, [3, 4, 2, 1]);
assert.strictEqual(queue.length(), 0);
assert.strictEqual(queue.concurrency, 1);
done();
};
});
it('should execute drain immediately if insert task is empty', function(done) {
var order = [];
var worker = function(data, callback) {
order.push(1);
callback();
};
var queue = async.queue(worker);
queue.drain = function() {
assert.deepStrictEqual(order, []);
done();
};
queue.push();
});
it('should execute empty function if task is empty', function(done) {
var worker = function(data, callback) {
setTimeout(function() {
callback();
}, 50);
};
var called = false;
var queue = async.queue(worker);
queue.empty = function() {
assert.strictEqual(queue.length(), 0);
called = true;
};
queue.push(1, function() {
assert.strictEqual(queue.length(), 0);
});
queue.drain = function() {
assert.ok(called);
done();
};
});
it('should pause, resume and kill', function(done) {
var order = [];
var delays = [40, 20];
var worker = function(data, callback) {
setTimeout(function() {
order.push(data);
callback();
}, delays.shift());
};
var queue = async.queue(worker);
queue.resume();
queue.pause();
queue.push(1, function() {
assert.strictEqual(queue.length(), 0);
});
queue.push(2, function() {});
setTimeout(function() {
queue.resume();
}, 100);
setTimeout(function() {
queue.kill();
}, 120);
setTimeout(function() {
assert.deepStrictEqual(order, [1]);
done();
}, 200);
});
it('should kill process', function(done) {
var q = async.queue(function(task, callback) {
setTimeout(function() {
assert.equal(false, 'Function should never be called');
callback();
}, 100);
}, 1);
q.drain = function() {
assert.equal(false, 'Function should never be called');
};
q.push(0);
q.kill();
setTimeout(function() {
assert.strictEqual(q.length(), 0);
done();
}, 200);
});
it('should check events', function(done) {
var calls = [];
var q = async.queue(function(task, cb) {
// nop
calls.push('process ' + task);
setImmediate(cb);
}, 10);
q.concurrency = 3;
q.saturated = function() {
assert.strictEqual(q.running(), q.concurrency);
calls.push('saturated');
};
q.empty = function() {
assert.strictEqual(q.length(), 0);
calls.push('empty');
};
q.drain = function() {
assert.strictEqual(q.length(), 0);
assert.strictEqual(q.running(), 0);
calls.push('drain');
assert.deepStrictEqual(calls, [
'process foo',
'process bar',
'saturated',
'process zoo',
'foo cb',
'saturated',
'process poo',
'bar cb',
'empty',
'saturated',
'process moo',
'zoo cb',
'poo cb',
'moo cb',
'drain'
]);
done();
};
q.push('foo', function() {
calls.push('foo cb');
});
q.push('bar', function() {
calls.push('bar cb');
});
q.push('zoo', function() {
calls.push('zoo cb');
});
q.push('poo', function() {
calls.push('poo cb');
});
q.push('moo', function() {
calls.push('moo cb');
});
});
it('should start', function(done) {
var q = async.queue(function() {});
assert.strictEqual(q.started, false);
q.push([]);
assert.strictEqual(q.started, true);
done();
});
it('should check concurrency when queue paused and resumed', function(done) {
var order = [];
var q = async.queue(function(task, callback) {
var name = task.name;
order.push(['process', name]);
setTimeout(function() {
order.push(['called', name]);
callback();
}, 100);
}, 5);
q.pause();
_.times(10, function(n) {
q.push({
name: ++n
});
});
setTimeout(q.resume, 100);
q.drain = function() {
assert.deepStrictEqual(order, [
['process', 1],
['process', 2],
['process', 3],
['process', 4],
['process', 5],
['called', 1],
['process', 6],
['called', 2],
['process', 7],
['called', 3],
['process', 8],
['called', 4],
['process', 9],
['called', 5],
['process', 10],
['called', 6],
['called', 7],
['called', 8],
['called', 9],
['called', 10]
]);
done();
};
});
it('should get workers list', function(done) {
var order = [];
var q = async.queue(function(task, callback) {
var name = task.name;
order.push(['process', name]);
setTimeout(function() {
order.push(['called', name]);
callback();
}, 100);
}, 5);
q.pause();
_.times(10, function(n) {
q.push({
name: ++n
});
});
setTimeout(q.resume, 100);
setTimeout(function() {
var list = q.workersList();
assert.strictEqual(list.length, 5);
assert.strictEqual(list[0].data.name, 6);
assert.strictEqual(list[1].data.name, 7);
assert.strictEqual(list[2].data.name, 8);
assert.strictEqual(list[3].data.name, 9);
assert.strictEqual(list[4].data.name, 10);
}, 250);
q.drain = function() {
assert.deepStrictEqual(order, [
['process', 1],
['process', 2],
['process', 3],
['process', 4],
['process', 5],
['called', 1],
['process', 6],
['called', 2],
['process', 7],
['called', 3],
['process', 8],
['called', 4],
['process', 9],
['called', 5],
['process', 10],
['called', 6],
['called', 7],
['called', 8],
['called', 9],
['called', 10]
]);
done();
};
});
it('should have a default buffer property that equals 25% of the concurrenct rate', function(done) {
var concurrency = 10;
var worker = function(task, callback) {
assert.ok(false);
async.setImmediate(callback);
};
var queue = async.queue(worker, concurrency);
assert.strictEqual(queue.buffer, 2.5);
setTimeout(done, 50);
});
it('should allow a user to change the buffer property', function(done) {
var concurrency = 10;
var worker = function(task, callback) {
assert.ok(false);
async.setImmediate(callback);
};
var queue = async.queue(worker, concurrency);
queue.buffer = 4;
assert.notStrictEqual(queue.buffer, 2.5);
assert.strictEqual(queue.buffer, 4);
setTimeout(done, 50);
});
it('should execute even if concurrency is infinity', function(done) {
var called = 0;
var queue = async.queue(function(data, callback) {
called++;
callback(null, data);
}, Infinity);
queue.pause();
_.times(10, function(n) {
queue.push(n, function(err, res) {
assert.strictEqual(res, n);
});
});
queue.resume();
setTimeout(function() {
assert.strictEqual(called, 10);
done();
}, 50);
});
it('should throw an error if callback is not function', function() {
var worker = function(task, callback) {
assert.ok(false);
async.setImmediate(callback);
};
var queue = async.queue(worker);
try {
queue.push(1, 2);
} catch(e) {
assert.ok(e);
assert.strictEqual(e.message, 'task callback must be a function');
}
});
it('should throw an error if callback is called twice', function(done) {
var worker = function(task, callback) {
callback(null, task);
callback(null, task);
};
var called = 0;
var queue = async.queue(worker);
domain.create()
.on('error', util.errorChecker)
.run(function() {
queue.push(1, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 1);
assert.strictEqual(++called, 1);
});
});
setTimeout(function() {
assert.strictEqual(called, 1);
done();
}, delay);
});
it('should pass more than 2 arguments', function(done) {
var worker = function(data, callback) {
switch (data) {
case 0:
return callback(null, 1, 2);
case 1:
return callback(null, 2, 3, 4);
case 2:
return callback(null, 3, 4, 5, 6);
}
};
var queue = async.queue(worker);
queue.push(0, function(err, res1, res2, res3, res4) {
if (err) {
return done(err);
}
assert.strictEqual(res1, 1);
assert.strictEqual(res2, 2);
assert.strictEqual(res3, undefined);
assert.strictEqual(res4, undefined);
});
queue.push(1, function(err, res1, res2, res3, res4) {
if (err) {
return done(err);
}
assert.strictEqual(res1, 2);
assert.strictEqual(res2, 3);
assert.strictEqual(res3, 4);
assert.strictEqual(res4, undefined);
});
queue.push(2, function(err, res1, res2, res3, res4) {
if (err) {
return done(err);
}
assert.strictEqual(res1, 3);
assert.strictEqual(res2, 4);
assert.strictEqual(res3, 5);
assert.strictEqual(res4, 6);
});
setTimeout(done, delay);
});
it('should pause in worker with concurrency', function(done) {
var order = [];
var q = async.queue(function(task, callback) {
if (task.isLongRunning) {
q.pause();
setTimeout(function() {
order.push(task.id);
q.resume();
callback();
}, 500);
} else {
order.push(task.id);
callback();
}
}, 10);
q.push({ id: 1, isLongRunning: true });
q.push({ id: 2 });
q.push({ id: 3 });
q.push({ id: 4 });
q.push({ id: 5 });
setTimeout(function() {
assert.deepStrictEqual(order, [1, 2, 3, 4, 5]);
done();
}, 1000);
});
it('should remove', function(done) {
var result = [];
var q = async.queue(function(data, callback) {
result.push(data);
async.setImmediate(callback);
});
q.push([1, 2, 3, 4, 5]);
q.remove(function (node) {
return node.data === 3;
});
q.drain = function() {
assert.deepStrictEqual(result, [1, 2, 4, 5]);
done();
};
});
});
parallel('#priorityQueue', function() {
it('should execute queue by priority sequence', function(done) {
var order = {
callback: [],
process: []
};
var worker = function(task, callback) {
order.process.push(task);
callback('err', 'arg');
};
var queue = async.priorityQueue(worker);
queue.push(1, 1.4, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(queue.length(), 2);
order.callback.push(1);
});
queue.push(2, 0.2, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(queue.length(), 3);
order.callback.push(2);
});
queue.push(3, 3.8, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(queue.length(), 0);
order.callback.push(3);
});
queue.push(4, 2.9, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(queue.length(), 1);
order.callback.push(4);
});
assert.strictEqual(queue.length(), 4);
assert.strictEqual(queue.concurrency, 1);
queue.drain = function() {
assert.deepStrictEqual(order.process, [2, 1, 4, 3]);
assert.deepStrictEqual(order.callback, [2, 1, 4, 3]);
assert.strictEqual(queue.concurrency, 1);
assert.strictEqual(queue.length(), 0);
done();
};
});
it('should execute queue by priority sequence with concurrency', function(done) {
var order = {
callback: [],
process: []
};
var delays = [160, 80, 240, 80];
var worker = function(task, callback) {
setTimeout(function() {
order.process.push(task);
callback('err', 'arg');
}, delays.shift());
};
var called = false;
var concurrency = 2;
var queue = async.priorityQueue(worker, concurrency);
queue.saturated = function() {
called = true;
};
queue.push(1, 1.4, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(queue.length(), 2);
order.callback.push(1);
});
queue.push(2, 0.2, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(queue.length(), 1);
order.callback.push(2);
});
queue.push(3, 3.8, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(queue.length(), 0);
order.callback.push(3);
});
queue.push(4, 2.9, function(err, arg) {
assert.strictEqual(err, 'err');
assert.strictEqual(arg, 'arg');
assert.strictEqual(queue.length(), 0);
order.callback.push(4);
});
assert.strictEqual(queue.length(), 4);
assert.strictEqual(queue.concurrency, 2);
queue.drain = function() {
assert.deepStrictEqual(order.process, [1, 2, 3, 4]);
assert.deepStrictEqual(order.callback, [1, 2, 3, 4]);
assert.strictEqual(queue.concurrency, 2);
assert.strictEqual(queue.length(), 0);
assert.ok(called);
done();
};
});
it('should execute drain immediately if insert task is empty', function(done) {
var order = [];
var worker = function(data, callback) {
order.push(1);
callback();
};
var queue = async.priorityQueue(worker);
queue.drain = function() {
assert.deepStrictEqual(order, []);
done();
};
queue.push();
});
it('should pause in worker with concurrency', function(done) {
var order = [];
var q = async.priorityQueue(function(task, callback) {
if (task.isLongRunning) {
q.pause();
setTimeout(function() {
order.push(task.id);
q.resume();
callback();
}, 500);
} else {
order.push(task.id);
callback();
}
}, 10);
q.push({ id: 1, isLongRunning: true });
q.push({ id: 2 });
q.push({ id: 3 });
q.push({ id: 4 });
q.push({ id: 5 });
setTimeout(function() {
assert.deepStrictEqual(order, [1, 2, 3, 4, 5]);
done();
}, 1000);
});
it('should have a default buffer property that equals 25% of the concurrenct rate', function(done) {
var concurrency = 10;
var worker = function(task, callback) {
assert.ok(false);
async.setImmediate(callback);
};
var queue = async.priorityQueue(worker, concurrency);
assert.strictEqual(queue.buffer, 2.5);
setTimeout(done, 50);
});
it('should allow a user to change the buffer property', function(done) {
var concurrency = 10;
var worker = function(task, callback) {
assert.ok(false);
async.setImmediate(callback);
};
var queue = async.priorityQueue(worker, concurrency);
queue.buffer = 4;
assert.notStrictEqual(queue.buffer, 2.5);
assert.strictEqual(queue.buffer, 4);
setTimeout(done, 50);
});
it('should call the unsaturated callback if tasks length is less than concurrency minus buffer', function(done) {
var order = [];
var concurrency = 10;
var worker = function(task, callback) {
order.push('worker_' + task);
async.setImmediate(callback);
};
var queue = async.priorityQueue(worker, concurrency);
queue.unsaturated = function() {
order.push('unsaturated');
};
queue.empty = function() {
order.push('empty');
};
queue.push('test1', 5, function() { order.push('test1'); });
queue.push('test2', 4, function() { order.push('test2'); });
queue.push('test3', 3, function() { order.push('test3'); });
queue.push('test4', 2, function() { order.push('test4'); });
queue.push('test5', 1, function() { order.push('test5'); });
setTimeout(function() {
assert.deepStrictEqual(order, [
'worker_test5',
'worker_test4',
'worker_test3',
'worker_test2',
'empty',
'worker_test1',
'test5',
'unsaturated',
'test4',
'unsaturated',
'test3',
'unsaturated',
'test2',
'unsaturated',
'test1',
'unsaturated'
]);
done();
}, 50);
});
it('should not be idle when empty is called', function(done) {
var calls = [];
var worker = function(task, cb) {
calls.push('process ' + task);
async.setImmediate(cb);
};
var q = async.queue(worker, 1);
q.empty = function () {
calls.push('empty');
assert(q.idle() === false, 'tasks should be running when empty is called')
assert.strictEqual(q.running(), 1);
};
q.drain = function() {
assert.deepStrictEqual(calls, [
'empty',
'process 1',
]);
done();
};
q.push(1);
});
});
neo-async-2.6.1/test/controlFlow/test.race.js 0000664 0000000 0000000 00000004302 13466145133 0021136 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
parallel('#race', function() {
it('should call each funciton in parallel and callback with first result', function(done) {
var called = 0;
var tasks = _.times(10, function(index) {
return function(next) {
called++;
next(null, index);
};
});
async.race(tasks, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 0);
assert.strictEqual(called, 1);
setImmediate(function() {
assert.strictEqual(called, 10);
done();
});
});
});
it('should callback funciton in parallel with object tasks', function(done) {
var called = 0;
var tasks = _.mapValues(_.times(5, function(index) {
return function(next) {
setTimeout(function() {
called++;
next(null, index);
}, 50 - index * 5);
};
}));
async.race(tasks, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 4);
});
setTimeout(function() {
assert.strictEqual(called, 5);
done();
}, 100);
});
it('should callback with the first error', function(done) {
var tasks = _.times(6, function(index) {
return function(next) {
setTimeout(function() {
next(new Error('error:' + index), index);
}, 50 - index * 5);
};
});
async.race(tasks, function(err, res) {
assert.ok(err);
assert.strictEqual(res, 5);
assert.strictEqual(err.message, 'error:5');
done();
});
});
it('should callback when task is empty', function(done) {
async.race([], function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
done();
});
});
it('should return TypeError if first argument is not an array or an object', function(done) {
async.race(null, function(err, res) {
assert.ok(err);
assert.ok(err instanceof TypeError);
assert.strictEqual(res, undefined);
done();
});
});
});
neo-async-2.6.1/test/controlFlow/test.retry.js 0000664 0000000 0000000 00000017650 13466145133 0021403 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
parallel('#retry', function() {
it('should retry until response', function(done) {
var failed = 3;
var callCount = 0;
var message = 'success';
var fn = function(callback) {
callCount++;
failed--;
if (failed === 0) {
return callback(null, message);
}
callback('err');
};
async.retry(fn, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(callCount, 3);
assert.strictEqual(res, message);
done();
});
});
it('should retry until time out', function(done) {
var times = 3;
var callCount = 0;
var error = 'error';
var success = 'success';
var fn = function(callback) {
callCount++;
callback(error + callCount, success + callCount);
};
async.retry(times, fn, function(err, res) {
assert.strictEqual(callCount, 3);
assert.strictEqual(err, error + times);
assert.strictEqual(res, success + times);
done();
});
});
it('should not require a callback', function(done) {
var times = 3;
var callCount = 0;
var fn = function(callback) {
callCount++;
callback();
};
async.retry(times, fn);
setTimeout(function() {
assert.strictEqual(callCount, 1);
done();
}, delay);
});
it('should execute even if type of times is string', function(done) {
var times = '3';
var callCount = 0;
var fn = function(callback) {
callCount++;
callback();
};
async.retry(times, fn);
setTimeout(function() {
assert.strictEqual(callCount, 1);
done();
}, delay);
});
it('should throw error if arguments are empty', function() {
try {
async.retry();
} catch(e) {
assert.ok(e);
assert.strictEqual(e.message, 'Invalid arguments for async.retry');
}
});
it('should throw error if first argument is not function', function() {
try {
async.retry(1);
} catch(e) {
assert.ok(e);
assert.strictEqual(e.message, 'Invalid arguments for async.retry');
}
});
it('should throw error if arguments are invalid', function() {
try {
async.retry(function() {}, 2, function() {});
} catch(e) {
assert.ok(e);
assert.strictEqual(e.message, 'Invalid arguments for async.retry');
}
});
it('should retry with interval when all attempts succeeds', function(done) {
var times = 3;
var interval = delay * 3;
var callCount = 0;
var error = 'ERROR';
var erroredResult = 'RESULT';
var fn = function(callback) {
callCount++;
callback(error + callCount, erroredResult + callCount);
};
var opts = {
times: times,
interval: interval
};
var start = Date.now();
async.retry(opts, fn, function(err, res) {
var diff = Date.now() - start;
assert(diff >= (interval * (times - 1)));
assert.strictEqual(callCount, 3);
assert.strictEqual(err, error + times);
assert.strictEqual(res, erroredResult + times);
done();
});
});
it('should retry with empty options', function(done) {
var callCount = 0;
var fn = function(callback) {
callCount++;
callback('error');
};
var opts = {};
async.retry(opts, fn, function(err) {
assert.ok(err);
assert.strictEqual(callCount, 5);
done();
});
});
it('should use default times', function(done) {
var called = 0;
async.retry(function(callback) {
called++;
callback('error');
});
setTimeout(function() {
assert.strictEqual(called, 5);
done();
}, delay);
});
it('retry with custom interval when all attempts fail',function(done) {
var times = 3;
var intervalFunc = function(retryCount) {
return retryCount * 110;
};
var callCount = 0;
var error = 'ERROR';
var erroredResult = 'RESULT';
var iterator = function(callback) {
callCount++;
callback(error + callCount, erroredResult + callCount); // respond with indexed values
};
var opts = {
times: times,
interval: intervalFunc
};
var start = Date.now();
async.retry(opts, iterator, function(err, res) {
var now = Date.now();
var diff = now - start;
assert.ok(diff >= 300, diff);
assert.strictEqual(callCount, 3);
assert.strictEqual(err, error + times);
assert.strictEqual(res, erroredResult + times);
done();
});
});
it('should return extra arguments', function(done) {
var func = function(callback) {
callback(null, 1, 2, 3);
};
async.retry(5, func, function(err, arg1, arg2, arg3) {
if (err) {
return done(err);
}
assert.strictEqual(arguments.length, 4);
assert.strictEqual(arg1, 1);
assert.strictEqual(arg2, 2);
assert.strictEqual(arg3, 3);
done();
});
});
it('should return extra arguments with options', function(done) {
var func = function(callback) {
callback(null, 1, 2, 3);
};
var intervalFunc = function(retryCount) {
return retryCount * 110;
};
var opts = {
times: 5,
interval: intervalFunc
};
async.retry(opts, func, function(err, arg1, arg2, arg3) {
if (err) {
return done(err);
}
assert.strictEqual(arguments.length, 4);
assert.strictEqual(arg1, 1);
assert.strictEqual(arg2, 2);
assert.strictEqual(arg3, 3);
done();
});
});
it('should use default interval if interval is invalid string or number', function(done) {
var callCount = 0;
var func = function(callback) {
callback(++callCount % 2, callCount);
};
var opts = {
interval: 'test'
};
async.retry(opts, func, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 2);
assert.strictEqual(callCount, 2);
done();
});
});
it('retry when some attempts fail and error test returns false at some invokation',function(done) {
var callCount = 0;
var error = 'ERROR';
var special = 'SPECIAL_ERROR';
var erroredResult = 'RESULT';
function fn(callback) {
callCount++;
var err = callCount === 2 ? special : error + callCount;
callback(err, erroredResult + callCount);
}
function errorTest(err) {
return err && err === error + callCount; // just a different pattern
}
var options = {
errorFilter: errorTest
};
async.retry(options, fn, function(err, result) {
assert.equal(callCount, 2, 'did not retry the correct number of times');
assert.equal(err, special, 'Incorrect error was returned');
assert.equal(result, erroredResult + 2, 'Incorrect result was returned');
done();
});
});
it('retry with interval when some attempts fail and error test returns false at some invokation',function(done) {
var interval = 50;
var callCount = 0;
var error = 'ERROR';
var erroredResult = 'RESULT';
var special = 'SPECIAL_ERROR';
var specialCount = 3;
function fn(callback) {
callCount++;
var err = callCount === specialCount ? special : error + callCount;
callback(err, erroredResult + callCount);
}
function errorTest(err) {
return err && err !== special;
}
var start = new Date().getTime();
async.retry({ interval: interval, errorFilter: errorTest }, fn, function(err, result){
var now = new Date().getTime();
var duration = now - start;
assert(duration >= (interval * (specialCount - 1)), 'did not include interval');
assert.equal(callCount, specialCount, 'did not retry the correct number of times');
assert.equal(err, special, 'Incorrect error was returned');
assert.equal(result, erroredResult + specialCount, 'Incorrect result was returned');
done();
});
});
});
neo-async-2.6.1/test/controlFlow/test.retryable.js 0000664 0000000 0000000 00000005263 13466145133 0022224 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
parallel('#retryable', function() {
it('should retry', function(done) {
var callCount = 0;
var retryableTask = async.retryable(3, function(arg, callback) {
callCount++;
assert.strictEqual(arg, 42);
callback('fail', callCount);
});
retryableTask(42, function(err, res) {
assert.ok(err);
assert.strictEqual(res, 3);
done();
});
});
it('should work as an embedded task', function(done) {
var retryResult = 'RETRY';
var fooResults;
var retryResults;
async.auto({
dep: async.constant('dep'),
foo: ['dep', function(res, callback) {
fooResults = res;
callback(null, 'FOO');
}],
retry: ['dep', async.retryable(function(res, callback) {
retryResults = res;
callback(null, retryResult);
})]
}, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res.retry, retryResult);
assert.strictEqual(fooResults, retryResults);
done();
});
});
it('should execute even if callback function length is more than 2', function(done) {
async.autoInject({
a: [async.retryable(function(callback) {
callback(null, 'a');
})],
b: ['a', async.retryable(function(a, callback) {
callback(null, 'b');
})],
c: ['a', 'b', async.retryable(function(a, b, callback) {
callback(null, 'c');
})],
d: ['a', 'b', 'c', async.retryable(function(a, b, c, callback) {
callback(null, 'd');
})],
e: ['a', 'b', 'c', 'd', async.retryable(function(a, b, c, d, callback) {
callback(null, 'e');
})],
f: ['a', 'b', 'c', 'd', 'e', async.retryable(function(a, b, c, d, e, callback) {
callback(null, 'f');
})]
}, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {
a: 'a',
b: 'b',
c: 'c',
d: 'd',
e: 'e',
f: 'f'
});
done();
});
});
it('should work as sn embedded task with interval', function(done) {
var start = Date.now();
var opts = {
times: 3,
interval: delay * 3
};
async.auto({
foo: function(callback) {
callback(null, 'FOO');
},
retry: async.retryable(opts, function(callback) {
callback('err');
})
}, function(err) {
assert.ok(err);
var diff = Date.now() - start;
assert(diff > delay * (opts.times - 1));
done();
});
});
});
neo-async-2.6.1/test/controlFlow/test.seq.js 0000664 0000000 0000000 00000005316 13466145133 0021022 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
parallel('#seq', function() {
it('should execute in order of insertion', function(done) {
var add2 = function(n, cb) {
assert.strictEqual(n, 3);
setTimeout(function() {
cb(null, n + 2);
}, 50);
};
var mul3 = function(n, cb) {
assert.strictEqual(n, 5);
setTimeout(function() {
cb(null, n * 3);
}, 15);
};
var add1 = function(n, cb) {
assert.strictEqual(n, 15);
setTimeout(function() {
cb(null, n + 1);
}, 100);
};
var add2mul3add1 = async.seq(add2, mul3, add1);
add2mul3add1(3, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 16);
done();
});
});
it('should execute in order of insertion with binding', function(done) {
var pow2 = function(n, cb) {
var self = this;
assert.strictEqual(n, 3);
setTimeout(function() {
cb(null, self.pow(n, 2));
}, 50);
};
var mul3 = function(n, cb) {
assert.strictEqual(n, 9);
setTimeout(function() {
cb(null, n * 3);
}, 15);
};
var pow3 = function(n, cb) {
var self = this;
assert.strictEqual(n, 27);
setTimeout(function() {
cb(null, self.pow(n, 3));
}, 100);
};
var add2mul3add1 = async.seq(pow2, mul3, pow3);
add2mul3add1.call(Math, 3, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 19683);
done();
});
});
it('should execute without callback', function(done) {
var testcontext = {
name: 'foo'
};
var add2 = function (n, cb) {
assert.strictEqual(this, testcontext);
setTimeout(function () {
cb(null, n + 2);
}, delay * 2);
};
var mul3 = function () {
assert.strictEqual(this, testcontext);
setTimeout(done, delay);
};
var add2mul3 = async.seq(add2, mul3);
add2mul3.call(testcontext, 3);
});
it('should throw error', function(done) {
var add2 = function(n, cb) {
assert.strictEqual(n, 3);
setTimeout(function() {
cb(null, n + 2);
}, 50);
};
var mul3 = function(n, cb) {
assert.strictEqual(n, 5);
setTimeout(function() {
cb(new Error('error'));
}, 15);
};
var add1 = function(n, cb) {
setTimeout(function() {
cb(null, n + 1);
}, 100);
};
var add2mul3add1 = async.seq(add2, mul3, add1);
add2mul3add1(3, function(err) {
assert.ok(err);
done();
});
});
});
neo-async-2.6.1/test/controlFlow/test.series.js 0000664 0000000 0000000 00000012351 13466145133 0021521 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var domain = require('domain');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
var util = require('../util');
function createTasks(order, numbers) {
return _.transform(numbers, function(memo, num, index) {
memo[index] = function(callback) {
var self = this;
setTimeout(function() {
order.push(num);
if (self && self.round) {
num = self.round(num);
}
callback(null, num * 2);
}, num * delay);
};
});
}
parallel('#series', function() {
it('should execute to series by tasks of array', function(done) {
var order = [];
var numbers = [1, 3, 2, 4];
var tasks = createTasks(order, numbers);
tasks.push(function(cb) {
setTimeout(function() {
order.push(5);
cb(null, 5, 5);
}, delay * 5);
});
async.series(tasks, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [2, 6, 4, 8, [5, 5]]);
assert.deepStrictEqual(order, [1, 3, 2, 4, 5]);
done();
});
});
it('should execute to series by tasks of object', function(done) {
var order = [];
var numbers = {
a: 4,
b: 2,
c: 1,
d: 3
};
var tasks = createTasks(order, numbers);
async.series(tasks, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {
a: 8,
b: 4,
c: 2,
d: 6
});
assert.deepStrictEqual(order, [4, 2, 1, 3]);
done();
});
});
it('should execute to series by tasks of array without binding', function(done) {
var order = [];
var numbers = [1.2, 2.4, 1.5, 3.6];
var tasks = createTasks(order, numbers);
async.series(tasks, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [2.4, 4.8, 3, 7.2]);
assert.deepStrictEqual(order, [1.2, 2.4, 1.5, 3.6]);
done();
}, Math);
});
it('should execute to series by tasks of object without binding', function(done) {
var order = [];
var numbers = {
a: 1.2,
b: 2.4,
c: 1.5,
d: 3.6
};
var tasks = createTasks(order, numbers);
async.series(tasks, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {
a: 2.4,
b: 4.8,
c: 3,
d: 7.2
});
assert.deepStrictEqual(order, [1.2, 2.4, 1.5, 3.6]);
done();
}, Math);
});
it('should execute on asynchronous', function(done) {
var sync = true;
var numbers = [1, 3, 2, 4];
var tasks = _.map(numbers, function(n) {
return function(next) {
next(null, n);
};
});
async.series(tasks, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.deepStrictEqual(res, [1, 3, 2, 4]);
done();
});
sync = false;
});
it('should return response immediately if array task is empty', function(done) {
var tasks = [];
async.series(tasks, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, []);
done();
});
});
it('should return response immediately if object task is empty', function(done) {
var tasks = {};
async.series(tasks, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {});
done();
});
});
it('should return response immediately if task is not collection', function(done) {
async.series('test', function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
done();
});
});
it('should throw error', function(done) {
var order = [];
var numbers = [1, 3, 2, 4];
var tasks = createTasks(order, numbers);
var errorTask = function(next) {
next('error');
};
tasks.splice(2, 0, errorTask);
async.series(tasks, function(err) {
assert.ok(err);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 1);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var tasks = [function(next) {
process.nextTick(next);
process.nextTick(next);
}];
async.series(tasks);
});
});
it('should avoid double callback', function(done) {
var called = false;
var tasks = _.times(3, function(n) {
return function(callback) {
try {
callback('error' + n);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
}
done();
}
};
});
async.series(tasks, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
});
neo-async-2.6.1/test/controlFlow/test.timeout.js 0000664 0000000 0000000 00000004317 13466145133 0021720 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
parallel('#timeout', function() {
it('timeout with series', function(done) {
async.series([
async.timeout(function(callback) {
setTimeout(function() {
callback(null, 'I did not time out');
}, delay);
}, delay * 2),
async.timeout(function(callback) {
setTimeout(function() {
callback(null, 'I will time out');
}, delay * 3);
}, delay * 2)
], function(err, res) {
assert.ok(err);
assert.strictEqual(err.code, 'ETIMEDOUT');
assert.strictEqual(err.message, 'Callback function "anonymous" timed out.');
assert.strictEqual(res[0], 'I did not time out');
done();
});
});
it('timeout with parallel', function(done) {
var info = { info: 'info' };
async.parallel([
async.timeout(function(callback) {
setTimeout(function() {
callback(null, 'I did not time out');
}, delay);
}, delay * 2),
async.timeout(function timer(callback) {
setTimeout(function() {
callback(null, 'I will time out');
}, delay * 3);
}, delay * 2, info)
], function(err, res) {
assert.ok(err);
assert.strictEqual(err.code, 'ETIMEDOUT');
assert.strictEqual(err.message, 'Callback function "timer" timed out.');
assert.strictEqual(err.info, info);
assert.strictEqual(res[0], 'I did not time out');
done();
});
});
it('should throw error', function(done) {
async.parallel([
async.timeout(function(callback) {
setTimeout(function() {
callback();
}, delay);
}, delay * 2),
async.timeout(function(callback) {
setTimeout(function() {
callback(null, 2, 2, 2);
}, delay);
}, delay * 2),
async.timeout(function(callback) {
setTimeout(function() {
callback(new Error('error'));
}, delay * 2);
}, delay * 4)
], function(err) {
assert.ok(err);
assert.strictEqual(err.message, 'error');
done();
});
});
});
neo-async-2.6.1/test/controlFlow/test.times.js 0000664 0000000 0000000 00000022346 13466145133 0021355 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var domain = require('domain');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
var util = require('../util');
function timeItrator(order) {
return function(num, callback) {
var self = this;
setTimeout(function() {
order.push(num);
if (self && self.pow) {
num = self.pow(num, 2);
}
callback(null, num);
}, num % 2 === 0 ? delay : 3 * delay);
};
}
parallel('#times', function() {
it('should execute iterator', function(done) {
var n = 3;
var order = [];
async.times(n, timeItrator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [0, 1, 2]);
assert.deepStrictEqual(order, [0, 2, 1]);
done();
});
});
it('should execute iterator even if num is string', function(done) {
var n = '3';
var order = [];
async.times(n, timeItrator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [0, 1, 2]);
assert.deepStrictEqual(order, [0, 2, 1]);
done();
});
});
it('should execute iterator without binding', function(done) {
var n = 3;
var order = [];
async.times(n, timeItrator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [0, 1, 2]);
assert.deepStrictEqual(order, [0, 2, 1]);
done();
}, Math);
});
it('should return response immediately', function(done) {
var n = 0;
var order = [];
async.times(n, timeItrator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should throw error', function(done) {
var n = 4;
var iterator = function(n, next) {
next(n === 2);
};
async.times(n, iterator, function(err) {
assert.ok(err);
setTimeout(done, delay);
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 4);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var iterator = function(num, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.times(4, iterator);
});
});
});
parallel('#timesSeries', function() {
it('should execute iterator', function(done) {
var n = 3;
var order = [];
async.timesSeries(n, timeItrator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [0, 1, 2]);
assert.deepStrictEqual(order, [0, 1, 2]);
done();
});
});
it('should execute iterator even if num is string', function(done) {
var n = '3';
var order = [];
async.timesSeries(n, timeItrator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [0, 1, 2]);
assert.deepStrictEqual(order, [0, 1, 2]);
done();
});
});
it('should execute iterator without binding', function(done) {
var n = 3;
var order = [];
async.timesSeries(n, timeItrator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [0, 1, 2]);
assert.deepStrictEqual(order, [0, 1, 2]);
done();
}, Math);
});
it('should execute on asynchronous', function(done) {
var sync = true;
var n = 3;
var iterator = function(n, callback) {
callback(null, n);
};
async.timesSeries(n, iterator, function(err, result) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.deepStrictEqual(result, [0, 1, 2]);
done();
});
sync = false;
});
it('should return response immediately', function(done) {
var n = 0;
var order = [];
async.timesSeries(n, timeItrator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should throw error', function(done) {
var n = 4;
var iterator = function(n, next) {
next(n === 2);
};
async.timesSeries(n, iterator, function(err) {
assert.ok(err);
done();
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 4);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var iterator = function(num, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.timesSeries(4, iterator);
});
});
});
parallel('#timesLimit', function() {
it('should execute iterator', function(done) {
var n = 5;
var order = [];
async.timesLimit(n, 2, timeItrator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [0, 1, 2, 3, 4]);
assert.deepStrictEqual(order, [0, 2, 1, 4, 3]);
done();
});
});
it('should execute iterator even if num is string', function(done) {
var n = '5';
var order = [];
async.timesLimit(n, 2, timeItrator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [0, 1, 2, 3, 4]);
assert.deepStrictEqual(order, [0, 2, 1, 4, 3]);
done();
});
});
it('should execute iterator without binding', function(done) {
var n = 7;
var order = [];
async.timesLimit(n, 2, timeItrator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [0, 1, 2, 3, 4, 5, 6]);
assert.deepStrictEqual(order, [0, 2, 1, 4, 3, 6, 5]);
done();
}, Math);
});
it('should execute like parallel if limit is Infinity', function(done) {
var n = 5;
var order = [];
var iterator = function(n, done) {
setTimeout(function() {
order.push(n);
done(null, n);
}, n * 30);
};
async.timesLimit(n, Infinity, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, [0, 1, 2, 3, 4]);
assert.deepStrictEqual(order, [0, 1, 2, 3, 4]);
done();
});
});
it('should return response immediately', function(done) {
var n = 0;
var order = [];
async.timesLimit(n, 2, timeItrator(order), function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(Object.prototype.toString.call(res), '[object Array]');
assert.deepStrictEqual(res, []);
assert.deepStrictEqual(order, []);
done();
});
});
it('should execute on asynchronous', function(done) {
var sync = true;
var n = 5;
var iterator = function(n, callback) {
callback(null, n);
};
async.timesLimit(n, 2, iterator, function(err, result) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.deepStrictEqual(result, [0, 1, 2, 3, 4]);
done();
});
sync = false;
});
it('should throw error', function(done) {
var n = 6;
var iterator = function(n, next) {
next(n === 4);
};
async.timesLimit(n, 3, iterator, function(err) {
assert.ok(err);
setTimeout(done, delay);
});
});
it('should throw error if double callback', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 4);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var iterator = function(num, callback) {
process.nextTick(callback);
process.nextTick(callback);
};
async.timesLimit(4, 2, iterator);
});
});
});
neo-async-2.6.1/test/controlFlow/test.tryEach.js 0000664 0000000 0000000 00000004657 13466145133 0021640 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
parallel('#tryEach', function() {
it('should execute', function(done) {
var result = 'test';
async.tryEach([
function(callback) {
callback(null, result);
}
], function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, result);
done();
});
});
it('should execute with object', function(done) {
var result = 'test';
async.tryEach({
task1: function(callback) {
callback(null, result);
},
task2: function() {
assert(false);
}
}, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, result);
done();
});
});
it('should return multiple arguments', function(done) {
var results = ['arg1', 'arg2'];
async.tryEach([
function(callback) {
callback(null, results[0], results[1]);
}
], function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, results);
done();
});
});
it('should execute second task if first task is failed', function(done) {
async.tryEach([
function(callback) {
callback(new Error('failed'), 'task1');
},
function(callback) {
callback(null, 'task2');
}
], function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 'task2');
done();
});
});
it('should return an error if all tasks are failed', function(done) {
async.tryEach([
function(callback) {
callback(new Error('failed1'), 'task1');
},
function(callback) {
callback(new Error('failed2'), 'task2');
}
], function(err) {
assert.ok(err);
assert.strictEqual(err.message, 'failed2');
done();
});
});
it('should not cause any error if task is empty', function(done) {
async.tryEach([], function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
done();
});
});
it('should not cause any error if task is string', function(done) {
async.tryEach('test', function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
done();
});
});
});
neo-async-2.6.1/test/controlFlow/test.until.js 0000664 0000000 0000000 00000016604 13466145133 0021367 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
parallel('#until', function() {
it('should execute until test is true', function(done) {
var count = 0;
var limit = 5;
var order = {
test: [],
iterator: []
};
var test = function() {
order.test.push(count);
return count === limit;
};
var iterator = function(callback) {
order.iterator.push(count++);
callback(null, count);
};
async.until(test, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order.iterator, [0, 1, 2, 3, 4]);
assert.deepStrictEqual(order.test, [0, 1, 2, 3, 4, 5]);
assert.strictEqual(res, 5);
done();
});
});
it('should execute without binding until test is false', function(done) {
var count = 0;
var limit = 5;
var order = {
test: [],
iterator: []
};
var result = [];
var test = function() {
order.test.push(count);
return count === limit;
};
var iterator = function(callback) {
assert.strictEqual(this, undefined);
result.push(count * count);
order.iterator.push(count++);
callback(null, count);
};
async.until(test, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order.iterator, [0, 1, 2, 3, 4]);
assert.deepStrictEqual(order.test, [0, 1, 2, 3, 4, 5]);
assert.deepStrictEqual(result, [0, 1, 4, 9, 16]);
assert.strictEqual(res, 5);
done();
}, Math);
});
it('should execute on asynchronous', function(done) {
var sync = true;
var count = 0;
var limit = 5;
var test = function() {
return count === limit;
};
var iterator = function(callback) {
count++;
callback();
};
async.until(test, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
done();
});
sync = false;
});
it('should execute callback immediately if first test is truthy', function(done) {
var test = function() {
return true;
};
var iterator = function(callback) {
callback();
};
async.until(test, iterator, done);
});
it('should get multiple result', function(done) {
var count = 0;
var limit = 5;
var test = function() {
assert.strictEqual(arguments.length, count);
return count === limit;
};
var iterator = function(callback) {
callback.apply(null, [null].concat(_.range(++count)));
};
async.until(test, iterator, function(err, res1, res2, res3, res4) {
if (err) {
return done(err);
}
assert.strictEqual(count, 5);
assert.strictEqual(arguments.length, 6);
assert.strictEqual(res1, 0);
assert.strictEqual(res2, 1);
assert.strictEqual(res3, 2);
assert.strictEqual(res4, 3);
done();
});
});
it('should throw error', function(done) {
var count = 0;
var limit = 5;
var order = {
test: [],
iterator: []
};
var test = function() {
order.test.push(count);
return count === limit;
};
var iterator = function(callback) {
order.iterator.push(count++);
callback(count === 3);
};
async.until(test, iterator, function(err) {
assert.ok(err);
assert.deepStrictEqual(order.iterator, [0, 1, 2]);
assert.deepStrictEqual(order.test, [0, 1, 2]);
done();
});
});
});
parallel('#doUntil', function() {
it('should execute until test is false', function(done) {
var count = 0;
var limit = 5;
var order = {
test: [],
iterator: []
};
var test = function() {
order.test.push(count);
return count === limit;
};
var iterator = function(callback) {
order.iterator.push(count++);
callback(null, count);
};
async.doUntil(iterator, test, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order.iterator, [0, 1, 2, 3, 4]);
assert.deepStrictEqual(order.test, [1, 2, 3, 4, 5]);
assert.strictEqual(res, 5);
done();
});
});
it('should execute without binding until test is false', function(done) {
var count = 0;
var limit = 5;
var order = {
test: [],
iterator: []
};
var result = [];
var test = function() {
order.test.push(count);
return count === limit;
};
var iterator = function(callback) {
assert.strictEqual(this, undefined);
result.push(count * count);
order.iterator.push(count++);
callback(null, count);
};
async.doUntil(iterator, test, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order.iterator, [0, 1, 2, 3, 4]);
assert.deepStrictEqual(order.test, [1, 2, 3, 4, 5]);
assert.deepStrictEqual(result, [0, 1, 4, 9, 16]);
assert.strictEqual(res, 5);
done();
}, Math);
});
it('should execute until test is false and apply params', function(done) {
var count = 0;
var limit = 5;
var order = {
test: [],
iterator: []
};
var test = function(c) {
order.test.push(c);
return c < limit;
};
var iterator = function(callback) {
order.iterator.push(count++);
callback(null, count);
};
async.doWhilst(iterator, test, function(err) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order.iterator, [0, 1, 2, 3, 4]);
assert.deepStrictEqual(order.test, [1, 2, 3, 4, 5]);
done();
});
});
it('should execute on asynchronous', function(done) {
var sync = true;
var count = 0;
var limit = 5;
var test = function() {
return count === limit;
};
var iterator = function(callback) {
count++;
callback();
};
async.doUntil(iterator, test, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
done();
});
sync = false;
});
it('should get multiple result', function(done) {
var count = 0;
var limit = 5;
var test = function(arg) {
assert.strictEqual(arg, 0);
assert.strictEqual(arguments.length, count);
return count === limit;
};
var iterator = function(callback) {
callback.apply(null, [null].concat(_.range(++count)));
};
async.doUntil(iterator, test, function(err, res1, res2, res3, res4) {
if (err) {
return done(err);
}
assert.strictEqual(count, 5);
assert.strictEqual(arguments.length, 6);
assert.strictEqual(res1, 0);
assert.strictEqual(res2, 1);
assert.strictEqual(res3, 2);
assert.strictEqual(res4, 3);
done();
});
});
it('should throw error', function(done) {
var count = 0;
var limit = 5;
var order = {
test: [],
iterator: []
};
var test = function() {
order.test.push(count);
return count === limit;
};
var iterator = function(callback) {
order.iterator.push(count++);
callback(count === 3);
};
async.doUntil(iterator, test, function(err) {
assert.ok(err);
assert.deepStrictEqual(order.iterator, [0, 1, 2]);
assert.deepStrictEqual(order.test, [1, 2]);
done();
});
});
});
neo-async-2.6.1/test/controlFlow/test.waterfall.js 0000664 0000000 0000000 00000014160 13466145133 0022210 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var domain = require('domain');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
var util = require('../util');
function createTasks(type, numbers) {
switch (type) {
case 'simple':
return createSimpleTasks();
case 'complex':
return createComplexTasks();
}
function createSimpleTasks() {
var first = true;
var tasks = _.transform(numbers, function(memo, num, key) {
if (first) {
first = false;
memo[key] = function(done) {
if (this === Math) {
num *= 2;
}
done(null, num);
};
} else {
memo[key] = function(sum, done) {
if (this === Math) {
num *= 2;
}
done(null, sum + num);
};
}
});
return tasks;
}
function createComplexTasks() {
var count = 0;
var tasks = _.transform(numbers, function(memo, num, key) {
if (count++ === 0) {
memo[key] = function(done) {
if (this === Math) {
num *= 2;
}
done(null, num);
};
} else {
memo[key] = function() {
if (this === Math) {
num *= 2;
}
var args = _.toArray(arguments);
var done = args.pop();
args.unshift(null);
args.push(num);
done.apply(null, args);
};
}
});
return tasks;
}
}
parallel('#waterfall', function() {
it('should execute to waterfall by collection of array', function(done) {
var numbers = [1, 3, 2, 4];
var tasks = createTasks('simple', numbers);
async.waterfall(tasks, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, 10);
done();
});
});
it('should execute simple tasks', function(done) {
var numbers = [1, 3, 2, 4, 7, 8, 6, 5];
var tasks = createTasks('simple', numbers);
async.waterfall(tasks, function(err, result) {
if (err) {
return done(err);
}
assert.strictEqual(result, 36);
done();
});
});
it('should execute complex tasks', function(done) {
var numbers = [1, 3, 2, 4, 7, 8, 6, 5];
var tasks = createTasks('complex', numbers);
async.waterfall(tasks, function(err, a, b, c, d, e, f, g, h) {
if (err) {
return done(err);
}
assert.strictEqual(a, 1);
assert.strictEqual(b, 3);
assert.strictEqual(c, 2);
assert.strictEqual(d, 4);
assert.strictEqual(e, 7);
assert.strictEqual(f, 8);
assert.strictEqual(g, 6);
assert.strictEqual(h, 5);
done();
});
});
it('should throw error', function(done) {
var numbers = [1, 3, 2, 4];
var tasks = createTasks('simple', numbers);
var errorTask = function(res, next) {
next('error');
};
tasks.splice(2, 0, errorTask);
async.waterfall(tasks, function(err) {
assert.ok(err);
done();
});
});
it('should throw error if callback is called twice', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 1);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
var array = [
function(next) {
setImmediate(function() {
next(null, 'one', 'two');
});
setImmediate(function() {
next(null, 'one', 'two');
});
},
function(arg1, arg2, next) {
next(null, arg1, arg2, 'three');
},
function(arg1, arg2, arg3, next) {
next(null, 'four');
},
function(arg1, next) {
next();
}
];
async.waterfall(array);
});
});
it('should throw error if task is not collection', function(done) {
async.waterfall(null, function(err) {
assert.strictEqual(err.message, 'First argument to waterfall must be an array of functions');
done();
});
});
it('should throw error with binding', function(done) {
var numbers = [1, 3, 2, 4];
var tasks = createTasks('simple', numbers);
var errorTask = function(res, next) {
next('error');
};
tasks.splice(2, 0, errorTask);
async.waterfall(tasks, function(err) {
assert.ok(err);
done();
}, Math);
});
it('should avoid double callback', function(done) {
var called = false;
var tasks = _.times(3, function(n) {
return function(callback) {
try {
callback('error' + n);
} catch (exception) {
try {
callback(exception);
} catch(e) {
assert.ok(e);
util.errorChecker(e);
}
done();
}
};
});
async.waterfall(tasks, function(err) {
assert.ok(err);
assert.strictEqual(called, false);
called = true;
async.nothing();
});
});
it('should return response immediately if array task is empty', function(done) {
var tasks = [];
async.waterfall(tasks, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, undefined);
done();
});
});
it('multiple callback calls (trickier) @nodeonly', function(done) {
var errorCallCount = 0;
setTimeout(function() {
assert.strictEqual(errorCallCount, 1);
done();
}, delay);
domain.create()
.on('error', util.errorChecker)
.on('error', function() {
errorCallCount++;
})
.run(function() {
async.waterfall([
function(callback) {
setTimeout(callback, 0, null, 'one', 'two');
setTimeout(callback, 10, null, 'one', 'two');
},
function(arg1, arg2, callback) {
setTimeout(callback, 15, null, arg1, arg2, 'three');
}
], function () {
throw new Error('should not get here');
});
});
});
});
neo-async-2.6.1/test/controlFlow/test.whilst.js 0000664 0000000 0000000 00000021034 13466145133 0021537 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var delay = require('../config').delay;
parallel('#whilst', function() {
it('should execute until test is false', function(done) {
var count = 0;
var limit = 5;
var order = {
test: [],
iterator: []
};
var test = function() {
order.test.push(count);
return count < limit;
};
var iterator = function(callback) {
order.iterator.push(count++);
callback(null, count);
};
async.whilst(test, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order.iterator, [0, 1, 2, 3, 4]);
assert.deepStrictEqual(order.test, [0, 1, 2, 3, 4, 5]);
assert.strictEqual(res, 5);
done();
});
});
it('should execute without binding until test is false', function(done) {
var count = 0;
var limit = 5;
var order = {
test: [],
iterator: []
};
var result = [];
var test = function() {
order.test.push(count);
return count < limit;
};
var iterator = function(callback) {
assert.strictEqual(this, undefined);
result.push(count * count);
order.iterator.push(count++);
callback(null, count);
};
async.whilst(test, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order.iterator, [0, 1, 2, 3, 4]);
assert.deepStrictEqual(order.test, [0, 1, 2, 3, 4, 5]);
assert.deepStrictEqual(result, [0, 1, 4, 9, 16]);
assert.strictEqual(res, 5);
done();
}, Math);
});
it('should execute on asynchronous', function(done) {
var sync = true;
var count = 0;
var limit = 5;
var test = function() {
return count < limit;
};
var iterator = function(callback) {
count++;
callback(null, count);
};
async.whilst(test, iterator, function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
assert.strictEqual(res, 5);
done();
});
sync = false;
});
it('should execute callback immediately if first test is falsy', function(done) {
var test = function() {
return false;
};
var iterator = function(callback) {
callback();
};
async.whilst(test, iterator, done);
});
it('should get multiple result', function(done) {
var count = 0;
var limit = 5;
var test = function() {
assert.strictEqual(arguments.length, count);
return count < limit;
};
var iterator = function(callback) {
callback.apply(null, [null].concat(_.range(++count)));
};
async.whilst(test, iterator, function(err, res1, res2, res3, res4) {
if (err) {
return done(err);
}
assert.strictEqual(count, 5);
assert.strictEqual(arguments.length, 6);
assert.strictEqual(res1, 0);
assert.strictEqual(res2, 1);
assert.strictEqual(res3, 2);
assert.strictEqual(res4, 3);
done();
});
});
it('should execute without callback', function(done) {
var count = 0;
var limit = 5;
var test = function() {
return count < limit;
};
var iterator = function(callback) {
count++;
callback();
};
async.whilst(test, iterator);
setTimeout(function() {
assert.strictEqual(count, 5);
done();
}, delay);
});
it('should throw error', function(done) {
var count = 0;
var limit = 5;
var order = {
test: [],
iterator: []
};
var result = [];
var test = function() {
order.test.push(count);
return count < limit;
};
var iterator = function(callback) {
assert.strictEqual(this, undefined);
result.push(count * count);
order.iterator.push(count++);
callback(count === 3);
};
async.whilst(test, iterator, function(err) {
assert.ok(err);
assert.deepStrictEqual(order.iterator, [0, 1, 2]);
assert.deepStrictEqual(order.test, [0, 1, 2]);
assert.deepStrictEqual(result, [0, 1, 4]);
done();
}, Math);
});
});
parallel('#doWhilst', function() {
it('should execute until test is false', function(done) {
var count = 0;
var limit = 5;
var order = {
test: [],
iterator: []
};
var test = function() {
order.test.push(count);
return count < limit;
};
var iterator = function(callback) {
order.iterator.push(count++);
callback(null, count);
};
async.doWhilst(iterator, test, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order.iterator, [0, 1, 2, 3, 4]);
assert.deepStrictEqual(order.test, [1, 2, 3, 4, 5]);
assert.strictEqual(res, 5);
done();
});
});
it('should execute without binding until test is false', function(done) {
var count = 0;
var limit = 5;
var order = {
test: [],
iterator: []
};
var result = [];
var test = function() {
order.test.push(count);
return count < limit;
};
var iterator = function(callback) {
assert.strictEqual(this, undefined);
result.push(count * count);
order.iterator.push(count++);
callback(null, count);
};
async.doWhilst(iterator, test, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order.iterator, [0, 1, 2, 3, 4]);
assert.deepStrictEqual(order.test, [1, 2, 3, 4, 5]);
assert.deepStrictEqual(result, [0, 1, 4, 9, 16]);
assert.strictEqual(res, 5);
done();
}, Math);
});
it('should execute until test is false and apply params', function(done) {
var count = 0;
var limit = 5;
var order = {
test: [],
iterator: []
};
var test = function(c) {
order.test.push(c);
return c < limit;
};
var iterator = function(callback) {
order.iterator.push(count++);
callback(null, count);
};
async.doWhilst(iterator, test, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(order.iterator, [0, 1, 2, 3, 4]);
assert.deepStrictEqual(order.test, [1, 2, 3, 4, 5]);
assert.strictEqual(res, 5);
done();
});
});
it('should execute on asynchronous', function(done) {
var sync = true;
var count = 0;
var limit = 5;
var test = function() {
return count < limit;
};
var iterator = function(callback) {
count++;
callback();
};
async.doWhilst(iterator, test, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
done();
});
sync = false;
});
it('should get multiple result', function(done) {
var count = 0;
var limit = 5;
var test = function(arg) {
assert.strictEqual(arg, 0);
assert.strictEqual(arguments.length, count);
return count < limit;
};
var iterator = function(callback) {
callback.apply(null, [null].concat(_.range(++count)));
};
async.doWhilst(iterator, test, function(err, res1, res2, res3, res4) {
if (err) {
return done(err);
}
assert.strictEqual(count, 5);
assert.strictEqual(arguments.length, 6);
assert.strictEqual(res1, 0);
assert.strictEqual(res2, 1);
assert.strictEqual(res3, 2);
assert.strictEqual(res4, 3);
done();
});
});
it('should execute without callback', function(done) {
var count = 0;
var limit = 5;
var test = function() {
return count < limit;
};
var iterator = function(callback) {
count++;
callback();
};
async.doWhilst(iterator, test);
setTimeout(function() {
assert.strictEqual(count, 5);
done();
}, delay);
});
it('should throw error', function(done) {
var count = 0;
var limit = 5;
var order = {
test: [],
iterator: []
};
var result = [];
var test = function() {
order.test.push(count);
return count < limit;
};
var iterator = function(callback) {
assert.strictEqual(this, undefined);
result.push(count * count);
order.iterator.push(count++);
callback(count === 3);
};
async.doWhilst(iterator, test, function(err) {
assert.ok(err);
assert.deepStrictEqual(order.iterator, [0, 1, 2]);
assert.deepStrictEqual(order.test, [1, 2]);
assert.deepStrictEqual(result, [0, 1, 4]);
done();
}, Math);
});
});
neo-async-2.6.1/test/mocha.opts 0000664 0000000 0000000 00000000050 13466145133 0016372 0 ustar 00root root 0000000 0000000 --ui bdd
--reporter spec
--timeout 5000
neo-async-2.6.1/test/other/ 0000775 0000000 0000000 00000000000 13466145133 0015522 5 ustar 00root root 0000000 0000000 neo-async-2.6.1/test/other/test.alias.js 0000664 0000000 0000000 00000004347 13466145133 0020137 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var parallel = require('mocha.parallel');
var async = require('../../');
parallel('#alias', function() {
it('should have alias of forEach', function(done) {
assert.strictEqual(async.forEach, async.each);
done();
});
it('should have alias of forEachSeries', function(done) {
assert.strictEqual(async.forEachSeries, async.eachSeries);
done();
});
it('should have alias of forEachLimit', function(done) {
assert.strictEqual(async.forEachLimit, async.eachLimit);
done();
});
it('should have alias of eachOf', function(done) {
assert.strictEqual(async.eachOf, async.each);
done();
});
it('should have alias of eachOfSeries', function(done) {
assert.strictEqual(async.eachOfSeries, async.eachSeries);
done();
});
it('should have alias of eachLimit', function(done) {
assert.strictEqual(async.eachOfLimit, async.eachLimit);
done();
});
it('should have alias of forEachOf', function(done) {
assert.strictEqual(async.forEachOf, async.each);
done();
});
it('should have alias of forEachOfSeries', function(done) {
assert.strictEqual(async.forEachOfSeries, async.eachSeries);
done();
});
it('should have alias of forEachOfLimit', function(done) {
assert.strictEqual(async.forEachOfLimit, async.eachLimit);
done();
});
it('should have alias of inject', function(done) {
assert.strictEqual(async.inject, async.reduce);
done();
});
it('should have alias of foldl', function(done) {
assert.strictEqual(async.foldl, async.reduce);
done();
});
it('should have alias of foldr', function(done) {
assert.strictEqual(async.foldr, async.reduceRight);
done();
});
it('should have alias of any', function(done) {
assert.strictEqual(async.any, async.some);
done();
});
it('should have alias of all', function(done) {
assert.strictEqual(async.all, async.every);
done();
});
it('should have alias of angelfall', function(done) {
assert.strictEqual(async.angelfall, async.angelFall);
done();
});
it('should have alias of wrapSync', function(done) {
assert.strictEqual(async.wrapSync, async.asyncify);
done();
});
});
neo-async-2.6.1/test/other/test.other.js 0000664 0000000 0000000 00000015135 13466145133 0020164 0 ustar 00root root 0000000 0000000 /* global it, before, after */
var fs = require('fs');
var vm = require('vm');
var path = require('path');
var assert = require('assert');
var _ = require('lodash');
var parallel = require('mocha.parallel');
var async = global.async || require('../../');
var asyncPath = global.async_path || path.resolve(__dirname, '../../lib/async.js');
parallel('#nextTick', function() {
'use strict';
it('should assign setImmediate when process does not exist', function(done) {
var context = {
require: require,
console: console,
exports: exports,
setTimeout: setTimeout,
setImmediate: setImmediate
};
vm.runInNewContext(fs.readFileSync(asyncPath), context);
assert.strictEqual(typeof context.async.nextTick, 'function');
assert.notStrictEqual(context.async.nextTick, process.nextTick);
assert.strictEqual(context.async.nextTick, setImmediate);
context.async.nextTick(done);
});
it('should assign setImmediate when process does not exist for coverage', function(done) {
var _nextTick = process.nextTick;
process.nextTick = undefined;
delete(require.cache[asyncPath]);
var async = require(asyncPath);
process.nextTick = _nextTick;
assert.strictEqual(typeof async.nextTick, 'function');
assert.notStrictEqual(async.nextTick, process.nextTick);
assert.strictEqual(async.nextTick, setImmediate);
async.nextTick(done);
});
it('should create original nextTick when process does not have nextTick and setImmediate', function(done) {
var context = {
require: require,
console: console,
exports: exports,
setTimeout: setTimeout
};
vm.runInNewContext(fs.readFileSync(asyncPath), context);
assert.strictEqual(typeof context.async.nextTick, 'function');
assert.notStrictEqual(context.async.nextTick, process.nextTick);
context.async.nextTick(done);
});
it('should create original nextTick when process does not have nextTick and setImmediate for coverage', function(done) {
var _nextTick = process.nextTick;
var _setImmediate = setImmediate;
process.nextTick = undefined;
setImmediate = undefined;
delete(require.cache[asyncPath]);
var async = require(asyncPath);
process.nextTick = _nextTick;
setImmediate = _setImmediate;
assert.strictEqual(typeof async.nextTick, 'function');
assert.notStrictEqual(async.nextTick, process.nextTick);
async.nextTick(done);
});
it('should avoid node warning [v0.10.x only]', function(done) {
var array = _.times(10000);
var iterator = function(n, done) {
done();
};
async.eachSeries(array, iterator, done);
});
it('should pass extra arguments', function(done) {
async.nextTick(function(a, b, c, d) {
assert.strictEqual(a, 1);
assert.strictEqual(b, 2);
assert.strictEqual(c, 3);
assert.strictEqual(d, undefined);
done();
}, 1, 2, 3);
});
});
parallel('#setImmediate', function() {
'use strict';
it('should create original setImmediate if does not have setImmediate', function(done) {
var context = {
require: require,
console: console,
exports: exports,
setTimeout: setTimeout
};
vm.runInNewContext(fs.readFileSync(asyncPath), context);
assert.strictEqual(typeof context.async.nextTick, 'function');
assert.notStrictEqual(context.async.nextTick, process.nextTick);
context.async.nextTick(done);
});
it('should create original setImmediate if does not have setImmediate for coverage', function(done) {
var _setImmediate = setImmediate;
setImmediate = undefined;
delete(require.cache[asyncPath]);
var async = require(asyncPath);
setImmediate = _setImmediate;
assert.strictEqual(typeof async.setImmediate, 'function');
assert.notStrictEqual(async.setImmediate, process.nextTick);
async.nextTick(done);
});
it('should pass extra arguments', function(done) {
var _setImmediate = setImmediate;
setImmediate = undefined;
delete(require.cache[asyncPath]);
var async = require(asyncPath);
setImmediate = _setImmediate;
async.setImmediate(function(a, b, c, d) {
assert.strictEqual(a, 1);
assert.strictEqual(b, 2);
assert.strictEqual(c, 3);
assert.strictEqual(d, undefined);
done();
}, 1, 2, 3);
});
});
parallel('#check functions', function() {
'use strict';
it('should have async functions', function() {
_.forOwn(require('async'), function(func, key) {
assert.ok(async[key], key + ' wasn\'t found.');
});
});
});
parallel('#other', function() {
'use strict';
var path = require('path');
it('should check whether "async" is assigned to context', function() {
var context = {
require: require,
console: console,
exports: exports
};
vm.runInNewContext(fs.readFileSync(path.resolve(__dirname, '../../lib/async.js')), context);
assert.ok(context.async);
_.forOwn(context.async, function(func, key) {
assert.ok(async[key]);
});
});
it('should check whether "neo_async" is assigned to context', function() {
var context = {
require: require,
console: console,
exports: exports,
async: require('async')
};
vm.runInNewContext(fs.readFileSync(path.resolve(__dirname, '../../lib/async.js')), context);
assert.ok(context.neo_async);
_.forOwn(context.neo_async, function(func, key) {
assert.ok(async[key]);
});
});
});
parallel('#default', function() {
'use strict';
it('should have same functions', function() {
_.forOwn(async['default'], function(value, key) {
assert.ok(async[key], key + ' wasn\'t found.');
});
});
});
parallel('#safe', function() {
'use strict';
it('should execute on asynchronous', function(done) {
async.safe();
var sync = true;
var collection = [1, 3, 2];
var iterator = function(value, key, callback) {
// sync call
callback();
};
async.eachSeries(collection, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
done();
});
sync = false;
});
});
parallel('#fast', function() {
'use strict';
before(function() {
async.fast();
});
after(function() {
async.safe();
});
it('should execute on synchronous', function(done) {
var sync = true;
var collection = [1, 3, 2];
var iterator = function(value, key, callback) {
// sync call
callback();
};
async.eachSeries(collection, iterator, function(err) {
if (err) {
return done(err);
}
assert.strictEqual(sync, true);
done();
});
sync = false;
});
});
neo-async-2.6.1/test/util.js 0000664 0000000 0000000 00000004520 13466145133 0015715 0 ustar 00root root 0000000 0000000 /* global it, Map, Set, Promise */
'use strict';
var assert = require('assert');
var _it = typeof Symbol === 'function' ? it : it.skip;
_it.only =
_it.only ||
function skipOnly(key) {
it.only(key);
};
exports.it = _it;
/**
* for v0.10.x
*/
exports.Map =
typeof Map === 'function'
? Map
: (function() {
function Map(arr) {
this._data = arr || [];
}
Map.prototype.set = function(key, value) {
this._data.push([key, value]);
};
Map.prototype[global.Symbol.iterator] = function() {
var self = this;
return {
next: function() {
var data = self._data.shift();
return {
value: data,
done: data === undefined
};
}
};
};
Object.defineProperty(Map.prototype, 'size', {
get: function() {
return this._data.length;
}
});
return Map;
})();
exports.Set =
typeof Set === 'function'
? Set
: (function() {
function Set(arr) {
this._data = arr || [];
}
Set.prototype.add = function(value) {
this._data.push(value);
};
Set.prototype[global.Symbol.iterator] = function() {
var self = this;
return {
next: function() {
var data = self._data.shift();
return {
value: data,
done: data === undefined
};
}
};
};
Object.defineProperty(Set.prototype, 'size', {
get: function() {
return this._data.length;
}
});
return Set;
})();
exports.errorChecker = function(err) {
assert.ok(err);
assert.strictEqual(err.message, 'Callback was already called.');
};
exports.uncaughtExceptionHandler = function(func) {
var handler = function(err) {
func(err);
process.removeListener('uncaughtException', handler);
};
process.removeAllListeners('uncaughtException');
process.domain = null;
process.on('uncaughtException', handler);
};
exports.Promise = typeof Promise !== 'undefined' ? Promise : require('bluebird');
exports.makeGenerator = function*(arr) {
var idx = 0;
var len = arr.length;
while (idx < len) {
yield arr[idx++];
}
};
neo-async-2.6.1/test/utils/ 0000775 0000000 0000000 00000000000 13466145133 0015541 5 ustar 00root root 0000000 0000000 neo-async-2.6.1/test/utils/test.asyncify.js 0000664 0000000 0000000 00000007027 13466145133 0020710 0 ustar 00root root 0000000 0000000 /* global it, describe */
'use strict';
var assert = require('assert');
var async = require('../../');
var delay = require('../config').delay;
var util = require('../util');
describe('#asyncify', function() {
it('should call a synchronous function asynchronously', function(done) {
var test = {
hoge: true
};
var func = function() {
return test;
};
async.asyncify(func)(function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, test);
done();
});
});
it('should call a synchronous function which has a promise as a result', function(done) {
var test = {
hoge: true
};
var func = function() {
return util.Promise.resolve(test);
};
async.asyncify(func)(function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, test);
done();
});
});
it('should throw error', function(done) {
var message = 'error';
var func = function() {
throw new Error(message);
};
async.asyncify(func)(function(err) {
assert.ok(err);
assert.strictEqual(err.message, message);
done();
});
});
it('should throw error by promise', function(done) {
var message = 'error';
var func = function() {
return util.Promise.reject(new Error(message));
};
async.asyncify(func)(function(err) {
assert.ok(err);
assert.strictEqual(err.message, message);
done();
});
});
it('should throw an uncaughtException instead of unhandledRejection', function(done) {
var error = new Error('callback error');
util.uncaughtExceptionHandler(function(err) {
assert.ok(err);
assert.strictEqual(err, error);
done();
});
var func = function() {
return util.Promise.reject(new Error('error'));
};
async.asyncify(func)(function(err) {
assert.ok(err);
throw error;
});
});
it('should avoid TypeError if return object is null', function(done) {
var func = function() {
return null;
};
async.asyncify(func)(function(err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res, null);
done();
});
});
it('should throw an error if reject is called', function(done) {
var func = function(arg) {
return util.Promise.reject(arg + ' rejected');
};
async.asyncify(func)('argument', function(err) {
assert.ok(err);
assert.strictEqual(err.message, 'argument rejected');
done();
});
});
it('should throw an error even if reject is called with null', function(done) {
var func = function() {
return util.Promise.reject(null);
};
async.asyncify(func)(function(err) {
assert.ok(err);
assert.ok(err instanceof Error);
assert.strictEqual(err.message, 'null');
done();
});
});
it('should avoid double callback', function(done) {
var count = 0;
var msg = 'error in callback';
util.uncaughtExceptionHandler(function(err) {
assert.ok(err);
assert.strictEqual(err.message, msg);
});
var promisified = function(arg) {
return new util.Promise(function(resolve) {
resolve(arg + ' resolved');
});
};
async.asyncify(promisified)('arg', function(err, res) {
count++;
if (err) {
return done(err);
}
assert.strictEqual(res, 'arg resolved');
setTimeout(function() {
assert.strictEqual(count, 1);
done();
}, delay);
throw new Error(msg);
});
});
});
neo-async-2.6.1/test/utils/test.constant.js 0000664 0000000 0000000 00000001604 13466145133 0020707 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var parallel = require('mocha.parallel');
var async = require('../../');
parallel('#constant', function() {
it('should get constant response', function(done) {
async.constant(1, 2, 3)(function(err, result1, result2, result3) {
if (err) {
return done(err);
}
assert.deepStrictEqual(result1, 1);
assert.deepStrictEqual(result2, 2);
assert.deepStrictEqual(result3, 3);
done();
});
});
it('should ignore other arguments', function(done) {
async.constant(1, 2, 3)(4, 5, 6, 7, function(err, result1, result2, result3) {
if (err) {
return done(err);
}
assert.deepStrictEqual(result1, 1);
assert.deepStrictEqual(result2, 2);
assert.deepStrictEqual(result3, 3);
assert.strictEqual(arguments.length, 4);
done();
});
});
});
neo-async-2.6.1/test/utils/test.createLogger.js 0000664 0000000 0000000 00000003417 13466145133 0021465 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var parallel = require('mocha.parallel');
var async = require('../../');
parallel('#createLogger', function() {
it('should test logger', function(done) {
var fn = function(name) {
return function(arg, callback) {
assert.equal(arg, name);
callback(null, name);
};
};
var names = ['log', 'dir', 'test'];
var name = names.shift();
var logger = async.createLogger(name);
logger(fn(name), name, function(err, res) {
if (err) {
return done(err);
}
assert.equal(res, 'log');
name = names.shift();
logger = async.createLogger(name);
logger(fn(name), name, function(err, res) {
if (err) {
return done(err);
}
assert.equal(res, 'dir');
name = names.shift();
logger = async.createLogger(name);
logger(fn(name), name, function(err, res) {
if (err) {
return done(err);
}
assert.equal(res, 'test');
done();
});
});
});
});
it('should throw error', function(done) {
var fn = function(name) {
return function(arg, done, logger) {
assert.equal(arg, name);
logger('error');
done('error');
};
};
var names = ['log', 'debug', 'info'];
var name = names.shift();
var logger = async.createLogger(name);
logger(fn(name), name, function(err) {
assert.ok(err);
done();
});
});
it('should check logger', function(done) {
var fn = function(arg, callback) {
assert.strictEqual(arg, 'test');
callback(null, 'log', 'test');
done();
};
var logger = async.createLogger('warn');
logger(fn, 'test');
});
});
neo-async-2.6.1/test/utils/test.ensureAsync.js 0000664 0000000 0000000 00000002705 13466145133 0021360 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var parallel = require('mocha.parallel');
var async = require('../../');
parallel('#ensureAsync', function() {
it('should call function on asynchronous even if funcion is called on synchronous', function(done) {
var sync = true;
var func = function(callback) {
callback();
};
async.ensureAsync(func)(function(err) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
done();
});
sync = false;
});
it('should call asynchronous function', function(done) {
var sync = true;
var func = function(callback) {
setImmediate(callback);
};
async.ensureAsync(func)(function(err) {
if (err) {
return done(err);
}
assert.strictEqual(sync, false);
done();
});
sync = false;
});
it('should bind context', function(done) {
var func = function(callback) {
callback(this);
};
var newFunc = async.ensureAsync(func);
newFunc = newFunc.bind(Math);
newFunc(function(res) {
assert.strictEqual(res, Math);
done();
});
});
it('should not override the bound context of function', function(done) {
var func = function(callback) {
callback(this);
};
var newFunc = func.bind(Math);
newFunc = async.ensureAsync(newFunc);
newFunc(function(res) {
assert.strictEqual(res, Math);
done();
});
});
});
neo-async-2.6.1/test/utils/test.memoize.js 0000664 0000000 0000000 00000005164 13466145133 0020530 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var parallel = require('mocha.parallel');
var async = require('../../');
parallel('#memoize', function() {
it('should callback memo if same arguments', function(done) {
var order = [];
var fn = function(arg, callback) {
order.push(arg);
callback();
};
var fn2 = async.memoize(fn);
fn2(1, function() {
fn2(2, function() {
fn2(1, function() {
assert.deepStrictEqual(order, [1, 2]);
done();
});
});
});
});
it('should callback memo and maintain asynchrony', function(done) {
var order = [];
var fn = function(arg1, arg2, callback) {
order.push(['fn', arg1, arg2]);
async.setImmediate(function() {
order.push(['cb', arg1, arg2]);
callback(null, arg1 + arg2);
});
};
var fn2 = async.memoize(fn);
fn2(1, 2, function(err, res) {
assert.equal(res, 3);
fn2(1, 2, function(err, res) {
assert.equal(res, 3);
async.nextTick(memoize_done);
order.push('tick3');
});
order.push('tick2');
});
order.push('tick1');
function memoize_done() {
var call_order = [
['fn', 1, 2],
'tick1', ['cb', 1, 2],
// ['fn', 1, 2], memoized
'tick2',
// ['cb', 1, 2], memoized
'tick3'
];
assert.deepStrictEqual(call_order, order);
done();
}
});
it('should use queue', function(done) {
var order = [];
var fn = function(arg, callback) {
order.push(arg);
setTimeout(function() {
callback(null, arg);
}, 100);
};
var fn2 = async.memoize(fn);
fn2(1, function(err, res) {
assert.ok(!err);
assert.strictEqual(res, 1);
});
fn2(2, function(err, res) {
assert.ok(!err);
assert.strictEqual(res, 2);
});
fn2(1, function(err, res) {
assert.ok(!err);
assert.strictEqual(res, 1);
});
setTimeout(function() {
assert.deepStrictEqual(order, [1, 2]);
done();
}, 300);
});
it('should not memoize result if error occurs', function(done) {
var called = 0;
var order = [];
var error = new Error('error');
var fn = function(arg, callback) {
called++;
callback(error, arg);
};
var memoized = async.memoize(fn);
memoized(1, function(err) {
assert.strictEqual(err, error);
error = null;
memoized(1, function(err, result) {
assert.strictEqual(err, null);
assert.strictEqual(result, 1);
assert.strictEqual(called, 2);
done();
});
})
});
});
neo-async-2.6.1/test/utils/test.reflect.js 0000664 0000000 0000000 00000006743 13466145133 0020513 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var parallel = require('mocha.parallel');
var async = require('../../');
parallel('#reflect', function() {
it('should execute with error in parallel', function(done) {
var tasks = [
async.reflect(function(callback) {
callback('error', 1);
}),
async.reflect(function(callback) {
callback('error2', 2);
}),
async.reflect(function(callback) {
callback(null, 3);
})
];
async.parallel(tasks, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [
{ error: 'error' },
{ error: 'error2' },
{ value: 3 }
]);
done();
});
});
it('should execute with error in series', function(done) {
var tasks = [
async.reflect(function(callback) {
callback('error', 1);
}),
async.reflect(function(callback) {
callback('error2', 2);
}),
async.reflect(function(callback) {
callback(null, 3, 3);
})
];
async.series(tasks, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [
{ error: 'error' },
{ error: 'error2' },
{ value: [3, 3] }
]);
done();
});
});
it('should execute even if it has an argument', function(done) {
var reflect = async.reflect(function(arg, callback) {
callback('error', arg);
});
reflect(1, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {
error: 'error'
});
done();
});
});
it('should execute even if it has two arguments', function(done) {
var reflect = async.reflect(function(arg1, arg2, callback) {
callback(null, arg1, arg2);
});
reflect(1, 2, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {
value: [1, 2]
});
done();
});
});
it('should execute even if it has some arguments', function(done) {
var reflect = async.reflect(function(arg1, arg2, arg3, arg4, callback) {
callback(null, arg3, arg4, arg1);
});
reflect(1, 2, 3, 4, function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {
value: [3, 4, 1]
});
done();
});
});
});
parallel('#reflectAll', function() {
it('should execute array tasks', function(done) {
var tasks = [
function(done) {
done('error', 1);
},
function(done) {
done('error2', 2);
},
function(done) {
done(null, 3);
}
];
async.parallel(async.reflectAll(tasks), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, [
{ error: 'error' },
{ error: 'error2' },
{ value: 3 }
]);
done();
});
});
it('should execute object tasks', function(done) {
var tasks = {
a: function(done) {
done('error', 1);
},
b: function(done) {
done('error2', 2);
},
c: function(done) {
done(null, 3, 4, 5);
}
};
async.parallel(async.reflectAll(tasks), function(err, res) {
if (err) {
return done(err);
}
assert.deepStrictEqual(res, {
a: { error: 'error' },
b: { error: 'error2' },
c: { value: [3, 4, 5] }
});
done();
});
});
});
neo-async-2.6.1/test/utils/test.unmemoize.js 0000664 0000000 0000000 00000001124 13466145133 0021063 0 ustar 00root root 0000000 0000000 /* global it */
'use strict';
var assert = require('assert');
var parallel = require('mocha.parallel');
var async = require('../../');
parallel('#unmemoize', function() {
it('should execute without memo', function(done) {
var order = [];
var fn = function(arg, callback) {
order.push(arg);
callback();
};
var fn2 = async.memoize(fn);
fn2 = async.unmemoize(fn2);
fn2(1, function() {
fn2(2, function() {
fn2(1, function() {
assert.deepStrictEqual(order, [1, 2, 1]);
done();
});
});
});
});
});