Update checked-in dependencies

node_modules/p-map/readme.md

@@ -1,9 +1,11 @@
-# p-map [![Build Status](https://travis-ci.org/sindresorhus/p-map.svg?branch=master)](https://travis-ci.org/sindresorhus/p-map)
+# p-map
 
 > Map over promises concurrently
 
 Useful when you need to run promise-returning & async functions multiple times with different inputs concurrently.
 
+This is different from `Promise.all()` in that you can control the concurrency and also decide whether or not to stop iterating when there's an error.
+
 ## Install
 
 ```
@@ -13,26 +15,24 @@ $ npm install p-map
 ## Usage
 
 ```js
-const pMap = require('p-map');
-const got = require('got');
+import pMap from 'p-map';
+import got from 'got';
 
 const sites = [
-	getWebsiteFromUsername('https://sindresorhus'), //=> Promise
-	'https://ava.li',
+	getWebsiteFromUsername('sindresorhus'), //=> Promise
+	'https://avajs.dev',
 	'https://github.com'
 ];
 
-(async () => {
-	const mapper = async site => {
-		const {requestUrl} = await got.head(site);
-		return requestUrl;
-	};
+const mapper = async site => {
+	const {requestUrl} = await got.head(site);
+	return requestUrl;
+};
 
- 	const result = await pMap(sites, mapper, {concurrency: 2});
+const result = await pMap(sites, mapper, {concurrency: 2});
 
-	console.log(result);
-	//=> ['https://sindresorhus.com/', 'https://ava.li/', 'https://github.com/']
-})();
+console.log(result);
+//=> ['https://sindresorhus.com/', 'https://avajs.dev/', 'https://github.com/']
 ```
 
 ## API
@@ -43,9 +43,11 @@ Returns a `Promise` that is fulfilled when all promises in `input` and ones retu
 
 #### input
 
-Type: `Iterable<Promise | unknown>`
+Type: `AsyncIterable<Promise<unknown> | unknown> | Iterable<Promise<unknown> | unknown>`
 
-Iterated over concurrently in the `mapper` function.
+Synchronous or asynchronous iterable that is iterated over concurrently, calling the `mapper` function for each element. Each iterated item is `await`'d before the `mapper` is invoked so the iterable may return a `Promise` that resolves to an item.
+
+Asynchronous iterables (different from synchronous iterables that return `Promise` that resolves to an item) can be used when the next item may not be ready without waiting for an asynchronous process to complete and/or the end of the iterable may be reached after the asynchronous process completes. For example, reading from a remote queue when the queue has reached empty, or reading lines from a stream.
 
 #### mapper(element, index)
 
@@ -59,7 +61,7 @@ Type: `object`
 
 ##### concurrency
 
-Type: `number` (Integer)\
+Type: `number` *(Integer)*\
 Default: `Infinity`\
 Minimum: `1`
 
@@ -70,7 +72,65 @@ Number of concurrently pending promises returned by `mapper`.
 Type: `boolean`\
 Default: `true`
 
-When set to `false`, instead of stopping when a promise rejects, it will wait for all the promises to settle and then reject with an [aggregated error](https://github.com/sindresorhus/aggregate-error) containing all the errors from the rejected promises.
+When `true`, the first mapper rejection will be rejected back to the consumer.
+
+When `false`, instead of stopping when a promise rejects, it will wait for all the promises to settle and then reject with an [aggregated error](https://github.com/sindresorhus/aggregate-error) containing all the errors from the rejected promises.
+
+Caveat: When `true`, any already-started async mappers will continue to run until they resolve or reject. In the case of infinite concurrency with sync iterables, *all* mappers are invoked on startup and will continue after the first rejection. [Issue #51](https://github.com/sindresorhus/p-map/issues/51) can be implemented for abort control.
+
+##### signal
+
+Type: [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal)
+
+You can abort the promises using [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController).
+
+*Requires Node.js 16 or later.*
+
+```js
+import pMap from 'p-map';
+import delay from 'delay';
+
+const abortController = new AbortController();
+
+setTimeout(() => {
+	abortController.abort();
+}, 500);
+
+const mapper = async value => value;
+
+await pMap([delay(1000), delay(1000)], mapper, {signal: abortController.signal});
+// Throws AbortError (DOMException) after 500 ms.
+```
+
+### pMapSkip
+
+Return this value from a `mapper` function to skip including the value in the returned array.
+
+```js
+import pMap, {pMapSkip} from 'p-map';
+import got from 'got';
+
+const sites = [
+	getWebsiteFromUsername('sindresorhus'), //=> Promise
+	'https://avajs.dev',
+	'https://example.invalid',
+	'https://github.com'
+];
+
+const mapper = async site => {
+	try {
+		const {requestUrl} = await got.head(site);
+		return requestUrl;
+	} catch {
+		return pMapSkip;
+	}
+};
+
+const result = await pMap(sites, mapper, {concurrency: 2});
+
+console.log(result);
+//=> ['https://sindresorhus.com/', 'https://avajs.dev/', 'https://github.com/']
+```
 
 ## p-map for enterprise