async-co - npm Package Compare versions

Comparing version 1.0.1 to 1.1.0

each.js

@@ -5,5 +5,5 @@ "use strict";
 
-module.exports = function *(series, thunk) {
-  yield eachLimit(series, series.length, thunk);
+module.exports = function *(series, thunk, ctx) {
+  yield eachLimit(series, series.length, thunk, ctx);
 };
 

eachLimit.js

 "use strict";
 
 
-module.exports = function *(series, n, thunk) {
+module.exports = function *(series, n, thunk, ctx) {
   var n = Math.min(n || 5, series.length);
@@ -16,3 +16,3 @@
     let i = index++;
-    ret[i] = yield thunk(series[i]);
+    ret[i] = yield thunk.call(ctx || this, series[i]);
 
@@ -19,0 +19,0 @@ yield next; //continue in lane

eachOf.js

@@ -5,5 +5,5 @@ "use strict";
 
-module.exports = function *(series, thunk) {
-  yield eachOfLimit(series, Object.keys(series).length, thunk);
+module.exports = function *(series, thunk, ctx) {
+  yield eachOfLimit(series, Object.keys(series).length, thunk, ctx);
 };
 

eachOfLimit.js

@@ -5,8 +5,8 @@ "use strict";
 
-module.exports = function *(series, n, thunk){
+module.exports = function *(series, n, thunk, ctx){
 
   yield eachLimit(Object.keys(series), n, function* (k){
     yield thunk(series[k], k);
-  });
+  }, ctx);
 };
 

eachOfSeries.js

@@ -6,5 +6,5 @@ "use strict";
   //what did you expect..
-module.exports = function (series, thunk){
-  return eachOfLimit(series, 1, thunk);
+module.exports = function (series, thunk, ctx){
+  return eachOfLimit(series, 1, thunk, ctx);
 };
 

eachSeries.js

@@ -6,5 +6,5 @@ "use strict";
   //what did you expect..
-module.exports = function (series, thunk){
-  return eachLimit(series, 1, thunk);
+module.exports = function (series, thunk, ctx){
+  return eachLimit(series, 1, thunk, ctx);
 };
 

package.json

 {
   "name": "async-co",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Control flow for co with async.js (v2) signatures",
@@ -5,0 +5,0 @@ "main": "index.js",

queue.js

@@ -8,7 +8,2 @@ "use strict";
 
-  var push = function * (task) {
-    var delayed = yield process(task);
-    return delayed;
-  }
-
   var process = function *(task) {
@@ -35,3 +30,5 @@ yield pickworker();
 
-  return { push };
+  var out  = process;  // better candidate than {}
+  out.push = process; // per compatibility
+  return out;
 }

README.md

@@ -1,27 +0,29 @@
-Control flow for ES6 generator (co) with async.js (v2) signatures
+Control flow ala ES7 async/await using  ES6 generator (thanks to [tj/co](https://github.com/tj/co)) with async.js (v2) signatures
 
 # Motivation
-async-co provide javascript async/await (through ES6 generator & co) equivalent signatures of the excellent [async](https://github.com/caolan/async) workflow library. 
+[async-co](https://github.com/131/async-co) provide javascript async/await (through ES6 generator & co) equivalent signatures of the excellent [async](https://github.com/caolan/async) workflow library.
 
+**async-co** is not a wrapper on **async**, but rather leverages the full potential of native async/await & promises contract. Code tend to be small & very efficient (far more simplier than using callbacks), just give [async-co/queue.js](https://github.com/131/async-co/blob/master/queue.js) a look
 
-## Addition to the async library signatures
-Because of the Promise contract (and sane API), it's easy to "throttle" a function that return a Promise (see the "throttle" API, for a way to make an ultra simple http request pooling).
 
+## Addition to the async library signatures / promise pooling
+Per design, it's easy to "throttle" a function that return a Promise ; checkout the "throttle" API for a way to make an ultra simple http request pooling.
 
+
 # API
 
-## async-co/eachLimit(arr, concurrency, *thunk)
+## async-co/eachLimit(arr, concurrency, *thunk [, thisobj])
 Nothing special here
-## async-co/eachSeries(arr, *thunk)
+## async-co/eachSeries(arr, *thunk [, thisobj] )
 // = eachLimit concurrency = 1
-## async-co/each(arr, *thunk)
+## async-co/each(arr, *thunk [, thisobj])
 // = eachLimit concurrency = arr.length
 
-## async-co/eachOfLimit (dict, concurrency, *thunk)
+## async-co/eachOfLimit (dict, concurrency, *thunk [, thisobj])
 Nothing special here neither
 
-## async-co/eachOfSeries(dict, *thunk)
+## async-co/eachOfSeries(dict, *thunk [, thisobj])
  // = eachOfLimit concurrency = 1
 
-## async-co/eachOf(dict, *thunk)
+## async-co/eachOf(dict, *thunk [, thisobj])
 // = eachOfLimit concurrency = dict.length
@@ -86,5 +88,5 @@
 * Get rich or die tryin'
+* write a working async-co/cargo (see [the challenge on stackoverflow](http://stackoverflow.com/questions/39069624))
 
 # Credits
-
 * [131](https://github.com/131)
@@ -94,4 +96,9 @@ * not dependant upon, yet relying on [co](https://github.com/tj/co)
 
+## Alternatives / relatives
+* [koa-async](https://github.com/eladnava/koa-async) ; a clever Promisify wrapper on top of async (but  not leveraging the full potential of ES7 async/await capabilities)
+* [caolan/async/asyncify.js](https://github.com/caolan/async/blob/master/lib/asyncify.js) goes the same as koa-async.
+* [es6-promise-pool](https://github.com/timdp/es6-promise-pool) ; equivalent to async-co/queue, with a different API
 
 
+
 # Shoutbox, keywords, SEO love
@@ -98,0 +105,0 @@ async/await, ES6 generators, co, async-co, promise, Promises, yield, async, queue, map, throttle, "Let's have a beer & talk in Paris"

throttle.js

@@ -9,5 +9,5 @@ "use strict";
   return function () {
-    return q.push([].slice.apply(arguments));
+    return q([].slice.apply(arguments));
   };
 
 }

New alerts

Network access

Supply chain risk

This module accesses the network.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

9479

increased by38.91%

Number of package files

15

increased by15.38%

Lines of code

177

increased by43.9%

Number of lines in readme file

107

increased by7%

Worsened metrics

Number of medium supply chain risk alerts

1

increased byInfinity%

No dependency changes