Add index parameter to map() method

Fixes #96

Author: sindresorhus

index.d.ts

@@ -26,13 +26,15 @@ export type LimitFunction = {
 	/**
 	Process an array of inputs with limited concurrency.
 
+	The mapper function receives the item value and its index.
+
 	@param array - An array containing an argument for the given function.
-	@param function_ - Promise-returning/async function.
+	@param mapperFunction - Promise-returning/async function.
 	@returns A Promise that returns an array of results.
 	*/
 	map: <Input, ReturnType> (
 		array: Input[],
-		function_: (input: Input) => PromiseLike<ReturnType> | ReturnType
+		mapperFunction: (input: Input, index: number) => PromiseLike<ReturnType> | ReturnType
 	) => Promise<ReturnType[]>;
 
 	/**

index.js

@@ -83,7 +83,7 @@ export default function pLimit(concurrency) {
 		},
 		map: {
 			async value(array, function_) {
-				const promises = array.map(value => this(function_, value));
+				const promises = array.map((value, index) => this(function_, value, index));
 				return Promise.all(promises);
 			},
 		},

readme.md

@@ -57,11 +57,13 @@ Any arguments to pass through to `fn`.
 
 Support for passing arguments on to the `fn` is provided in order to be able to avoid creating unnecessary closures. You probably don't need this optimization unless you're pushing a *lot* of functions.
 
-### limit.map(array, fn)
+### limit.map(array, mapperFunction)
 
 Process an array of inputs with limited concurrency.
 
-Returns a promise equivalent to `Promise.all(array.map(item => limit(fn, item)))`.
+The mapper function receives the item value and its index.
+
+Returns a promise equivalent to `Promise.all(array.map((item, index) => limit(mapperFunction, item, index)))`.
 
 This is a convenience function for processing inputs that arrive in batches. For more complex use cases, see [p-map](https://github.com/sindresorhus/p-map).
 

test.js

@@ -175,6 +175,21 @@ test('map', async t => {
 	t.deepEqual(results, [2, 3, 4, 5, 6, 7, 8]);
 });
 
+test('map passes index and preserves order with concurrency', async t => {
+	const limit = pLimit(3);
+	const inputs = [10, 10, 10, 10, 10];
+
+	// eslint-disable-next-line unicorn/no-array-method-this-argument
+	const results = await limit.map(inputs, async (value, index) => {
+		// Simulate variable async duration per index to shuffle completion order
+		await delay((inputs.length - index) * 5);
+		return value + index;
+	});
+
+	// Results should be in input order and include index
+	t.deepEqual(results, [10, 11, 12, 13, 14]);
+});
+
 test('throws on invalid concurrency argument', t => {
 	t.throws(() => {
 		pLimit(0);