@common.js/p-throttle 6.1.0 → 6.2.0

package/README.md

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

package/index.d.ts

@@ -44,7 +44,7 @@ export type Options = {
 	readonly strict?: boolean;
 
 	/**
-	Get notified when function calls are delayed due to exceeding the `limit` of allowed calls within the given `interval`.
+	Get notified when function calls are delayed due to exceeding the `limit` of allowed calls within the given `interval`. The delayed call arguments are passed to the `onDelay` callback.
 
  	Can be useful for monitoring the throttling efficiency.
 
@@ -55,25 +55,25 @@ export type Options = {
 	const throttle = pThrottle({
 		limit: 2,
 		interval: 1000,
-		onDelay: () => {
-			console.log('Reached interval limit, call is delayed');
+		onDelay: (a, b) => {
+			console.log(`Reached interval limit, call is delayed for ${a} ${b}`);
 		},
 	});
 
-	const throttled = throttle(() => {
- 		console.log('Executing...');
+	const throttled = throttle((a, b) => {
+ 		console.log(`Executing with ${a} ${b}...`);
    	});
 
-	await throttled();
-	await throttled();
-	await throttled();
-	//=> Executing...
-	//=> Executing...
-	//=> Reached interval limit, call is delayed
-	//=> Executing...
+	await throttled(1, 2);
+	await throttled(3, 4);
+	await throttled(5, 6);
+	//=> Executing with 1 2...
+	//=> Executing with 3 4...
+	//=> Reached interval limit, call is delayed for 5 6
+	//=> Executing with 5 6...
 	```
 	*/
-	readonly onDelay?: () => void;
+	readonly onDelay?: (...arguments_: readonly any[]) => void;
 };
 
 /**

package/index.js

@@ -16,6 +16,14 @@ _export(exports, {
         return pThrottle;
     }
 });
+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];
+    return arr2;
+}
+function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
 function _assertThisInitialized(self) {
     if (self === void 0) {
         throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
@@ -106,6 +114,12 @@ function _inherits(subClass, superClass) {
 function _isNativeFunction(fn) {
     return Function.toString.call(fn).indexOf("[native code]") !== -1;
 }
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 function _possibleConstructorReturn(self, call) {
     if (call && (_typeof(call) === "object" || typeof call === "function")) {
         return call;
@@ -119,10 +133,21 @@ function _setPrototypeOf(o, p) {
     };
     return _setPrototypeOf(o, p);
 }
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
 var _typeof = function(obj) {
     "@swc/helpers - typeof";
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
 function _wrapNativeSuper(Class) {
     var _cache = typeof Map === "function" ? new Map() : undefined;
     _wrapNativeSuper = function _wrapNativeSuper(Class) {
@@ -355,7 +380,7 @@ function pThrottle(param) {
                 if (delay > 0) {
                     timeoutId = setTimeout(execute, delay);
                     queue.set(timeoutId, reject);
-                    onDelay === null || onDelay === void 0 ? void 0 : onDelay();
+                    onDelay === null || onDelay === void 0 ? void 0 : onDelay.apply(void 0, _toConsumableArray(arguments_));
                 } else {
                     execute();
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@common.js/p-throttle",
-  "version": "6.1.0",
+  "version": "6.2.0",
   "description": "p-throttle package exported as CommonJS modules",
   "license": "MIT",
   "repository": "etienne-martin/common.js",