@common.js/p-limit 4.0.0 → 5.0.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@5.0.0](https://www.npmjs.com/package/p-limit/v/5.0.0) using https://github.com/etienne-martin/common.js.

package/async-hooks-stub.js

@@ -0,0 +1,63 @@
+"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;
+}();

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.
 	*/
@@ -26,10 +24,10 @@ export interface LimitFunction {
 	@returns The promise returned by calling `fn(...arguments)`.
 	*/
 	<Arguments extends unknown[], ReturnType>(
-		fn: (...arguments: Arguments) => PromiseLike<ReturnType> | ReturnType,
-		...arguments: Arguments
+		fn: (...arguments_: Arguments) => PromiseLike<ReturnType> | ReturnType,
+		...arguments_: Arguments
 	): Promise<ReturnType>;
-}
+};
 
 /**
 Run multiple promise-returning & async functions with limited concurrency.

package/index.js

@@ -9,6 +9,7 @@ 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];
@@ -176,7 +177,7 @@ function pLimit(concurrency) {
         }
     };
     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){
@@ -186,7 +187,7 @@ function pLimit(concurrency) {
                             return __generator(this, function(_state) {
                                 return [
                                     2,
-                                    fn.apply(void 0, _toConsumableArray(args))
+                                    function_.apply(void 0, _toConsumableArray(arguments_))
                                 ];
                             });
                         })();
@@ -223,12 +224,12 @@ 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.enqueue(_asyncHooks.AsyncResource.bind(run.bind(undefined, function_, resolve, arguments_)));
         _asyncToGenerator(function() {
             return __generator(this, function(_state) {
                 switch(_state.label){
@@ -253,12 +254,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,7 +274,7 @@ function pLimit(concurrency) {
             }
         },
         clearQueue: {
-            value: function() {
+            value: function value() {
                 queue.clear();
             }
         }

package/package.json

@@ -1,33 +1,41 @@
 {
   "name": "@common.js/p-limit",
-  "version": "4.0.0",
-  "description": "Run multiple promise-returning & async functions with limited concurrency",
+  "version": "5.0.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"
+    }
+  },
   "engines": {
-    "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+    "node": ">=18"
   },
   "scripts": {
     "test": "xo && ava && tsd"
   },
   "files": [
     "index.js",
-    "index.d.ts"
+    "index.d.ts",
+    "async-hooks-stub.js"
   ],
   "dependencies": {
     "@common.js/yocto-queue": "^1.0.0"
   },
   "devDependencies": {
-    "ava": "^3.15.0",
-    "delay": "^5.0.0",
+    "ava": "^5.3.1",
+    "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.29.0",
+    "xo": "^0.56.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>