queue-async - npm Package Compare versions

Comparing version 1.0.7 to 1.1.0

package.json

 {
   "name": "queue-async",
-  "version": "1.0.7",
+  "version": "1.1.0",
   "description": "A little helper for asynchronous JavaScript.",
@@ -10,2 +10,4 @@ "keywords": [
   ],
+  "homepage": "https://github.com/mbostock/queue",
+  "license": "BSD-3-Clause",
   "author": {
@@ -15,2 +17,4 @@ "name": "Mike Bostock",
   },
+  "main": "build/queue.js",
+  "jsnext:main": "index",
   "repository": {
@@ -20,10 +24,14 @@ "type": "git",
   },
-  "main": "queue.js",
+  "scripts": {
+    "pretest": "mkdir -p build && node -e 'process.stdout.write(\"import queue from \\\"../index\\\"; queue.version = \\\"\" + require(\"./package.json\").version + \"\\\"; export default queue;\");' > build/bundle.js && rollup -f umd -u queue -n queue -o build/queue.js -- build/bundle.js",
+    "test": "faucet `find test -name '*-test.js'` && eslint index.js src",
+    "prepublish": "npm run test && uglifyjs build/queue.js -c -m -o build/queue.min.js && rm -f build/queue.zip && zip -j build/queue.zip -- LICENSE README.md build/queue.js build/queue.min.js"
+  },
   "devDependencies": {
-    "uglify-js": "2",
-    "vows": "0.7"
-  },
-  "scripts": {
-    "test": "vows; echo"
+    "faucet": "0.0",
+    "rollup": "0.25",
+    "seedrandom": "2",
+    "tape": "4",
+    "uglify-js": "2"
   }
 }

README.md

@@ -1,4 +0,4 @@
-# queue.js
+# Queue
 
-**Queue.js** is yet another asynchronous helper library for JavaScript. Think of it as a minimalist version of [Async.js](https://github.com/caolan/async) that allows fine-tuning over parallelism. Or, think of it as a version of [TameJs](http://tamejs.org/) that does not use code generation.
+**Queue.js** is yet another asynchronous helper library for JavaScript. Think of Queue as a minimalist version of [Async.js](https://github.com/caolan/async) that allows fine-tuning over parallelism. Or, think of it as a version of [TameJs](https://github.com/maxtaco/tamejs/) that does not use code generation.
 
@@ -22,3 +22,3 @@ For example, if you wanted to stat two files in parallel:
 
-Queue.js can be run inside Node.js or in a browser.
+Queue can be run inside Node.js or in a browser.
 
@@ -30,9 +30,13 @@ ## Installation
 ```html
-<script src="http://d3js.org/queue.v1.min.js"></script>
+<script src="https://d3js.org/queue.v1.min.js"></script>
 ```
 
-Queue.js supports the asynchronous module definition (AMD) API. For example, if you use [RequireJS](http://requirejs.org/), you may load as follows:
+Queue supports the [universal module definition](https://github.com/umdjs/umd) API. For example, with [RequireJS](http://requirejs.org/):
 
 ```js
-require.config({paths: {queue: "http://d3js.org/queue.v1.min"}});
+require.config({
+  paths: {
+    queue: "https://d3js.org/queue.v1.min"
+  }
+});
 
@@ -54,17 +58,48 @@ require(["queue"], function(queue) {
 
-### queue([parallelism])
+<a href="#queue" name="queue">#</a> <b>queue</b>([<i>parallelism</i>])
 
 Constructs a new queue with the specified *parallelism*. If *parallelism* is not specified, the queue has infinite parallelism. Otherwise, *parallelism* is a positive integer. For example, if *parallelism* is 1, then all tasks will be run in series. If *parallelism* is 3, then at most three tasks will be allowed to proceed concurrently; this is useful, for example, when loading resources in a web browser.
 
-### queue.defer(task[, arguments…])
+<a href="#queue_defer" name="queue_defer">#</a> <i>queue</i>.<b>defer</b>(<i>task</i>[, <i>arguments</i>…])
 
-Adds the specified asynchronous *task* function to the queue, with any optional *arguments*. The *task* will be called with the optional arguments and an additional callback argument; the callback should be invoked when the task has finished. Tasks can only be deferred before the *await* callback is set. If a task is deferred after the await callback is set, the behavior of the queue is undefined.
+Adds the specified asynchronous *task* callback to the queue, with any optional *arguments*. The *task* will be called with the specified optional arguments and an additional callback argument; the callback must then be invoked by the task when it has finished. The task must invoke the callback with two arguments: the error, if any, and the result of the task. For example:
 
-### queue.await(callback)
-### queue.awaitAll(callback)
+```js
+function simpleTask(callback) {
+  setTimeout(function() {
+    callback(null, {answer: 42});
+  }, 250);
+}
+```
 
-Sets the *callback* to be invoked when all deferred tasks have finished. The first argument to the *callback* is the first error that occurred, or null if no error occurred. If *await* is used, each result is passed as an additional separate argument; if *awaitAll* is used, the entire array of results is passed as the second argument to the callback. If all callbacks have already been completed by the time the *await* or *awaitAll* callback is set, the callback will be invoked immediately. This method should only be called once, after any tasks have been deferred. If the await callback is set multiple times, or set before a task is deferred, the behavior of the queue is undefined.
+To return multiple results from a single callback, wrap those results in an object or array.
 
-## Callbacks
+If the task calls back with an error, any tasks that were scheduled *but not yet started* will not run. For a serial queue (of *parallelism* 1), this means that a task will only run if all previous tasks succeed. For a queue with higher parallelism, only the first error that occurs is reported to the await callback, and tasks that were started before the error occurred will continue to run; note, however, that their results will not be reported to the await callback.
 
-The callbacks follow the Node.js convention where the first argument is an optional error object and the second argument is the result of the task. Queue.js does not support asynchronous functions that return multiple results; however, you can homogenize such functions by wrapping them and converting multiple results into a single object or array.
+Tasks can only be deferred before [*queue*.await](#queue_await) or [*queue*.awaitAll](#queue_awaitAll) is called. If a task is deferred after then, an error is thrown.
+
+<a href="#queue_await" name="queue_await">#</a> <i>queue</i>.<b>await</b>(<i>callback</i>)
+
+Sets the *callback* to be invoked when all deferred tasks have finished. The first argument to the *callback* is the first error that occurred, or null if no error occurred. If an error occurred, there are no additional arguments to the callback. Otherwise, the *callback* is passed each result as an additional argument. For example:
+
+```js
+queue()
+    .defer(fs.stat, __dirname + "/../Makefile")
+    .defer(fs.stat, __dirname + "/../package.json")
+    .await(function(error, file1, file2) { console.log(file1, file2); });
+```
+
+If all [deferred](#queue_defer) tasks have already completed, the callback will be invoked immediately. This method may only be called once, after any tasks have been deferred. If this method is called multiple times, or if it is called after [*queue*.awaitAll](#queue_awaitAll), an error is thrown.
+
+<a href="#queue_awaitAll" name="queue_awaitAll">#</a> <i>queue</i>.<b>awaitAll</b>(<i>callback</i>)
+
+Sets the *callback* to be invoked when all deferred tasks have finished. The first argument to the *callback* is the first error that occurred, or null if no error occurred. If an error occurred, there are no additional arguments to the callback. Otherwise, the *callback* is also passed an array of results as the second argument. For example:
+
+```js
+queue()
+    .defer(fs.stat, __dirname + "/../Makefile")
+    .defer(fs.stat, __dirname + "/../package.json")
+    .awaitAll(function(error, files) { console.log(files); });
+```
+
+If all [deferred](#queue_defer) tasks have already completed, the callback will be invoked immediately. This method may only be called once, after any tasks have been deferred. If this method is called multiple times, or if it is called after [*queue*.await](#queue_await), an error is thrown.

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

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

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

No website

Quality

Package does not have a website.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

13648

increased by43.89%

Lines of code

163

increased by48.18%

Number of low quality alerts

0

decreased by-100%

Number of lines in readme file

103

increased by51.47%

Worsened metrics

Dev dependency count

5

increased by150%

Number of medium supply chain risk alerts

1

increased byInfinity%

No dependency changes