@common.js/p-limit 4.0.0 → 6.1.0

package/README.md

@@ -2,4 +2,4 @@
 
 The [p-limit](https://www.npmjs.com/package/p-limit) package exported as CommonJS modules.
 
-Exported from [p-limit@4.0.0](https://www.npmjs.com/package/p-limit/v/4.0.0) using https://github.com/etienne-martin/common.js.
+Exported from [p-limit@6.1.0](https://www.npmjs.com/package/p-limit/v/6.1.0) using https://github.com/etienne-martin/common.js.

package/index.d.ts

@@ -1,6 +1,4 @@
-/* eslint-disable @typescript-eslint/member-ordering */
-
-export interface LimitFunction {
+export type LimitFunction = {
 	/**
 	The number of promises that are currently running.
 	*/
@@ -11,6 +9,11 @@ export interface LimitFunction {
 	*/
 	readonly pendingCount: number;
 
+	/**
+	Get or set the concurrency limit.
+	*/
+	concurrency: number;
+
 	/**
 	Discard pending promises that are waiting to run.
 
@@ -26,10 +29,10 @@ export interface LimitFunction {
 	@returns The promise returned by calling `fn(...arguments)`.
 	*/
 	<Arguments extends unknown[], ReturnType>(
-		fn: (...arguments: Arguments) => PromiseLike<ReturnType> | ReturnType,
-		...arguments: Arguments
+		function_: (...arguments_: Arguments) => PromiseLike<ReturnType> | ReturnType,
+		...arguments_: Arguments
 	): Promise<ReturnType>;
-}
+};
 
 /**
 Run multiple promise-returning & async functions with limited concurrency.

package/index.js

@@ -164,29 +164,31 @@ var __generator = (void 0) && (void 0).__generator || function(thisArg, body) {
     }
 };
 function pLimit(concurrency) {
-    if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
-        throw new TypeError("Expected `concurrency` to be a number from 1 and up");
-    }
+    validateConcurrency(concurrency);
     var queue = new _yoctoQueue.default();
     var activeCount = 0;
-    var next = function() {
-        activeCount--;
-        if (queue.size > 0) {
+    var resumeNext = function() {
+        if (activeCount < concurrency && queue.size > 0) {
             queue.dequeue()();
+            // Since `pendingCount` has been decreased by one, increase `activeCount` by one.
+            activeCount++;
         }
     };
+    var next = function() {
+        activeCount--;
+        resumeNext();
+    };
     var run = function() {
-        var _ref = _asyncToGenerator(function(fn, resolve, args) {
+        var _ref = _asyncToGenerator(function(function_, resolve, arguments_) {
             var result, e;
             return __generator(this, function(_state) {
                 switch(_state.label){
                     case 0:
-                        activeCount++;
                         result = _asyncToGenerator(function() {
                             return __generator(this, function(_state) {
                                 return [
                                     2,
-                                    fn.apply(void 0, _toConsumableArray(args))
+                                    function_.apply(void 0, _toConsumableArray(arguments_))
                                 ];
                             });
                         })();
@@ -223,19 +225,23 @@ function pLimit(concurrency) {
                 }
             });
         });
-        return function run(fn, resolve, args) {
+        return function run(function_, resolve, arguments_) {
             return _ref.apply(this, arguments);
         };
     }();
-    var enqueue = function(fn, resolve, args) {
-        queue.enqueue(run.bind(undefined, fn, resolve, args));
+    var enqueue = function(function_, resolve, arguments_) {
+        // Queue `internalResolve` instead of the `run` function
+        // to preserve asynchronous context.
+        new Promise(function(internalResolve) {
+            queue.enqueue(internalResolve);
+        }).then(run.bind(undefined, function_, resolve, arguments_));
         _asyncToGenerator(function() {
             return __generator(this, function(_state) {
                 switch(_state.label){
                     case 0:
                         // This function needs to wait until the next microtask before comparing
                         // `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
-                        // when the run function is dequeued and called. The comparison in the if-statement
+                        // after the `internalResolve` function is dequeued and called. The comparison in the if-statement
                         // needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
                         return [
                             4,
@@ -243,8 +249,8 @@ function pLimit(concurrency) {
                         ];
                     case 1:
                         _state.sent();
-                        if (activeCount < concurrency && queue.size > 0) {
-                            queue.dequeue()();
+                        if (activeCount < concurrency) {
+                            resumeNext();
                         }
                         return [
                             2
@@ -253,12 +259,12 @@ function pLimit(concurrency) {
             });
         })();
     };
-    var generator = function(fn) {
-        for(var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
-            args[_key - 1] = arguments[_key];
+    var generator = function(function_) {
+        for(var _len = arguments.length, arguments_ = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+            arguments_[_key - 1] = arguments[_key];
         }
         return new Promise(function(resolve) {
-            enqueue(fn, resolve, args);
+            enqueue(function_, resolve, arguments_);
         });
     };
     Object.defineProperties(generator, {
@@ -273,10 +279,30 @@ function pLimit(concurrency) {
             }
         },
         clearQueue: {
-            value: function() {
+            value: function value() {
                 queue.clear();
             }
+        },
+        concurrency: {
+            get: function() {
+                return concurrency;
+            },
+            set: function set(newConcurrency) {
+                validateConcurrency(newConcurrency);
+                concurrency = newConcurrency;
+                queueMicrotask(function() {
+                    // eslint-disable-next-line no-unmodified-loop-condition
+                    while(activeCount < concurrency && queue.size > 0){
+                        resumeNext();
+                    }
+                });
+            }
         }
     });
     return generator;
 }
+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");
+    }
+}

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@common.js/p-limit",
-  "version": "4.0.0",
-  "description": "Run multiple promise-returning & async functions with limited concurrency",
+  "version": "6.1.0",
+  "description": "p-limit package exported as CommonJS modules",
   "license": "MIT",
   "repository": "etienne-martin/common.js",
   "funding": "https://github.com/sponsors/sindresorhus",
   "type": "commonjs",
+  "sideEffects": false,
   "engines": {
-    "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+    "node": ">=18"
   },
   "scripts": {
     "test": "xo && ava && tsd"
@@ -17,17 +18,18 @@
     "index.d.ts"
   ],
   "dependencies": {
-    "@common.js/yocto-queue": "^1.0.0"
+    "@common.js/yocto-queue": "^1.1.1"
   },
   "devDependencies": {
-    "ava": "^3.15.0",
-    "delay": "^5.0.0",
+    "ava": "^6.1.3",
+    "delay": "^6.0.0",
     "in-range": "^3.0.0",
     "random-int": "^3.0.0",
-    "time-span": "^5.0.0",
-    "tsd": "^0.17.0",
-    "xo": "^0.44.0"
+    "time-span": "^5.1.0",
+    "tsd": "^0.31.1",
+    "xo": "^0.58.0"
   },
   "homepage": "https://github.com/etienne-martin/common.js#readme",
+  "types": "./index.d.ts",
   "main": "./index.js"
 }

package/readme.md

@@ -1,99 +0,0 @@
-# p-limit
-
-> Run multiple promise-returning & async functions with limited concurrency
-
-## Install
-
-```
-$ npm install p-limit
-```
-
-## Usage
-
-```js
-import pLimit from 'p-limit';
-
-const limit = pLimit(1);
-
-const input = [
-	limit(() => fetchSomething('foo')),
-	limit(() => fetchSomething('bar')),
-	limit(() => doSomething())
-];
-
-// Only one promise is run at once
-const result = await Promise.all(input);
-console.log(result);
-```
-
-## API
-
-### pLimit(concurrency)
-
-Returns a `limit` function.
-
-#### concurrency
-
-Type: `number`\
-Minimum: `1`\
-Default: `Infinity`
-
-Concurrency limit.
-
-### limit(fn, ...args)
-
-Returns the promise returned by calling `fn(...args)`.
-
-#### fn
-
-Type: `Function`
-
-Promise-returning/async function.
-
-#### args
-
-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.activeCount
-
-The number of promises that are currently running.
-
-### limit.pendingCount
-
-The number of promises that are waiting to run (i.e. their internal `fn` was not called yet).
-
-### limit.clearQueue()
-
-Discard pending promises that are waiting to run.
-
-This might be useful if you want to teardown the queue at the end of your program's lifecycle or discard any function calls referencing an intermediary state of your app.
-
-Note: This does not cancel promises that are already running.
-
-## FAQ
-
-### How is this different from the [`p-queue`](https://github.com/sindresorhus/p-queue) package?
-
-This package is only about limiting the number of concurrent executions, while `p-queue` is a fully featured queue implementation with lots of different options, introspection, and ability to pause the queue.
-
-## Related
-
-- [p-queue](https://github.com/sindresorhus/p-queue) - Promise queue with concurrency control
-- [p-throttle](https://github.com/sindresorhus/p-throttle) - Throttle promise-returning & async functions
-- [p-debounce](https://github.com/sindresorhus/p-debounce) - Debounce promise-returning & async functions
-- [p-all](https://github.com/sindresorhus/p-all) - Run promise-returning & async functions concurrently with optional limited concurrency
-- [More…](https://github.com/sindresorhus/promise-fun)
-
----
-
-<div align="center">
-	<b>
-		<a href="https://tidelift.com/subscription/pkg/npm-p-limit?utm_source=npm-p-limit&utm_medium=referral&utm_campaign=readme">Get professional support for this package with a Tidelift subscription</a>
-	</b>
-	<br>
-	<sub>
-		Tidelift helps make open source sustainable for maintainers while giving companies<br>assurances about security, maintenance, and licensing for their dependencies.
-	</sub>
-</div>