@common.js/p-limit 5.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@5.0.0](https://www.npmjs.com/package/p-limit/v/5.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

@@ -9,6 +9,11 @@ export type LimitFunction = {
 	*/
 	readonly pendingCount: number;
 
+	/**
+	Get or set the concurrency limit.
+	*/
+	concurrency: number;
+
 	/**
 	Discard pending promises that are waiting to run.
 
@@ -24,7 +29,7 @@ export type LimitFunction = {
 	@returns The promise returned by calling `fn(...arguments)`.
 	*/
 	<Arguments extends unknown[], ReturnType>(
-		fn: (...arguments_: Arguments) => PromiseLike<ReturnType> | ReturnType,
+		function_: (...arguments_: Arguments) => PromiseLike<ReturnType> | ReturnType,
 		...arguments_: Arguments
 	): Promise<ReturnType>;
 };

package/index.js

@@ -9,7 +9,6 @@ Object.defineProperty(exports, "default", {
     }
 });
 var _yoctoQueue = /*#__PURE__*/ _interopRequireDefault(require("yocto-queue"));
-var _asyncHooks = require("#async_hooks");
 function _arrayLikeToArray(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
@@ -165,24 +164,26 @@ 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(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 [
@@ -229,14 +230,18 @@ function pLimit(concurrency) {
         };
     }();
     var enqueue = function(function_, resolve, arguments_) {
-        queue.enqueue(_asyncHooks.AsyncResource.bind(run.bind(undefined, 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,
@@ -244,8 +249,8 @@ function pLimit(concurrency) {
                         ];
                     case 1:
                         _state.sent();
-                        if (activeCount < concurrency && queue.size > 0) {
-                            queue.dequeue()();
+                        if (activeCount < concurrency) {
+                            resumeNext();
                         }
                         return [
                             2
@@ -277,7 +282,27 @@ function pLimit(concurrency) {
             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,17 +1,12 @@
 {
   "name": "@common.js/p-limit",
-  "version": "5.0.0",
+  "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",
-  "imports": {
-    "#async_hooks": {
-      "node": "async_hooks",
-      "default": "./async-hooks-stub.js"
-    }
-  },
+  "sideEffects": false,
   "engines": {
     "node": ">=18"
   },
@@ -20,20 +15,19 @@
   },
   "files": [
     "index.js",
-    "index.d.ts",
-    "async-hooks-stub.js"
+    "index.d.ts"
   ],
   "dependencies": {
-    "@common.js/yocto-queue": "^1.0.0"
+    "@common.js/yocto-queue": "^1.1.1"
   },
   "devDependencies": {
-    "ava": "^5.3.1",
+    "ava": "^6.1.3",
     "delay": "^6.0.0",
     "in-range": "^3.0.0",
     "random-int": "^3.0.0",
     "time-span": "^5.1.0",
-    "tsd": "^0.29.0",
-    "xo": "^0.56.0"
+    "tsd": "^0.31.1",
+    "xo": "^0.58.0"
   },
   "homepage": "https://github.com/etienne-martin/common.js#readme",
   "types": "./index.d.ts",

package/async-hooks-stub.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    AsyncResource: function() {
-        return AsyncResource;
-    },
-    AsyncLocalStorage: function() {
-        return AsyncLocalStorage;
-    }
-});
-function _classCallCheck(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function _defineProperties(target, props) {
-    for(var i = 0; i < props.length; i++){
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-    }
-}
-function _createClass(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
-}
-var AsyncResource = {
-    bind: function bind(fn, _type, thisArg) {
-        return fn.bind(thisArg);
-    }
-};
-var AsyncLocalStorage = /*#__PURE__*/ function() {
-    "use strict";
-    function AsyncLocalStorage() {
-        _classCallCheck(this, AsyncLocalStorage);
-    }
-    _createClass(AsyncLocalStorage, [
-        {
-            key: "getStore",
-            value: function getStore() {
-                return undefined;
-            }
-        },
-        {
-            key: "run",
-            value: function run(_store, callback) {
-                return callback();
-            }
-        }
-    ]);
-    return AsyncLocalStorage;
-}();