feat: initial async generator support

.babelrc

@@ -1,5 +1,8 @@
 {
-  "plugins": ["transform-es2015-modules-commonjs"],
+  "plugins": [
+    "transform-es2015-modules-commonjs",
+    "syntax-async-generators"
+  ],
   "env": {
     "test": {
       "plugins": ["istanbul"]

lib/internal/asyncEachOfLimit.js

@@ -0,0 +1,59 @@
+const breakLoop = require('./breakLoop')
+
+// for async generators
+export default function asyncEachOfLimit(generator, limit, iteratee, callback) {
+    let done = false
+    let canceled = false
+    let awaiting = false
+    let running = 0
+    let idx = 0
+
+    function replenish() {
+        //console.log('replenish')
+        if (running >= limit || awaiting) return
+        //console.log('replenish awaiting')
+        awaiting = true
+        generator.next().then(({value, done: iterDone}) => {
+            //console.log('got value', value)
+            awaiting = false
+            if (iterDone) {
+                done = true;
+                if (running <= 0) {
+                    callback(null)
+                }
+                return;
+            }
+            running++
+            iteratee(value, idx, iterateeCallback)
+            idx++
+            replenish()
+        }).catch(handleError)
+    }
+
+    function iterateeCallback(err, result) {
+        //console.log('iterateeCallback')
+        if (canceled) return
+        running -= 1;
+        if (err) return handleError(err)
+
+        if (err === false) {
+            done = true;
+            canceled = true;
+        }
+
+        if (result === breakLoop || (done && running <= 0)) {
+            done = true;
+            //console.log('done')
+            return callback(null);
+        }
+        replenish()
+    }
+
+    function handleError(err) {
+        awaiting = false
+        done = true
+        callback(err)
+    }
+
+    replenish()
+}

lib/internal/eachOfLimit.js

@@ -3,6 +3,8 @@ import once from './once';
 
 import iterator from './iterator';
 import onlyOnce from './onlyOnce';
+import {isAsyncGenerator} from './wrapAsync'
+import asyncEachOfLimit from './asyncEachOfLimit'
 
 import breakLoop from './breakLoop';
 
@@ -15,6 +17,9 @@ export default (limit) => {
         if (!obj) {
             return callback(null);
         }
+        if (isAsyncGenerator(obj)) {
+            return asyncEachOfLimit(obj, limit, iteratee, callback)
+        }
         var nextElem = iterator(obj);
         var done = false;
         var canceled = false;

lib/internal/wrapAsync.js

@@ -4,10 +4,14 @@ function isAsync(fn) {
     return fn[Symbol.toStringTag] === 'AsyncFunction';
 }
 
+function isAsyncGenerator(fn) {
+    return fn[Symbol.toStringTag] === 'AsyncGenerator';
+}
+
 function wrapAsync(asyncFn) {
     return isAsync(asyncFn) ? asyncify(asyncFn) : asyncFn;
 }
 
 export default wrapAsync;
 
-export { isAsync };
+export { isAsync, isAsyncGenerator };

package.json

@@ -23,6 +23,7 @@
     "babel-core": "^6.26.3",
     "babel-plugin-add-module-exports": "^0.2.1",
     "babel-plugin-istanbul": "^2.0.1",
+    "babel-plugin-syntax-async-generators": "^6.13.0",
     "babel-plugin-transform-es2015-modules-commonjs": "^6.26.2",
     "babel-preset-es2015": "^6.3.13",
     "babel-preset-es2017": "^6.22.0",

test/asyncFunctions.js

@@ -11,6 +11,17 @@ function supportsAsync() {
     return supported;
 }
 
+function supportsAsyncGenerators() {
+    var supported;
+    try {
+        /* eslint no-eval: 0 */
+        supported = eval('(async function * () { yield await 1 })');
+    } catch (e) {
+        supported = false;
+    }
+    return supported;
+}
+
 describe('async function support', function () {
     this.timeout(100);
 
@@ -19,4 +30,10 @@ describe('async function support', function () {
     } else {
         it('should not test async functions in this environment');
     }
+
+    if (supportsAsyncGenerators()) {
+        require('./es2017/asyncGenerators.js')();
+    } else {
+        it('should not test async generators in this environment');
+    }
 });

test/es2017/asyncGenerators.js

@@ -0,0 +1,61 @@
+var async = require('../../lib');
+const {expect} = require('chai');
+const assert = require('assert');
+
+const delay = ms => new Promise(resolve => setTimeout(resolve, ms))
+
+module.exports = function () {
+    async function asyncIdentity(val) {
+        var res = await Promise.resolve(val);
+        return res;
+    }
+
+    async function * range (num) {
+        for(let i = 0; i < num; i++) {
+            await delay(1)
+            yield i
+        }
+    }
+
+    it('should handle async generators in each', (done) => {
+        const calls = []
+        async.each(range(5),
+            async (val) => {
+                calls.push(val)
+                await delay(5)
+            }, (err) => {
+                if (err) throw err
+                expect(calls).to.eql([0, 1, 2, 3, 4])
+                done()
+            }
+        )
+    });
+
+    it('should handle async generators in eachLimit', (done) => {
+        const calls = []
+        async.eachLimit(range(5), 2,
+            async (val) => {
+                calls.push(val)
+                await delay(5)
+            }, (err) => {
+                if (err) throw err
+                expect(calls).to.eql([0, 1, 2, 3, 4])
+                done()
+            }
+        )
+    });
+
+    it('should handle async generators in eachSeries', (done) => {
+        const calls = []
+        async.eachSeries(range(5),
+            async (val) => {
+                calls.push(val)
+                await delay(5)
+            }, (err) => {
+                if (err) throw err
+                expect(calls).to.eql([0, 1, 2, 3, 4])
+                done()
+            }
+        )
+    });
+}