@esportsplus/typescript 0.8.4 → 0.8.6

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

@@ -1,91 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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

@@ -1,55 +0,0 @@
-{
-  "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

@@ -1,21 +0,0 @@
-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

@@ -1,93 +0,0 @@
-# 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

@@ -1,34 +0,0 @@
-/**
- * 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

@@ -1,110 +0,0 @@
-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

@@ -1,110 +0,0 @@
-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 };