maximize-iterator - npm Package Compare versions

Comparing version 1.0.0 to 1.1.0

lib/callIteratorsAsyncIterator.js

+var getKeep = require('./getKeep');
+
+async function next(iterator, options, callback) {
+  const value = await iterator[Symbol.asyncIterator]().next();
+  if (options.done) return;
+  if (value === null) {
+    options.done = true;
+    return callback();
+  }
+
+  if (options.each) {
+    const keep = await new Promise(function (resolve, reject) {
+      getKeep(options.each(value), function (err, keep) {
+        err ? reject(err) : resolve(keep);
+      });
+    });
+    if (options.done) return;
+    if (!keep) {
+      options.done = true;
+      return callback();
+    }
+  }
+}
+
+module.exports = async function callIteratorsAsyncIterator(iterator, options, callback) {
+  var counter = 0;
+  while (options.counter < options.concurrency) {
+    if (options.done || counter++ > options.batch) return; // done
+    options.counter++;
+
+    next(iterator, options, callback)
+      .then(function () {
+        options.counter--;
+        if (options.done) return;
+        callIteratorsAsyncIterator(iterator, options, callback);
+      })
+      .catch(function (err) {
+        options.counter--;
+        if (options.done) return;
+        if (err) {
+          options.done = true;
+          return callback(err);
+        }
+      });
+  }
+};

lib/callIteratorsCallback.js

+var getKeep = require('./getKeep');
+
+module.exports = function callIteratorsCallback(iterator, options, callback) {
+  var counter = 0;
+  while (options.counter < options.concurrency) {
+    if (options.done || counter++ > options.batch) return; // done
+    options.counter++;
+
+    iterator.next(function (err, value) {
+      if (options.done) return;
+      if (err || value === null) {
+        options.done = true;
+        return callback(err);
+      }
+
+      if (!options.each) {
+        options.counter--;
+        return callIteratorsCallback(iterator, options, callback);
+      }
+
+      try {
+        getKeep(options.each(value), function (err1, keep) {
+          if (options.done) return;
+          if (err1) {
+            options.done = true;
+            return callback(err1);
+          }
+
+          if (!keep) {
+            options.done = true;
+            return callback();
+          }
+          options.counter--;
+          return callIteratorsCallback(iterator, options, callback);
+        });
+      } catch (err) {
+        options.done = true;
+        return callback(err);
+      }
+    });
+  }
+};

lib/useAsyncIterator.js

+const HAS_ASYNC_ITERATOR = typeof Symbol !== 'undefined' && Symbol.asyncIterator;
+
+module.exports = function (obj) {
+  if (!HAS_ASYNC_ITERATOR || obj.next) return false; // prefer callback-based next over asyncIterator
+  return !!obj[Symbol.asyncIterator];
+};

test/spec/platform-specific.test.js

+const HAS_ASYNC_ITERATOR = typeof Symbol !== 'undefined' && Symbol.asyncIterator;
+const HAS_ASYNC_AWAIT = typeof Symbol !== 'undefined' && Symbol.asyncIterator;
+
+describe('platform specific', function () {
+  if (HAS_ASYNC_ITERATOR) require('./platform-specific/asyncIterator');
+  if (HAS_ASYNC_AWAIT) require('./platform-specific/asyncAwait');
+});

test/spec/platform-specific/asyncAwait.js

+var assert = require('assert');
+var maximizeIterator = require('../../..');
+
+class Iterator {
+  constructor(values) {
+    this.values = values;
+  }
+  next(callback) {
+    if (!this.values.length) return callback(null, null);
+    return callback(null, this.values.shift());
+  }
+}
+
+describe('async await', function () {
+  it('should get all (default options)', async function () {
+    var iterator = new Iterator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+
+    try {
+      await maximizeIterator(iterator);
+    } catch (err) {
+      assert.ok(!err);
+    }
+    assert.equal(iterator.values.length, 0);
+  });
+
+  it('should get all (concurrency 1)', async function () {
+    var iterator = new Iterator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+
+    var results = [];
+    try {
+      await maximizeIterator(iterator, { concurrency: 1, each: results.push.bind(results) });
+      assert.equal(iterator.values.length, 0);
+      assert.deepEqual(results, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+    } catch (err) {
+      assert.ok(!err);
+    }
+  });
+
+  it('should get all (concurrency 100)', async function () {
+    var iterator = new Iterator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+
+    var results = [];
+    try {
+      await maximizeIterator(iterator, { concurrency: 100, each: results.push.bind(results) });
+    } catch (err) {
+      assert.ok(!err);
+    }
+    assert.equal(iterator.values.length, 0);
+    assert.deepEqual(results.sort(), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].sort());
+  });
+
+  it('should get with promises (concurrency 1)', async function () {
+    var iterator = new Iterator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+
+    var results = [];
+    try {
+      await maximizeIterator(iterator, {
+        concurrency: 1,
+        each: async function (value) {
+          results.push(value);
+          return true;
+        },
+      });
+    } catch (err) {
+      assert.ok(!err);
+    }
+    assert.equal(iterator.values.length, 0);
+    assert.deepEqual(results, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+  });
+
+  it('should get with promises and early exit (concurrency 1)', async function () {
+    var iterator = new Iterator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+
+    var results = [];
+    try {
+      await maximizeIterator(iterator, {
+        concurrency: 1,
+        each: async function (value) {
+          if (value === 3) return false;
+          results.push(value);
+          return true;
+        },
+      });
+    } catch (err) {
+      assert.ok(!err);
+    }
+    assert.equal(iterator.values.length, 7);
+    assert.deepEqual(results, [1, 2]);
+  });
+});

test/spec/platform-specific/asyncIterator.js

+var assert = require('assert');
+var maximizeIterator = require('../../..');
+
+class Iterator {
+  constructor(values) {
+    this.values = values;
+  }
+}
+Iterator.prototype[Symbol.asyncIterator] = function () {
+  var self = this;
+  return { next: nextPromise };
+
+  function nextPromise() {
+    return new Promise(function (resolve) {
+      if (!self.values.length) return resolve(null);
+      return resolve(self.values.shift());
+    });
+  }
+};
+
+describe('asyncIterator', function () {
+  it('should get all (default options)', async function () {
+    var iterator = new Iterator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+
+    try {
+      await maximizeIterator(iterator);
+    } catch (err) {
+      assert.ok(!err);
+    }
+    assert.equal(iterator.values.length, 0);
+  });
+
+  it('should get all (concurrency 1)', async function () {
+    var iterator = new Iterator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+
+    var results = [];
+    try {
+      await maximizeIterator(iterator, { concurrency: 1, each: results.push.bind(results) });
+      assert.equal(iterator.values.length, 0);
+      assert.deepEqual(results, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+    } catch (err) {
+      assert.ok(!err);
+    }
+  });
+
+  it('should get all (concurrency 100)', async function () {
+    var iterator = new Iterator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+
+    var results = [];
+    try {
+      await maximizeIterator(iterator, { concurrency: 100, each: results.push.bind(results) });
+    } catch (err) {
+      assert.ok(!err);
+    }
+    assert.equal(iterator.values.length, 0);
+    assert.deepEqual(results.sort(), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].sort());
+  });
+
+  it('should get with promises (concurrency 1)', async function () {
+    var iterator = new Iterator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+
+    var results = [];
+    try {
+      await maximizeIterator(iterator, {
+        concurrency: 1,
+        each: async function (value) {
+          results.push(value);
+          return true;
+        },
+      });
+    } catch (err) {
+      assert.ok(!err);
+    }
+    assert.equal(iterator.values.length, 0);
+    assert.deepEqual(results, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+  });
+
+  it('should get with promises and early exit (concurrency 1)', async function () {
+    var iterator = new Iterator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+
+    var results = [];
+    try {
+      await maximizeIterator(iterator, {
+        concurrency: 1,
+        each: async function (value) {
+          if (value === 3) return false;
+          results.push(value);
+          return true;
+        },
+      });
+    } catch (err) {
+      assert.ok(!err);
+    }
+    assert.equal(iterator.values.length, 7);
+    assert.deepEqual(results, [1, 2]);
+  });
+});

index.js

@@ -1,48 +0,11 @@
-var getKeep = require('./lib/getKeep');
 var callOnce = require('./lib/callOnce');
+var callIteratorsCallback = require('./lib/callIteratorsCallback');
 
+const HAS_ASYNC_ITERATOR = typeof Symbol !== 'undefined' && Symbol.asyncIterator;
+var useAsyncIterator = require('./lib/useAsyncIterator');
+var callIteratorsAsyncIterator = HAS_ASYNC_ITERATOR ? require('./lib/callIteratorsAsyncIterator') : null;
+
 var DEFAULT_CONCURRENCY = 4096;
 var MAXIMUM_BATCH = 10;
 
-function callIterators(iterator, options, callback) {
-  var counter = 0;
-  while (options.counter < options.concurrency) {
-    if (options.done || counter++ > options.batch) return; // done
-    options.counter++;
-
-    iterator.next(function (err, result) {
-      if (options.done) return;
-      if (err || result.done) {
-        options.done = true;
-        return callback(err);
-      }
-
-      if (!options.each) {
-        options.counter--;
-        return callIterators(iterator, options, callback);
-      }
-
-      try {
-        getKeep(options.each(result.value), function (err1, keep) {
-          if (options.done) return;
-          if (err1) {
-            options.done = true;
-            return callback(err1);
-          }
-
-          if (!keep) {
-            options.done = true;
-            return callback();
-          }
-          options.counter--;
-          return callIterators(iterator, options, callback);
-        });
-      } catch (err) {
-        options.done = true;
-        return callback(err);
-      }
-    });
-  }
-}
-
 module.exports = function maximizeIterator(iterator, options, callback) {
@@ -61,3 +24,6 @@ if (typeof options === 'function') {
 
-  if (typeof callback === 'function') return callIterators(iterator, options, callOnce(callback));
+  if (typeof callback === 'function') {
+    if (useAsyncIterator(iterator)) return callIteratorsAsyncIterator(iterator, options, callOnce(callback));
+    else return callIteratorsCallback(iterator, options, callOnce(callback));
+  }
   return new Promise(function (resolve, reject) {
@@ -64,0 +30,0 @@ maximizeIterator(iterator, options, function (err) {

package.json

 {
   "name": "maximize-iterator",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Maximize the parallel calls of an iterator supporting asyncIterator interface",
@@ -5,0 +5,0 @@ "main": "index.js",

test/spec/callback.test.js

@@ -9,4 +9,4 @@ var assert = require('assert');
   next(callback) {
-    if (!this.values.length) return callback(null, { done: true });
-    return callback(null, { done: false, value: this.values.shift() });
+    if (!this.values.length) return callback(null, null);
+    return callback(null, this.values.shift());
   }
@@ -13,0 +13,0 @@ }

test/spec/promises.test.js

@@ -9,4 +9,4 @@ var assert = require('assert');
   next(callback) {
-    if (!this.values.length) return callback(null, { done: true });
-    return callback(null, { done: false, value: this.values.shift() });
+    if (!this.values.length) return callback(null, null);
+    return callback(null, this.values.shift());
   }
@@ -16,77 +16,92 @@ }
 describe('promises interface', function () {
-  it('should get all (default options)', async function () {
+  it('should get all (default options)', function (callback) {
     var iterator = new Iterator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 
-    try {
-      await maximizeIterator(iterator);
-    } catch (err) {
-      assert.ok(!err);
-    }
-    assert.equal(iterator.values.length, 0);
+    maximizeIterator(iterator)
+      .then(function () {
+        assert.equal(iterator.values.length, 0);
+        callback();
+      })
+      .catch(function (err) {
+        assert.ok(!err);
+        callback(err);
+      });
   });
 
-  it('should get all (concurrency 1)', async function () {
+  it('should get all (concurrency 1)', function (callback) {
     var iterator = new Iterator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 
     var results = [];
-    try {
-      await maximizeIterator(iterator, { concurrency: 1, each: results.push.bind(results) });
-      assert.equal(iterator.values.length, 0);
-      assert.deepEqual(results, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-    } catch (err) {
-      assert.ok(!err);
-    }
+    maximizeIterator(iterator, { concurrency: 1, each: results.push.bind(results) })
+      .then(function () {
+        assert.equal(iterator.values.length, 0);
+        assert.deepEqual(results, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+        callback();
+      })
+      .catch(function (err) {
+        assert.ok(!err);
+        callback(err);
+      });
   });
 
-  it('should get all (concurrency 100)', async function () {
+  it('should get all (concurrency 100)', function (callback) {
     var iterator = new Iterator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 
     var results = [];
-    try {
-      await maximizeIterator(iterator, { concurrency: 100, each: results.push.bind(results) });
-    } catch (err) {
-      assert.ok(!err);
-    }
-    assert.equal(iterator.values.length, 0);
-    assert.deepEqual(results.sort(), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].sort());
+    maximizeIterator(iterator, { concurrency: 100, each: results.push.bind(results) })
+      .then(function () {
+        assert.equal(iterator.values.length, 0);
+        assert.deepEqual(results.sort(), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].sort());
+        callback();
+      })
+      .catch(function (err) {
+        assert.ok(!err);
+        callback(err);
+      });
   });
 
-  it('should get with promises (concurrency 1)', async function () {
+  it('should get with promises (concurrency 1)', function (callback) {
     var iterator = new Iterator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 
     var results = [];
-    try {
-      await maximizeIterator(iterator, {
-        concurrency: 1,
-        each: async function (value) {
-          results.push(value);
-          return true;
-        },
+    maximizeIterator(iterator, {
+      concurrency: 1,
+      each: function (value) {
+        results.push(value);
+        return true;
+      },
+    })
+      .then(function () {
+        assert.equal(iterator.values.length, 0);
+        assert.deepEqual(results, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+        callback();
+      })
+      .catch(function (err) {
+        assert.ok(!err);
+        callback(err);
       });
-    } catch (err) {
-      assert.ok(!err);
-    }
-    assert.equal(iterator.values.length, 0);
-    assert.deepEqual(results, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
   });
 
-  it('should get with promises and early exit (concurrency 1)', async function () {
+  it('should get with promises and early exit (concurrency 1)', function (callback) {
     var iterator = new Iterator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 
     var results = [];
-    try {
-      await maximizeIterator(iterator, {
-        concurrency: 1,
-        each: async function (value) {
-          if (value === 3) return false;
-          results.push(value);
-          return true;
-        },
+    maximizeIterator(iterator, {
+      concurrency: 1,
+      each: function (value) {
+        if (value === 3) return false;
+        results.push(value);
+        return true;
+      },
+    })
+      .then(function () {
+        assert.equal(iterator.values.length, 7);
+        assert.deepEqual(results, [1, 2]);
+        callback();
+      })
+      .catch(function (err) {
+        assert.ok(!err);
+        callback(err);
       });
-    } catch (err) {
-      assert.ok(!err);
-    }
-    assert.equal(iterator.values.length, 7);
-    assert.deepEqual(results, [1, 2]);
   });
 });

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

18008

76.55%

Number of package files

19

46.15%

Lines of code

473

102.14%

Worsened metrics

Number of medium supply chain risk alerts

1

Infinity%

No dependency changes