Limit function

index.d.ts

@@ -41,3 +41,21 @@ Run multiple promise-returning & async functions with limited concurrency.
 @returns A `limit` function.
 */
 export default function pLimit(concurrency: number): LimitFunction;
+
+export type Options = {
+	/**
+	Concurrency limit
+	*/
+	concurrency: number;
+};
+
+/**
+Return a function with limited concurrency.
+
+@param function_ - Promise-returning/async function.
+@return Function with limited concurrency.
+*/
+export function limitFunction<Arguments extends unknown[], ReturnType>(
+	function_: (...arguments_: Arguments) => PromiseLike<ReturnType> | ReturnType,
+	option: Options
+): (...arguments_: Arguments) => Promise<ReturnType>;

index.js

@@ -90,6 +90,13 @@ export default function pLimit(concurrency) {
 	return generator;
 }
 
+export function limitFunction(function_, option) {
+	const {concurrency} = option;
+	const limit = pLimit(concurrency);
+
+	return (...arguments_) => limit(() => function_(...arguments_));
+}
+
 function validateConcurrency(concurrency) {
 	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
 		throw new TypeError('Expected `concurrency` to be a number from 1 and up');

readme.md

@@ -77,6 +77,40 @@ Note: This does not cancel promises that are already running.
 
 Get or set the concurrency limit.
 
+### limitFunction(fn, options)
+
+Return a function with limited concurrency.
+
+Note: Unlike fucntion return by `pLimit`, the return by `limitFunction` is already limited, do not need call with `limit`.
+
+#### fn
+
+Type: `Function`
+
+Promise-returning/async function.
+
+#### options
+
+Type: `object`
+
+#### concurrency
+
+Type: `number`\
+Minimum: `1`
+
+```js
+import {limitFunction} from 'p-limit';
+
+const limitFunction_ = limitFunction(async () => {
+	return doSomething();
+}, {concurrency: 1});
+
+const input = Array.from({length: 10}, limitFunction_);
+
+// Only one promise is run at once
+await Promise.all(input);
+```
+
 ## FAQ
 
 ### How is this different from the [`p-queue`](https://github.com/sindresorhus/p-queue) package?

test.js

@@ -4,7 +4,7 @@ import delay from 'delay';
 import inRange from 'in-range';
 import timeSpan from 'time-span';
 import randomInt from 'random-int';
-import pLimit from './index.js';
+import pLimit, {limitFunction} from './index.js';
 
 test('concurrency: 1', async t => {
 	const input = [
@@ -217,3 +217,19 @@ test('change concurrency to bigger value', async t => {
 	await Promise.all(promises);
 	t.deepEqual(log, [1, 2, 3, 4, 4, 4, 4, 4, 4, 4]);
 });
+
+test('limit function with concurrency', async t => {
+	const concurrency = 5;
+	let running = 0;
+
+	const limitFunction_ = limitFunction(async () => {
+		running++;
+		t.true(running <= concurrency);
+		await delay(randomInt(30, 200));
+		running--;
+	}, {concurrency});
+
+	const input = Array.from({length: 100}, limitFunction_);
+
+	await Promise.all(input);
+});