@common.js/p-throttle 6.1.0

package/README.md

@@ -0,0 +1,5 @@
+# @common.js/p-throttle
+
+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.

package/index.d.ts

@@ -0,0 +1,117 @@
+export class AbortError extends Error {
+	readonly name: 'AbortError';
+
+	private constructor();
+}
+
+type AnyFunction = (...arguments_: readonly any[]) => unknown;
+
+export type ThrottledFunction<F extends AnyFunction> = F & {
+	/**
+	Whether future function calls should be throttled or count towards throttling thresholds.
+
+	@default true
+	*/
+	isEnabled: boolean;
+
+	/**
+	The number of queued items waiting to be executed.
+	*/
+	readonly queueSize: number;
+
+	/**
+	Abort pending executions. All unresolved promises are rejected with a `pThrottle.AbortError` error.
+	*/
+	abort(): void;
+};
+
+export type Options = {
+	/**
+	The maximum number of calls within an `interval`.
+	*/
+	readonly limit: number;
+
+	/**
+	The timespan for `limit` in milliseconds.
+	*/
+	readonly interval: number;
+
+	/**
+	Use a strict, more resource intensive, throttling algorithm. The default algorithm uses a windowed approach that will work correctly in most cases, limiting the total number of calls at the specified limit per interval window. The strict algorithm throttles each call individually, ensuring the limit is not exceeded for any interval.
+
+	@default false
+	*/
+	readonly strict?: boolean;
+
+	/**
+	Get notified when function calls are delayed due to exceeding the `limit` of allowed calls within the given `interval`.
+
+ 	Can be useful for monitoring the throttling efficiency.
+
+	@example
+	```
+	import pThrottle from 'p-throttle';
+
+	const throttle = pThrottle({
+		limit: 2,
+		interval: 1000,
+		onDelay: () => {
+			console.log('Reached interval limit, call is delayed');
+		},
+	});
+
+	const throttled = throttle(() => {
+ 		console.log('Executing...');
+   	});
+
+	await throttled();
+	await throttled();
+	await throttled();
+	//=> Executing...
+	//=> Executing...
+	//=> Reached interval limit, call is delayed
+	//=> Executing...
+	```
+	*/
+	readonly onDelay?: () => void;
+};
+
+/**
+Throttle promise-returning/async/normal functions.
+
+It rate-limits function calls without discarding them, making it ideal for external API interactions where avoiding call loss is crucial.
+
+@returns A throttle function.
+
+Both the `limit` and `interval` options must be specified.
+
+@example
+```
+import pThrottle from 'p-throttle';
+
+const now = Date.now();
+
+const throttle = pThrottle({
+	limit: 2,
+	interval: 1000
+});
+
+const throttled = throttle(async index => {
+	const secDiff = ((Date.now() - now) / 1000).toFixed();
+	return `${index}: ${secDiff}s`;
+});
+
+for (let index = 1; index <= 6; index++) {
+	(async () => {
+		console.log(await throttled(index));
+	})();
+}
+//=> 1: 0s
+//=> 2: 0s
+//=> 3: 1s
+//=> 4: 1s
+//=> 5: 2s
+//=> 6: 2s
+```
+*/
+export default function pThrottle(options: Options): <F extends AnyFunction>(function_: F) => ThrottledFunction<F>;

package/index.js

@@ -0,0 +1,397 @@
+"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, {
+    AbortError: function() {
+        return AbortError;
+    },
+    default: function() {
+        return pThrottle;
+    }
+});
+function _assertThisInitialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Date.prototype.toString.call(Reflect.construct(Date, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _construct(Parent, args, Class) {
+    if (isNativeReflectConstruct()) {
+        _construct = Reflect.construct;
+    } else {
+        _construct = function _construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class) _setPrototypeOf(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+function _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _getPrototypeOf(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _setPrototypeOf(subClass, superClass);
+}
+function _isNativeFunction(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _possibleConstructorReturn(self, call) {
+    if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assertThisInitialized(self);
+}
+function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _setPrototypeOf(o, p);
+}
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+function _wrapNativeSuper(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrapNativeSuper = function _wrapNativeSuper(Class) {
+        if (Class === null || !_isNativeFunction(Class)) return Class;
+        if (typeof Class !== "function") {
+            throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class)) return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        return _setPrototypeOf(Wrapper, Class);
+    };
+    return _wrapNativeSuper(Class);
+}
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
+var __generator = (void 0) && (void 0).__generator || function(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+};
+var AbortError = /*#__PURE__*/ function(Error1) {
+    "use strict";
+    _inherits(AbortError, Error1);
+    var _super = _createSuper(AbortError);
+    function AbortError() {
+        _classCallCheck(this, AbortError);
+        var _this;
+        _this = _super.call(this, "Throttled function aborted");
+        _this.name = "AbortError";
+        return _this;
+    }
+    return AbortError;
+}(_wrapNativeSuper(Error));
+function pThrottle(param) {
+    var limit = param.limit, interval = param.interval, strict = param.strict, onDelay = param.onDelay;
+    var windowedDelay = function windowedDelay() {
+        var now = Date.now();
+        if (now - currentTick > interval) {
+            activeCount = 1;
+            currentTick = now;
+            return 0;
+        }
+        if (activeCount < limit) {
+            activeCount++;
+        } else {
+            currentTick += interval;
+            activeCount = 1;
+        }
+        return currentTick - now;
+    };
+    var strictDelay = function strictDelay() {
+        var now = Date.now();
+        // Clear the queue if there's a significant delay since the last execution
+        if (strictTicks.length > 0 && now - strictTicks.at(-1) > interval) {
+            strictTicks.length = 0;
+        }
+        // If the queue is not full, add the current time and execute immediately
+        if (strictTicks.length < limit) {
+            strictTicks.push(now);
+            return 0;
+        }
+        // Calculate the next execution time based on the first item in the queue
+        var nextExecutionTime = strictTicks[0] + interval;
+        // Shift the queue and add the new execution time
+        strictTicks.shift();
+        strictTicks.push(nextExecutionTime);
+        // Calculate the delay for the current execution
+        return Math.max(0, nextExecutionTime - now);
+    };
+    if (!Number.isFinite(limit)) {
+        throw new TypeError("Expected `limit` to be a finite number");
+    }
+    if (!Number.isFinite(interval)) {
+        throw new TypeError("Expected `interval` to be a finite number");
+    }
+    var queue = new Map();
+    var currentTick = 0;
+    var activeCount = 0;
+    var strictTicks = [];
+    var getDelay = strict ? strictDelay : windowedDelay;
+    return function(function_) {
+        var throttled = function() {
+            for(var _len = arguments.length, arguments_ = new Array(_len), _key = 0; _key < _len; _key++){
+                arguments_[_key] = arguments[_key];
+            }
+            var _this = this;
+            if (!throttled.isEnabled) {
+                var _this1 = this;
+                return _asyncToGenerator(function() {
+                    return __generator(this, function(_state) {
+                        return [
+                            2,
+                            function_.apply(_this1, arguments_)
+                        ];
+                    });
+                })();
+            }
+            var timeoutId;
+            return new Promise(function(resolve, reject) {
+                var execute = function() {
+                    resolve(function_.apply(_this, arguments_));
+                    queue.delete(timeoutId);
+                };
+                var delay = getDelay();
+                if (delay > 0) {
+                    timeoutId = setTimeout(execute, delay);
+                    queue.set(timeoutId, reject);
+                    onDelay === null || onDelay === void 0 ? void 0 : onDelay();
+                } else {
+                    execute();
+                }
+            });
+        };
+        throttled.abort = function() {
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = queue.keys()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var timeout = _step.value;
+                    clearTimeout(timeout);
+                    queue.get(timeout)(new AbortError());
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+            queue.clear();
+            strictTicks.splice(0, strictTicks.length);
+        };
+        throttled.isEnabled = true;
+        Object.defineProperty(throttled, "queueSize", {
+            get: function get() {
+                return queue.size;
+            }
+        });
+        return throttled;
+    };
+}

package/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@common.js/p-throttle",
+  "version": "6.1.0",
+  "description": "p-throttle package exported as CommonJS modules",
+  "license": "MIT",
+  "repository": "etienne-martin/common.js",
+  "funding": "https://github.com/sponsors/sindresorhus",
+  "type": "commonjs",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "xo && ava && tsd"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts"
+  ],
+  "devDependencies": {
+    "ava": "^5.3.1",
+    "delay": "^6.0.0",
+    "in-range": "^3.0.0",
+    "time-span": "^5.1.0",
+    "tsd": "^0.29.0",
+    "xo": "^0.56.0"
+  },
+  "ava": {
+    "serial": true
+  },
+  "homepage": "https://github.com/etienne-martin/common.js#readme",
+  "dependencies": {},
+  "types": "./index.d.ts",
+  "main": "./index.js"
+}