@common.js/p-queue 7.3.0

package/dist/lower-bound.d.ts

@@ -0,0 +1 @@
+export default function lowerBound<T>(array: readonly T[], value: T, comparator: (a: T, b: T) => number): number;

package/dist/lower-bound.js

@@ -0,0 +1,27 @@
+// Port of lower_bound from https://en.cppreference.com/w/cpp/algorithm/lower_bound
+// Used to compute insertion index to keep queue sorted after insertion
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return lowerBound;
+    }
+});
+function lowerBound(array, value, comparator) {
+    var first = 0;
+    var count = array.length;
+    while(count > 0){
+        var step = Math.trunc(count / 2);
+        var it = first + step;
+        if (comparator(array[it], value) <= 0) {
+            first = ++it;
+            count -= step + 1;
+        } else {
+            count = step;
+        }
+    }
+    return first;
+}

package/dist/options.d.ts

@@ -0,0 +1,102 @@
+import { Queue, RunFunction } from './queue.js';
+interface TimeoutOptions {
+    /**
+    Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.
+    */
+    timeout?: number;
+    /**
+    Whether or not a timeout is considered an exception.
+
+    @default false
+    */
+    throwOnTimeout?: boolean;
+}
+export interface Options<QueueType extends Queue<RunFunction, QueueOptions>, QueueOptions extends QueueAddOptions> extends TimeoutOptions {
+    /**
+    Concurrency limit.
+
+    Minimum: `1`.
+
+    @default Infinity
+    */
+    readonly concurrency?: number;
+    /**
+    Whether queue tasks within concurrency limit, are auto-executed as soon as they're added.
+
+    @default true
+    */
+    readonly autoStart?: boolean;
+    /**
+    Class with a `enqueue` and `dequeue` method, and a `size` getter. See the [Custom QueueClass](https://github.com/sindresorhus/p-queue#custom-queueclass) section.
+    */
+    readonly queueClass?: new () => QueueType;
+    /**
+    The max number of runs in the given interval of time.
+
+    Minimum: `1`.
+
+    @default Infinity
+    */
+    readonly intervalCap?: number;
+    /**
+    The length of time in milliseconds before the interval count resets. Must be finite.
+
+    Minimum: `0`.
+
+    @default 0
+    */
+    readonly interval?: number;
+    /**
+    Whether the task must finish in the given interval or will be carried over into the next interval count.
+
+    @default false
+    */
+    readonly carryoverConcurrencyCount?: boolean;
+}
+export interface QueueAddOptions extends TaskOptions, TimeoutOptions {
+    /**
+    Priority of operation. Operations with greater priority will be scheduled first.
+
+    @default 0
+    */
+    readonly priority?: number;
+}
+export interface TaskOptions {
+    /**
+    [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) for cancellation of the operation. When aborted, it will be removed from the queue and the `queue.add()` call will reject with an `AbortError`. If the operation is already running, the signal will need to be handled by the operation itself.
+
+    @example
+    ```
+    import PQueue, {AbortError} from 'p-queue';
+    import got, {CancelError} from 'got';
+
+    const queue = new PQueue();
+
+    const controller = new AbortController();
+
+    try {
+        await queue.add(({signal}) => {
+            const request = got('https://sindresorhus.com');
+
+            signal.addEventListener('abort', () => {
+                request.cancel();
+            });
+
+            try {
+                return await request;
+            } catch (error) {
+                if (!(error instanceof CancelError)) {
+                    throw error;
+                }
+            }
+        }, {signal: controller.signal});
+    } catch (error) {
+        if (!(error instanceof AbortError)) {
+            throw error;
+        }
+    }
+    ```
+    */
+    readonly signal?: AbortSignal;
+}
+export {};

package/dist/options.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/dist/priority-queue.d.ts

@@ -0,0 +1,12 @@
+import { Queue, RunFunction } from './queue.js';
+import { QueueAddOptions } from './options.js';
+export interface PriorityQueueOptions extends QueueAddOptions {
+    priority?: number;
+}
+export default class PriorityQueue implements Queue<RunFunction, PriorityQueueOptions> {
+    #private;
+    enqueue(run: RunFunction, options?: Partial<PriorityQueueOptions>): void;
+    dequeue(): RunFunction | undefined;
+    filter(options: Readonly<Partial<PriorityQueueOptions>>): RunFunction[];
+    get size(): number;
+}

package/dist/priority-queue.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return PriorityQueue;
+    }
+});
+var _lowerBoundJs = /*#__PURE__*/ _interopRequireDefault(require("./lower-bound.js"));
+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;
+}
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+var __classPrivateFieldGet = (void 0) && (void 0).__classPrivateFieldGet || function(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _PriorityQueue_queue;
+var PriorityQueue = /*#__PURE__*/ function() {
+    "use strict";
+    function PriorityQueue() {
+        _classCallCheck(this, PriorityQueue);
+        _PriorityQueue_queue.set(this, []);
+    }
+    _createClass(PriorityQueue, [
+        {
+            key: "enqueue",
+            value: function enqueue(run, options) {
+                options = _objectSpread({
+                    priority: 0
+                }, options);
+                var element = {
+                    priority: options.priority,
+                    run: run
+                };
+                if (this.size && __classPrivateFieldGet(this, _PriorityQueue_queue, "f")[this.size - 1].priority >= options.priority) {
+                    __classPrivateFieldGet(this, _PriorityQueue_queue, "f").push(element);
+                    return;
+                }
+                var index = (0, _lowerBoundJs.default)(__classPrivateFieldGet(this, _PriorityQueue_queue, "f"), element, function(a, b) {
+                    return b.priority - a.priority;
+                });
+                __classPrivateFieldGet(this, _PriorityQueue_queue, "f").splice(index, 0, element);
+            }
+        },
+        {
+            key: "dequeue",
+            value: function dequeue() {
+                var item = __classPrivateFieldGet(this, _PriorityQueue_queue, "f").shift();
+                return item === null || item === void 0 ? void 0 : item.run;
+            }
+        },
+        {
+            key: "filter",
+            value: function filter(options) {
+                return __classPrivateFieldGet(this, _PriorityQueue_queue, "f").filter(function(element) {
+                    return element.priority === options.priority;
+                }).map(function(element) {
+                    return element.run;
+                });
+            }
+        },
+        {
+            key: "size",
+            get: function get() {
+                return __classPrivateFieldGet(this, _PriorityQueue_queue, "f").length;
+            }
+        }
+    ]);
+    return PriorityQueue;
+}();
+_PriorityQueue_queue = new WeakMap();

package/dist/queue.d.ts

@@ -0,0 +1,7 @@
+export declare type RunFunction = () => Promise<unknown>;
+export interface Queue<Element, Options> {
+    size: number;
+    filter: (options: Partial<Options>) => Element[];
+    dequeue: () => Element | undefined;
+    enqueue: (run: Element, options?: Partial<Options>) => void;
+}

package/dist/queue.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

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,68 @@
+{
+  "name": "@common.js/p-queue",
+  "version": "7.3.0",
+  "description": "Promise queue with concurrency control",
+  "license": "MIT",
+  "repository": "etienne-martin/common.js",
+  "funding": "https://github.com/sponsors/sindresorhus",
+  "type": "commonjs",
+  "engines": {
+    "node": ">=12"
+  },
+  "scripts": {
+    "build": "del dist && tsc",
+    "test": "xo && npm run build && nyc ava",
+    "bench": "node --loader=ts-node/esm bench.ts"
+  },
+  "files": [
+    "dist"
+  ],
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "eventemitter3": "^4.0.7",
+    "@common.js/p-timeout": "^5.0.2"
+  },
+  "devDependencies": {
+    "@sindresorhus/tsconfig": "^2.0.0",
+    "@types/benchmark": "^2.1.1",
+    "@types/node": "^17.0.13",
+    "ava": "^4.0.1",
+    "benchmark": "^2.1.4",
+    "codecov": "^3.8.3",
+    "del-cli": "^4.0.1",
+    "delay": "^5.0.0",
+    "in-range": "^3.0.0",
+    "nyc": "^15.1.0",
+    "p-defer": "^4.0.0",
+    "random-int": "^3.0.0",
+    "time-span": "^5.0.0",
+    "ts-node": "^10.4.0",
+    "typescript": "^4.5.5",
+    "xo": "^0.44.0"
+  },
+  "ava": {
+    "files": [
+      "test/**"
+    ],
+    "extensions": {
+      "ts": "module"
+    },
+    "nodeArguments": [
+      "--loader=ts-node/esm"
+    ]
+  },
+  "xo": {
+    "rules": {
+      "@typescript-eslint/member-ordering": "off",
+      "@typescript-eslint/no-floating-promises": "off",
+      "@typescript-eslint/no-invalid-void-type": "off"
+    }
+  },
+  "nyc": {
+    "extension": [
+      ".ts"
+    ]
+  },
+  "homepage": "https://github.com/etienne-martin/common.js#readme",
+  "main": "./dist/index.js"
+}