@esportsplus/typescript 0.6.7 → 0.8.1

package/node_modules/plimit-lit/dist/plimit-lit.cjs

@@ -0,0 +1,91 @@
+var queueLit = require('queue-lit');
+
+/**
+ * pLimit creates a "limiter" function that can be used to enqueue
+ * promise returning functions with limited concurrency.
+ * @param {number} concurrency
+ */
+function pLimit(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
+    throw new TypeError('Expected `concurrency` to be a number greater than 1');
+  }
+  const queue = new queueLit.Queue();
+  let activeCount = 0;
+
+  /**
+   * next updates the activeCount and executes the next queued item.
+   */
+  const next = () => {
+    activeCount--;
+    if (queue.size > 0) {
+      queue.pop()();
+    }
+  };
+
+  /**
+   * run executes a given `fn` passing `args`. Inside the `run` closure any
+   * thrown errors/rejections are swallowed, but by resolving the `fn` result
+   * immediatly we surface any rejections/errors to a parent function.
+   * @param {Function} fn
+   * @param {Promise.resolve} resolve
+   * @param {*} args
+   */
+  const run = async (fn, resolve, args) => {
+    activeCount++;
+    const result = (async () => fn(...args))();
+    resolve(result);
+    try {
+      await result;
+    } catch {}
+    next();
+  };
+
+  /**
+   * enqueue enqueues a given `fn` to be executed while limiting concurrency.
+   * @param {Function} fn
+   * @param {Promise.resolve} resolve
+   * @param {*} args
+   */
+  const enqueue = (fn, resolve, args) => {
+    queue.push(run.bind(null, fn, resolve, args));
+    (async () => {
+      // NOTE(joel): This function needs to wait until the next microtask
+      // before comparing `activeCount` to `concurrency` because `activeCount`
+      // is updated asynchronously when the run function is popped and
+      // called.
+      await Promise.resolve();
+      if (activeCount < concurrency && queue.size > 0) {
+        queue.pop()();
+      }
+    })();
+  };
+
+  /**
+   * generator defines the public api of `pLimit` and allows enqueueing promise
+   * returning functions while limiting their concurrency.
+   * @param {(...args: Arguments) => PromiseLike<RType> | RType} fn
+   * @param  {Arguments} args
+   * @returns {Promise<RType>}
+   * @template {unknown[]} Arguments
+   * @template RType
+   */
+  const generator = (fn, ...args) => new Promise(resolve => {
+    enqueue(fn, resolve, args);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value: () => {
+        queue.clear();
+      }
+    }
+  });
+  return generator;
+}
+
+exports.pLimit = pLimit;

package/node_modules/plimit-lit/dist/plimit-lit.modern.js

@@ -0,0 +1,91 @@
+import { Queue } from 'queue-lit';
+
+/**
+ * pLimit creates a "limiter" function that can be used to enqueue
+ * promise returning functions with limited concurrency.
+ * @param {number} concurrency
+ */
+function pLimit(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
+    throw new TypeError('Expected `concurrency` to be a number greater than 1');
+  }
+  const queue = new Queue();
+  let activeCount = 0;
+
+  /**
+   * next updates the activeCount and executes the next queued item.
+   */
+  const next = () => {
+    activeCount--;
+    if (queue.size > 0) {
+      queue.pop()();
+    }
+  };
+
+  /**
+   * run executes a given `fn` passing `args`. Inside the `run` closure any
+   * thrown errors/rejections are swallowed, but by resolving the `fn` result
+   * immediatly we surface any rejections/errors to a parent function.
+   * @param {Function} fn
+   * @param {Promise.resolve} resolve
+   * @param {*} args
+   */
+  const run = async (fn, resolve, args) => {
+    activeCount++;
+    const result = (async () => fn(...args))();
+    resolve(result);
+    try {
+      await result;
+    } catch {}
+    next();
+  };
+
+  /**
+   * enqueue enqueues a given `fn` to be executed while limiting concurrency.
+   * @param {Function} fn
+   * @param {Promise.resolve} resolve
+   * @param {*} args
+   */
+  const enqueue = (fn, resolve, args) => {
+    queue.push(run.bind(null, fn, resolve, args));
+    (async () => {
+      // NOTE(joel): This function needs to wait until the next microtask
+      // before comparing `activeCount` to `concurrency` because `activeCount`
+      // is updated asynchronously when the run function is popped and
+      // called.
+      await Promise.resolve();
+      if (activeCount < concurrency && queue.size > 0) {
+        queue.pop()();
+      }
+    })();
+  };
+
+  /**
+   * generator defines the public api of `pLimit` and allows enqueueing promise
+   * returning functions while limiting their concurrency.
+   * @param {(...args: Arguments) => PromiseLike<RType> | RType} fn
+   * @param  {Arguments} args
+   * @returns {Promise<RType>}
+   * @template {unknown[]} Arguments
+   * @template RType
+   */
+  const generator = (fn, ...args) => new Promise(resolve => {
+    enqueue(fn, resolve, args);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value: () => {
+        queue.clear();
+      }
+    }
+  });
+  return generator;
+}
+
+export { pLimit };

package/node_modules/plimit-lit/dist/plimit-lit.module.js

@@ -0,0 +1,91 @@
+import { Queue } from 'queue-lit';
+
+/**
+ * pLimit creates a "limiter" function that can be used to enqueue
+ * promise returning functions with limited concurrency.
+ * @param {number} concurrency
+ */
+function pLimit(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
+    throw new TypeError('Expected `concurrency` to be a number greater than 1');
+  }
+  const queue = new Queue();
+  let activeCount = 0;
+
+  /**
+   * next updates the activeCount and executes the next queued item.
+   */
+  const next = () => {
+    activeCount--;
+    if (queue.size > 0) {
+      queue.pop()();
+    }
+  };
+
+  /**
+   * run executes a given `fn` passing `args`. Inside the `run` closure any
+   * thrown errors/rejections are swallowed, but by resolving the `fn` result
+   * immediatly we surface any rejections/errors to a parent function.
+   * @param {Function} fn
+   * @param {Promise.resolve} resolve
+   * @param {*} args
+   */
+  const run = async (fn, resolve, args) => {
+    activeCount++;
+    const result = (async () => fn(...args))();
+    resolve(result);
+    try {
+      await result;
+    } catch {}
+    next();
+  };
+
+  /**
+   * enqueue enqueues a given `fn` to be executed while limiting concurrency.
+   * @param {Function} fn
+   * @param {Promise.resolve} resolve
+   * @param {*} args
+   */
+  const enqueue = (fn, resolve, args) => {
+    queue.push(run.bind(null, fn, resolve, args));
+    (async () => {
+      // NOTE(joel): This function needs to wait until the next microtask
+      // before comparing `activeCount` to `concurrency` because `activeCount`
+      // is updated asynchronously when the run function is popped and
+      // called.
+      await Promise.resolve();
+      if (activeCount < concurrency && queue.size > 0) {
+        queue.pop()();
+      }
+    })();
+  };
+
+  /**
+   * generator defines the public api of `pLimit` and allows enqueueing promise
+   * returning functions while limiting their concurrency.
+   * @param {(...args: Arguments) => PromiseLike<RType> | RType} fn
+   * @param  {Arguments} args
+   * @returns {Promise<RType>}
+   * @template {unknown[]} Arguments
+   * @template RType
+   */
+  const generator = (fn, ...args) => new Promise(resolve => {
+    enqueue(fn, resolve, args);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value: () => {
+        queue.clear();
+      }
+    }
+  });
+  return generator;
+}
+
+export { pLimit };

package/node_modules/plimit-lit/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "plimit-lit",
+  "description": "This package is a helper to run multiple promise-returning & async functions with limited concurrency.",
+  "version": "1.6.1",
+  "author": "Joel Voß <mail@joelvoss.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/joelvoss/plimit-lit",
+  "bugs": {
+    "url": "https://github.com/joelvoss/plimit-lit/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/joelvoss/plimit-lit.git"
+  },
+  "engines": {
+    "node": ">=12"
+  },
+  "type": "module",
+  "source": "src/index.js",
+  "main": "dist/plimit-lit.cjs",
+  "module": "dist/plimit-lit.module.js",
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "require": "./dist/plimit-lit.cjs",
+    "import": "./dist/plimit-lit.modern.js"
+  },
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "./Taskfile.sh",
+    "test": "./Taskfile.sh test",
+    "prepublishOnly": "./Taskfile.sh build"
+  },
+  "dependencies": {
+    "queue-lit": "^1.5.1"
+  },
+  "devDependencies": {
+    "@jvdx/core": "^3.6.0"
+  },
+  "prettier": "@jvdx/prettier-config",
+  "prettierIgnore": [
+    "tests/",
+    "dist/"
+  ],
+  "eslintConfig": {
+    "extends": "@jvdx/eslint-config"
+  },
+  "eslintIgnore": [
+    "tests/",
+    "dist/"
+  ]
+}

package/node_modules/queue-lit/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Joel Voss
+
+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/node_modules/queue-lit/README.md

@@ -0,0 +1,93 @@
+# queue-lit
+
+This package is a tiny queue data structure in case you `Array#push()` or
+`Array#shift()` on large arrays very often.  
+`Array#shift()` has linear time complexity `O(n)` while `Queue#push()` has
+constant time complexity `O(1)`.
+
+## Installation
+
+```bash
+$ npm i queue-lit
+# or
+$ yarn add queue-lit
+```
+
+## Usage
+
+```js
+import { Queue } from 'queue-lit';
+
+const queue = new Queue();
+
+queue.push('Hello');
+queue.push('World');
+
+console.log(queue.size);
+// => 2
+
+console.log(...queue);
+// => 'Hello World'
+
+console.log(queue.pop());
+//=> 'Hello'
+
+console.log(queue.pop());
+//=> 'World'
+```
+
+## API
+
+### `queue = new Queue()`
+
+The instance is an [`Iterable`], which means you can iterate over the queue
+front to back with a `for...of` loop, or use spreading to convert the queue to
+an array.
+
+#### `.push(value)`
+
+Adds one element to the end of the queue and returns the new length of
+the queue.  
+This method changes the size of the queue.
+
+#### `.pop()`
+
+Pop removes the last element from the queue and returns that element.  
+This method changes the size of the queue.
+
+Returns `undefined` if the queue is empty.
+
+#### `.clear()`
+
+Clears the queue and removes all elements.  
+This method changes the size of the queue.
+
+#### `.size`
+
+Static method that returns the size of the queue.
+
+
+## Development
+
+(1) Install dependencies
+
+```bash
+$ npm i
+# or
+$ yarn
+```
+
+(2) Run initial validation
+
+```bash
+$ ./Taskfile.sh validate
+```
+
+(3) Start developing. See [`./Taskfile.sh`](./Taskfile.sh) for more tasks to
+    help you develop.
+
+---
+
+_This project was set up by @jvdx/core_
+
+[`Iterable`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols

package/node_modules/queue-lit/dist/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Queue
+ * @implements Iterable<Value>
+ * @template Value
+ */
+export class Queue<Value> implements Iterable<Value> {
+    /**
+     * clear
+     * @returns {void}
+     */
+    clear(): void;
+    /**
+     * push
+     * @param {Value} value
+     * @returns {number}
+     */
+    push(value: Value): number;
+    /**
+     * pop
+     * @returns {Value | undefined}
+     */
+    pop(): Value | undefined;
+    /**
+     * size
+     * @returns {number}
+     */
+    get size(): number;
+    /**
+     * Iterator
+     * @returns {IterableIterator<Value>}
+     */
+    [Symbol.iterator](): IterableIterator<Value>;
+    #private;
+}

package/node_modules/queue-lit/dist/queue-lit.cjs

@@ -0,0 +1,110 @@
+var id = 0;
+function _classPrivateFieldLooseKey(name) {
+  return "__private_" + id++ + "_" + name;
+}
+function _classPrivateFieldLooseBase(receiver, privateKey) {
+  if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
+    throw new TypeError("attempted to use private field on non-instance");
+  }
+  return receiver;
+}
+
+let _Symbol$iterator;
+class Node {
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Queue
+ * @implements Iterable<Value>
+ * @template Value
+ */
+var _head = /*#__PURE__*/_classPrivateFieldLooseKey("head");
+var _tail = /*#__PURE__*/_classPrivateFieldLooseKey("tail");
+var _size = /*#__PURE__*/_classPrivateFieldLooseKey("size");
+_Symbol$iterator = Symbol.iterator;
+class Queue {
+  constructor() {
+    Object.defineProperty(this, _head, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _tail, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _size, {
+      writable: true,
+      value: void 0
+    });
+    this.clear();
+  }
+
+  /**
+   * clear
+   * @returns {void}
+   */
+  clear() {
+    _classPrivateFieldLooseBase(this, _head)[_head] = undefined;
+    _classPrivateFieldLooseBase(this, _tail)[_tail] = undefined;
+    _classPrivateFieldLooseBase(this, _size)[_size] = 0;
+  }
+
+  /**
+   * push
+   * @param {Value} value
+   * @returns {number}
+   */
+  push(value) {
+    const node = new Node(value);
+    if (_classPrivateFieldLooseBase(this, _head)[_head]) {
+      _classPrivateFieldLooseBase(this, _tail)[_tail].next = node;
+      _classPrivateFieldLooseBase(this, _tail)[_tail] = node;
+    } else {
+      _classPrivateFieldLooseBase(this, _head)[_head] = node;
+      _classPrivateFieldLooseBase(this, _tail)[_tail] = node;
+    }
+    _classPrivateFieldLooseBase(this, _size)[_size]++;
+    return _classPrivateFieldLooseBase(this, _size)[_size];
+  }
+
+  /**
+   * pop
+   * @returns {Value | undefined}
+   */
+  pop() {
+    const current = _classPrivateFieldLooseBase(this, _head)[_head];
+    if (!current) {
+      return;
+    }
+    _classPrivateFieldLooseBase(this, _head)[_head] = _classPrivateFieldLooseBase(this, _head)[_head].next;
+    _classPrivateFieldLooseBase(this, _size)[_size]--;
+    return current.value;
+  }
+
+  /**
+   * size
+   * @returns {number}
+   */
+  get size() {
+    return _classPrivateFieldLooseBase(this, _size)[_size];
+  }
+
+  /**
+   * Iterator
+   * @returns {IterableIterator<Value>}
+   */
+  *[_Symbol$iterator]() {
+    let current = _classPrivateFieldLooseBase(this, _head)[_head];
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+}
+
+exports.Queue = Queue;

package/node_modules/queue-lit/dist/queue-lit.modern.js

@@ -0,0 +1,110 @@
+var id = 0;
+function _classPrivateFieldLooseKey(name) {
+  return "__private_" + id++ + "_" + name;
+}
+function _classPrivateFieldLooseBase(receiver, privateKey) {
+  if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
+    throw new TypeError("attempted to use private field on non-instance");
+  }
+  return receiver;
+}
+
+let _Symbol$iterator;
+class Node {
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Queue
+ * @implements Iterable<Value>
+ * @template Value
+ */
+var _head = /*#__PURE__*/_classPrivateFieldLooseKey("head");
+var _tail = /*#__PURE__*/_classPrivateFieldLooseKey("tail");
+var _size = /*#__PURE__*/_classPrivateFieldLooseKey("size");
+_Symbol$iterator = Symbol.iterator;
+class Queue {
+  constructor() {
+    Object.defineProperty(this, _head, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _tail, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _size, {
+      writable: true,
+      value: void 0
+    });
+    this.clear();
+  }
+
+  /**
+   * clear
+   * @returns {void}
+   */
+  clear() {
+    _classPrivateFieldLooseBase(this, _head)[_head] = undefined;
+    _classPrivateFieldLooseBase(this, _tail)[_tail] = undefined;
+    _classPrivateFieldLooseBase(this, _size)[_size] = 0;
+  }
+
+  /**
+   * push
+   * @param {Value} value
+   * @returns {number}
+   */
+  push(value) {
+    const node = new Node(value);
+    if (_classPrivateFieldLooseBase(this, _head)[_head]) {
+      _classPrivateFieldLooseBase(this, _tail)[_tail].next = node;
+      _classPrivateFieldLooseBase(this, _tail)[_tail] = node;
+    } else {
+      _classPrivateFieldLooseBase(this, _head)[_head] = node;
+      _classPrivateFieldLooseBase(this, _tail)[_tail] = node;
+    }
+    _classPrivateFieldLooseBase(this, _size)[_size]++;
+    return _classPrivateFieldLooseBase(this, _size)[_size];
+  }
+
+  /**
+   * pop
+   * @returns {Value | undefined}
+   */
+  pop() {
+    const current = _classPrivateFieldLooseBase(this, _head)[_head];
+    if (!current) {
+      return;
+    }
+    _classPrivateFieldLooseBase(this, _head)[_head] = _classPrivateFieldLooseBase(this, _head)[_head].next;
+    _classPrivateFieldLooseBase(this, _size)[_size]--;
+    return current.value;
+  }
+
+  /**
+   * size
+   * @returns {number}
+   */
+  get size() {
+    return _classPrivateFieldLooseBase(this, _size)[_size];
+  }
+
+  /**
+   * Iterator
+   * @returns {IterableIterator<Value>}
+   */
+  *[_Symbol$iterator]() {
+    let current = _classPrivateFieldLooseBase(this, _head)[_head];
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+}
+
+export { Queue };