@discordeno/utils 19.0.0-next.e70bfc3 → 19.0.0-next.e7d32e4

package/dist/cjs/Collection.cjs

@@ -0,0 +1,121 @@
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Collection", {
+    enumerable: true,
+    get: ()=>Collection
+});
+let Collection = class Collection extends Map {
+    constructor(entries, options){
+        super(entries ?? []);
+        this.maxSize = options?.maxSize;
+        if (!options?.sweeper) return;
+        this.startSweeper(options.sweeper);
+    }
+    startSweeper(options) {
+        if (this.sweeper?.intervalId) clearInterval(this.sweeper.intervalId);
+        this.sweeper = options;
+        this.sweeper.intervalId = setInterval(()=>{
+            this.forEach((value, key)=>{
+                if (!this.sweeper?.filter(value, key, options.bot)) return;
+                this.delete(key);
+                return key;
+            });
+        }, options.interval);
+        return this.sweeper.intervalId;
+    }
+    stopSweeper() {
+        return clearInterval(this.sweeper?.intervalId);
+    }
+    changeSweeperInterval(newInterval) {
+        if (this.sweeper == null) return;
+        this.startSweeper({
+            filter: this.sweeper.filter,
+            interval: newInterval
+        });
+    }
+    changeSweeperFilter(newFilter) {
+        if (this.sweeper == null) return;
+        this.startSweeper({
+            filter: newFilter,
+            interval: this.sweeper.interval
+        });
+    }
+    /** Add an item to the collection. Makes sure not to go above the maxSize. */ set(key, value) {
+        // When this collection is maxSized make sure we can add first
+        if ((this.maxSize !== undefined || this.maxSize === 0) && this.size >= this.maxSize) {
+            return this;
+        }
+        return super.set(key, value);
+    }
+    /** Add an item to the collection, no matter what the maxSize is. */ forceSet(key, value) {
+        return super.set(key, value);
+    }
+    /** Convert the collection to an array. */ array() {
+        return [
+            ...this.values()
+        ];
+    }
+    /** Retrieve the value of the first element in this collection. */ first() {
+        return this.values().next().value;
+    }
+    /** Retrieve the value of the last element in this collection. */ last() {
+        return [
+            ...this.values()
+        ][this.size - 1];
+    }
+    /** Retrieve the value of a random element in this collection. */ random() {
+        const array = [
+            ...this.values()
+        ];
+        return array[Math.floor(Math.random() * array.length)];
+    }
+    /** Find a specific element in this collection. */ find(callback) {
+        for (const key of this.keys()){
+            const value = this.get(key);
+            if (callback(value, key)) return value;
+        }
+    // If nothing matched
+    }
+    /** Find all elements in this collection that match the given pattern. */ filter(callback) {
+        const relevant = new Collection();
+        this.forEach((value, key)=>{
+            if (callback(value, key)) relevant.set(key, value);
+        });
+        return relevant;
+    }
+    /** Converts the collection into an array by running a callback on all items in the collection. */ map(callback) {
+        const results = [];
+        for (const key of this.keys()){
+            const value = this.get(key);
+            results.push(callback(value, key));
+        }
+        return results;
+    }
+    /** Check if one of the items in the collection matches the pattern. */ some(callback) {
+        for (const key of this.keys()){
+            const value = this.get(key);
+            if (callback(value, key)) return true;
+        }
+        return false;
+    }
+    /** Check if all of the items in the collection matches the pattern. */ every(callback) {
+        for (const key of this.keys()){
+            const value = this.get(key);
+            if (!callback(value, key)) return false;
+        }
+        return true;
+    }
+    /** Runs a callback on all items in the collection, merging them into a single value. */ reduce(callback, initialValue) {
+        let accumulator = initialValue;
+        for (const key of this.keys()){
+            const value = this.get(key);
+            accumulator = callback(accumulator, value, key);
+        }
+        return accumulator;
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/Collection.ts"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/no-empty-interface\nexport interface PlaceHolderBot {}\n\nexport class Collection<K, V> extends Map<K, V> {\n  /**\n   * The maximum amount of items allowed in this collection. To disable cache, set it 0, set to undefined to make it infinite.\n   * @default undefined\n   */\n  maxSize: number | undefined\n  /** Handler to remove items from the collection every so often. */\n  sweeper: (CollectionSweeper<K, V> & { intervalId?: NodeJS.Timer }) | undefined\n\n  constructor(entries?: (ReadonlyArray<readonly [K, V]> | null) | Map<K, V>, options?: CollectionOptions<K, V>) {\n    super(entries ?? [])\n\n    this.maxSize = options?.maxSize\n\n    if (!options?.sweeper) return\n\n    this.startSweeper(options.sweeper)\n  }\n\n  startSweeper(options: CollectionSweeper<K, V>): NodeJS.Timer {\n    if (this.sweeper?.intervalId) clearInterval(this.sweeper.intervalId)\n\n    this.sweeper = options\n    this.sweeper.intervalId = setInterval(() => {\n      this.forEach((value, key) => {\n        if (!this.sweeper?.filter(value, key, options.bot)) return\n\n        this.delete(key)\n        return key\n      })\n    }, options.interval)\n\n    return this.sweeper.intervalId\n  }\n\n  stopSweeper(): void {\n    return clearInterval(this.sweeper?.intervalId)\n  }\n\n  changeSweeperInterval(newInterval: number): void {\n    if (this.sweeper == null) return\n\n    this.startSweeper({ filter: this.sweeper.filter, interval: newInterval })\n  }\n\n  changeSweeperFilter(newFilter: (value: V, key: K, bot: PlaceHolderBot) => boolean): void {\n    if (this.sweeper == null) return\n\n    this.startSweeper({ filter: newFilter, interval: this.sweeper.interval })\n  }\n\n  /** Add an item to the collection. Makes sure not to go above the maxSize. */\n  set(key: K, value: V): this {\n    // When this collection is maxSized make sure we can add first\n    if ((this.maxSize !== undefined || this.maxSize === 0) && this.size >= this.maxSize) {\n      return this\n    }\n\n    return super.set(key, value)\n  }\n\n  /** Add an item to the collection, no matter what the maxSize is. */\n  forceSet(key: K, value: V): this {\n    return super.set(key, value)\n  }\n\n  /** Convert the collection to an array. */\n  array(): V[] {\n    return [...this.values()]\n  }\n\n  /** Retrieve the value of the first element in this collection. */\n  first(): V | undefined {\n    return this.values().next().value\n  }\n\n  /** Retrieve the value of the last element in this collection. */\n  last(): V | undefined {\n    return [...this.values()][this.size - 1]\n  }\n\n  /** Retrieve the value of a random element in this collection. */\n  random(): V | undefined {\n    const array = [...this.values()]\n    return array[Math.floor(Math.random() * array.length)]\n  }\n\n  /** Find a specific element in this collection. */\n  find(callback: (value: V, key: K) => boolean): NonNullable<V> | undefined {\n    for (const key of this.keys()) {\n      const value = this.get(key)!\n      if (callback(value, key)) return value\n    }\n    // If nothing matched\n  }\n\n  /** Find all elements in this collection that match the given pattern. */\n  filter(callback: (value: V, key: K) => boolean): Collection<K, V> {\n    const relevant = new Collection<K, V>()\n    this.forEach((value, key) => {\n      if (callback(value, key)) relevant.set(key, value)\n    })\n\n    return relevant\n  }\n\n  /** Converts the collection into an array by running a callback on all items in the collection. */\n  map<T>(callback: (value: V, key: K) => T): T[] {\n    const results = []\n    for (const key of this.keys()) {\n      const value = this.get(key)!\n      results.push(callback(value, key))\n    }\n    return results\n  }\n\n  /** Check if one of the items in the collection matches the pattern. */\n  some(callback: (value: V, key: K) => boolean): boolean {\n    for (const key of this.keys()) {\n      const value = this.get(key)!\n      if (callback(value, key)) return true\n    }\n\n    return false\n  }\n\n  /** Check if all of the items in the collection matches the pattern. */\n  every(callback: (value: V, key: K) => boolean): boolean {\n    for (const key of this.keys()) {\n      const value = this.get(key)!\n      if (!callback(value, key)) return false\n    }\n\n    return true\n  }\n\n  /** Runs a callback on all items in the collection, merging them into a single value. */\n  reduce<T>(callback: (accumulator: T, value: V, key: K) => T, initialValue?: T): T {\n    let accumulator: T = initialValue!\n\n    for (const key of this.keys()) {\n      const value = this.get(key)!\n      accumulator = callback(accumulator, value, key)\n    }\n\n    return accumulator\n  }\n}\n\nexport interface CollectionOptions<K, V> {\n  /** Handler to clean out the items in the collection every so often. */\n  sweeper?: CollectionSweeper<K, V>\n  /** The maximum number of items allowed in the collection. */\n  maxSize?: number\n}\n\nexport interface CollectionSweeper<K, V> {\n  /** The filter to determine whether an element should be deleted or not */\n  filter: (value: V, key: K, ...args: any[]) => boolean\n  /** The interval in which the sweeper should run */\n  interval: number\n  /** The bot object itself */\n  bot?: PlaceHolderBot\n}\n"],"names":["Collection","Map","constructor","entries","options","maxSize","sweeper","startSweeper","intervalId","clearInterval","setInterval","forEach","value","key","filter","bot","delete","interval","stopSweeper","changeSweeperInterval","newInterval","changeSweeperFilter","newFilter","set","undefined","size","forceSet","array","values","first","next","last","random","Math","floor","length","find","callback","keys","get","relevant","map","results","push","some","every","reduce","initialValue","accumulator"],"mappings":"AAAA,iEAAiE;;;;;+BAGpDA;;aAAAA;;AAAN,IAAA,AAAMA,aAAN,MAAMA,mBAAyBC;IASpCC,YAAYC,OAA6D,EAAEC,OAAiC,CAAE;QAC5G,KAAK,CAACD,WAAW,EAAE;QAEnB,IAAI,CAACE,OAAO,GAAGD,SAASC;QAExB,IAAI,CAACD,SAASE,SAAS;QAEvB,IAAI,CAACC,YAAY,CAACH,QAAQE,OAAO;IACnC;IAEAC,aAAaH,OAAgC,EAAgB;QAC3D,IAAI,IAAI,CAACE,OAAO,EAAEE,YAAYC,cAAc,IAAI,CAACH,OAAO,CAACE,UAAU;QAEnE,IAAI,CAACF,OAAO,GAAGF;QACf,IAAI,CAACE,OAAO,CAACE,UAAU,GAAGE,YAAY,IAAM;YAC1C,IAAI,CAACC,OAAO,CAAC,CAACC,OAAOC,MAAQ;gBAC3B,IAAI,CAAC,IAAI,CAACP,OAAO,EAAEQ,OAAOF,OAAOC,KAAKT,QAAQW,GAAG,GAAG;gBAEpD,IAAI,CAACC,MAAM,CAACH;gBACZ,OAAOA;YACT;QACF,GAAGT,QAAQa,QAAQ;QAEnB,OAAO,IAAI,CAACX,OAAO,CAACE,UAAU;IAChC;IAEAU,cAAoB;QAClB,OAAOT,cAAc,IAAI,CAACH,OAAO,EAAEE;IACrC;IAEAW,sBAAsBC,WAAmB,EAAQ;QAC/C,IAAI,IAAI,CAACd,OAAO,IAAI,IAAI,EAAE;QAE1B,IAAI,CAACC,YAAY,CAAC;YAAEO,QAAQ,IAAI,CAACR,OAAO,CAACQ,MAAM;YAAEG,UAAUG;QAAY;IACzE;IAEAC,oBAAoBC,SAA6D,EAAQ;QACvF,IAAI,IAAI,CAAChB,OAAO,IAAI,IAAI,EAAE;QAE1B,IAAI,CAACC,YAAY,CAAC;YAAEO,QAAQQ;YAAWL,UAAU,IAAI,CAACX,OAAO,CAACW,QAAQ;QAAC;IACzE;IAEA,2EAA2E,GAC3EM,IAAIV,GAAM,EAAED,KAAQ,EAAQ;QAC1B,8DAA8D;QAC9D,IAAI,AAAC,CAAA,IAAI,CAACP,OAAO,KAAKmB,aAAa,IAAI,CAACnB,OAAO,KAAK,CAAA,KAAM,IAAI,CAACoB,IAAI,IAAI,IAAI,CAACpB,OAAO,EAAE;YACnF,OAAO,IAAI;QACb,CAAC;QAED,OAAO,KAAK,CAACkB,GAAG,CAACV,KAAKD;IACxB;IAEA,kEAAkE,GAClEc,SAASb,GAAM,EAAED,KAAQ,EAAQ;QAC/B,OAAO,KAAK,CAACW,GAAG,CAACV,KAAKD;IACxB;IAEA,wCAAwC,GACxCe,QAAa;QACX,OAAO;eAAI,IAAI,CAACC,MAAM;SAAG;IAC3B;IAEA,gEAAgE,GAChEC,QAAuB;QACrB,OAAO,IAAI,CAACD,MAAM,GAAGE,IAAI,GAAGlB,KAAK;IACnC;IAEA,+DAA+D,GAC/DmB,OAAsB;QACpB,OAAO;eAAI,IAAI,CAACH,MAAM;SAAG,CAAC,IAAI,CAACH,IAAI,GAAG,EAAE;IAC1C;IAEA,+DAA+D,GAC/DO,SAAwB;QACtB,MAAML,QAAQ;eAAI,IAAI,CAACC,MAAM;SAAG;QAChC,OAAOD,KAAK,CAACM,KAAKC,KAAK,CAACD,KAAKD,MAAM,KAAKL,MAAMQ,MAAM,EAAE;IACxD;IAEA,gDAAgD,GAChDC,KAAKC,QAAuC,EAA8B;QACxE,KAAK,MAAMxB,OAAO,IAAI,CAACyB,IAAI,GAAI;YAC7B,MAAM1B,QAAQ,IAAI,CAAC2B,GAAG,CAAC1B;YACvB,IAAIwB,SAASzB,OAAOC,MAAM,OAAOD;QACnC;IACA,qBAAqB;IACvB;IAEA,uEAAuE,GACvEE,OAAOuB,QAAuC,EAAoB;QAChE,MAAMG,WAAW,IAAIxC;QACrB,IAAI,CAACW,OAAO,CAAC,CAACC,OAAOC,MAAQ;YAC3B,IAAIwB,SAASzB,OAAOC,MAAM2B,SAASjB,GAAG,CAACV,KAAKD;QAC9C;QAEA,OAAO4B;IACT;IAEA,gGAAgG,GAChGC,IAAOJ,QAAiC,EAAO;QAC7C,MAAMK,UAAU,EAAE;QAClB,KAAK,MAAM7B,OAAO,IAAI,CAACyB,IAAI,GAAI;YAC7B,MAAM1B,QAAQ,IAAI,CAAC2B,GAAG,CAAC1B;YACvB6B,QAAQC,IAAI,CAACN,SAASzB,OAAOC;QAC/B;QACA,OAAO6B;IACT;IAEA,qEAAqE,GACrEE,KAAKP,QAAuC,EAAW;QACrD,KAAK,MAAMxB,OAAO,IAAI,CAACyB,IAAI,GAAI;YAC7B,MAAM1B,QAAQ,IAAI,CAAC2B,GAAG,CAAC1B;YACvB,IAAIwB,SAASzB,OAAOC,MAAM,OAAO,IAAI;QACvC;QAEA,OAAO,KAAK;IACd;IAEA,qEAAqE,GACrEgC,MAAMR,QAAuC,EAAW;QACtD,KAAK,MAAMxB,OAAO,IAAI,CAACyB,IAAI,GAAI;YAC7B,MAAM1B,QAAQ,IAAI,CAAC2B,GAAG,CAAC1B;YACvB,IAAI,CAACwB,SAASzB,OAAOC,MAAM,OAAO,KAAK;QACzC;QAEA,OAAO,IAAI;IACb;IAEA,sFAAsF,GACtFiC,OAAUT,QAAiD,EAAEU,YAAgB,EAAK;QAChF,IAAIC,cAAiBD;QAErB,KAAK,MAAMlC,OAAO,IAAI,CAACyB,IAAI,GAAI;YAC7B,MAAM1B,QAAQ,IAAI,CAAC2B,GAAG,CAAC1B;YACvBmC,cAAcX,SAASW,aAAapC,OAAOC;QAC7C;QAEA,OAAOmC;IACT;AACF"}

package/dist/cjs/base64.cjs

@@ -0,0 +1,272 @@
+/**
+ * CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
+ * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
+ * @param data
+ */ "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, {
+    encode: ()=>encode,
+    decode: ()=>decode
+});
+function encode(data) {
+    const uint8 = typeof data === 'string' ? new TextEncoder().encode(data) : data instanceof Uint8Array ? data : new Uint8Array(data);
+    let result = '';
+    let i;
+    const l = uint8.length;
+    for(i = 2; i < l; i += 3){
+        result += base64abc[uint8[i - 2] >> 2];
+        result += base64abc[(uint8[i - 2] & 0x03) << 4 | uint8[i - 1] >> 4];
+        result += base64abc[(uint8[i - 1] & 0x0f) << 2 | uint8[i] >> 6];
+        result += base64abc[uint8[i] & 0x3f];
+    }
+    if (i === l + 1) {
+        // 1 octet yet to write
+        result += base64abc[uint8[i - 2] >> 2];
+        result += base64abc[(uint8[i - 2] & 0x03) << 4];
+        result += '==';
+    }
+    if (i === l) {
+        // 2 octets yet to write
+        result += base64abc[uint8[i - 2] >> 2];
+        result += base64abc[(uint8[i - 2] & 0x03) << 4 | uint8[i - 1] >> 4];
+        result += base64abc[(uint8[i - 1] & 0x0f) << 2];
+        result += '=';
+    }
+    return result;
+}
+function decode(data) {
+    if (data.length % 4 !== 0) {
+        throw new Error('Unable to parse base64 string.');
+    }
+    const index = data.indexOf('=');
+    if (index !== -1 && index < data.length - 2) {
+        throw new Error('Unable to parse base64 string.');
+    }
+    const missingOctets = data.endsWith('==') ? 2 : data.endsWith('=') ? 1 : 0;
+    const n = data.length;
+    const result = new Uint8Array(3 * (n / 4));
+    let buffer;
+    for(let i = 0, j = 0; i < n; i += 4, j += 3){
+        buffer = getBase64Code(data.charCodeAt(i)) << 18 | getBase64Code(data.charCodeAt(i + 1)) << 12 | getBase64Code(data.charCodeAt(i + 2)) << 6 | getBase64Code(data.charCodeAt(i + 3));
+        result[j] = buffer >> 16;
+        result[j + 1] = buffer >> 8 & 0xff;
+        result[j + 2] = buffer & 0xff;
+    }
+    return result.subarray(0, result.length - missingOctets);
+}
+/**
+ * CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
+ * @param charCode
+ */ function getBase64Code(charCode) {
+    if (charCode >= base64codes.length) {
+        throw new Error('Unable to parse base64 string.');
+    }
+    const code = base64codes[charCode];
+    if (code === 255) {
+        throw new Error('Unable to parse base64 string.');
+    }
+    return code;
+}
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+const base64abc = [
+    'A',
+    'B',
+    'C',
+    'D',
+    'E',
+    'F',
+    'G',
+    'H',
+    'I',
+    'J',
+    'K',
+    'L',
+    'M',
+    'N',
+    'O',
+    'P',
+    'Q',
+    'R',
+    'S',
+    'T',
+    'U',
+    'V',
+    'W',
+    'X',
+    'Y',
+    'Z',
+    'a',
+    'b',
+    'c',
+    'd',
+    'e',
+    'f',
+    'g',
+    'h',
+    'i',
+    'j',
+    'k',
+    'l',
+    'm',
+    'n',
+    'o',
+    'p',
+    'q',
+    'r',
+    's',
+    't',
+    'u',
+    'v',
+    'w',
+    'x',
+    'y',
+    'z',
+    '0',
+    '1',
+    '2',
+    '3',
+    '4',
+    '5',
+    '6',
+    '7',
+    '8',
+    '9',
+    '+',
+    '/'
+];
+// CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
+const base64codes = [
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    62,
+    255,
+    255,
+    255,
+    63,
+    52,
+    53,
+    54,
+    55,
+    56,
+    57,
+    58,
+    59,
+    60,
+    61,
+    255,
+    255,
+    255,
+    0,
+    255,
+    255,
+    255,
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    16,
+    17,
+    18,
+    19,
+    20,
+    21,
+    22,
+    23,
+    24,
+    25,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    26,
+    27,
+    28,
+    29,
+    30,
+    31,
+    32,
+    33,
+    34,
+    35,
+    36,
+    37,
+    38,
+    39,
+    40,
+    41,
+    42,
+    43,
+    44,
+    45,
+    46,
+    47,
+    48,
+    49,
+    50,
+    51
+];
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/base64.ts"],"sourcesContent":["/**\n * CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727\n * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation\n * @param data\n */\nexport function encode(data: ArrayBuffer | string): string {\n  const uint8 = typeof data === 'string' ? new TextEncoder().encode(data) : data instanceof Uint8Array ? data : new Uint8Array(data)\n  let result = ''\n  let i\n  const l = uint8.length\n  for (i = 2; i < l; i += 3) {\n    result += base64abc[uint8[i - 2] >> 2]\n    result += base64abc[((uint8[i - 2] & 0x03) << 4) | (uint8[i - 1] >> 4)]\n    result += base64abc[((uint8[i - 1] & 0x0f) << 2) | (uint8[i] >> 6)]\n    result += base64abc[uint8[i] & 0x3f]\n  }\n  if (i === l + 1) {\n    // 1 octet yet to write\n    result += base64abc[uint8[i - 2] >> 2]\n    result += base64abc[(uint8[i - 2] & 0x03) << 4]\n    result += '=='\n  }\n  if (i === l) {\n    // 2 octets yet to write\n    result += base64abc[uint8[i - 2] >> 2]\n    result += base64abc[((uint8[i - 2] & 0x03) << 4) | (uint8[i - 1] >> 4)]\n    result += base64abc[(uint8[i - 1] & 0x0f) << 2]\n    result += '='\n  }\n  return result\n}\n\n/**\n * CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727\n * Decodes RFC4648 base64 string into an Uint8Array\n * @param data\n */\nexport function decode(data: string): Uint8Array {\n  if (data.length % 4 !== 0) {\n    throw new Error('Unable to parse base64 string.')\n  }\n  const index = data.indexOf('=')\n  if (index !== -1 && index < data.length - 2) {\n    throw new Error('Unable to parse base64 string.')\n  }\n  const missingOctets = data.endsWith('==') ? 2 : data.endsWith('=') ? 1 : 0\n  const n = data.length\n  const result = new Uint8Array(3 * (n / 4))\n  let buffer\n  for (let i = 0, j = 0; i < n; i += 4, j += 3) {\n    buffer =\n      (getBase64Code(data.charCodeAt(i)) << 18) |\n      (getBase64Code(data.charCodeAt(i + 1)) << 12) |\n      (getBase64Code(data.charCodeAt(i + 2)) << 6) |\n      getBase64Code(data.charCodeAt(i + 3))\n    result[j] = buffer >> 16\n    result[j + 1] = (buffer >> 8) & 0xff\n    result[j + 2] = buffer & 0xff\n  }\n  return result.subarray(0, result.length - missingOctets)\n}\n\n/**\n * CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727\n * @param charCode\n */\nfunction getBase64Code(charCode: number): number {\n  if (charCode >= base64codes.length) {\n    throw new Error('Unable to parse base64 string.')\n  }\n  const code = base64codes[charCode]\n  if (code === 255) {\n    throw new Error('Unable to parse base64 string.')\n  }\n  return code\n}\n\n// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.\nconst base64abc = [\n  'A',\n  'B',\n  'C',\n  'D',\n  'E',\n  'F',\n  'G',\n  'H',\n  'I',\n  'J',\n  'K',\n  'L',\n  'M',\n  'N',\n  'O',\n  'P',\n  'Q',\n  'R',\n  'S',\n  'T',\n  'U',\n  'V',\n  'W',\n  'X',\n  'Y',\n  'Z',\n  'a',\n  'b',\n  'c',\n  'd',\n  'e',\n  'f',\n  'g',\n  'h',\n  'i',\n  'j',\n  'k',\n  'l',\n  'm',\n  'n',\n  'o',\n  'p',\n  'q',\n  'r',\n  's',\n  't',\n  'u',\n  'v',\n  'w',\n  'x',\n  'y',\n  'z',\n  '0',\n  '1',\n  '2',\n  '3',\n  '4',\n  '5',\n  '6',\n  '7',\n  '8',\n  '9',\n  '+',\n  '/',\n]\n\n// CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727\nconst base64codes = [\n  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,\n  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62, 255, 255, 255, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 255, 255, 255,\n  0, 255, 255, 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 255, 255, 255, 255, 255, 255, 26,\n  27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,\n]\n"],"names":["encode","decode","data","uint8","TextEncoder","Uint8Array","result","i","l","length","base64abc","Error","index","indexOf","missingOctets","endsWith","n","buffer","j","getBase64Code","charCodeAt","subarray","charCode","base64codes","code"],"mappings":"AAAA;;;;CAIC;;;;;;;;;;;IACeA,MAAM,MAANA;IAgCAC,MAAM,MAANA;;AAhCT,SAASD,OAAOE,IAA0B,EAAU;IACzD,MAAMC,QAAQ,OAAOD,SAAS,WAAW,IAAIE,cAAcJ,MAAM,CAACE,QAAQA,gBAAgBG,aAAaH,OAAO,IAAIG,WAAWH,KAAK;IAClI,IAAII,SAAS;IACb,IAAIC;IACJ,MAAMC,IAAIL,MAAMM,MAAM;IACtB,IAAKF,IAAI,GAAGA,IAAIC,GAAGD,KAAK,EAAG;QACzBD,UAAUI,SAAS,CAACP,KAAK,CAACI,IAAI,EAAE,IAAI,EAAE;QACtCD,UAAUI,SAAS,CAAC,AAAEP,CAAAA,KAAK,CAACI,IAAI,EAAE,GAAG,IAAG,KAAM,IAAMJ,KAAK,CAACI,IAAI,EAAE,IAAI,EAAG;QACvED,UAAUI,SAAS,CAAC,AAAEP,CAAAA,KAAK,CAACI,IAAI,EAAE,GAAG,IAAG,KAAM,IAAMJ,KAAK,CAACI,EAAE,IAAI,EAAG;QACnED,UAAUI,SAAS,CAACP,KAAK,CAACI,EAAE,GAAG,KAAK;IACtC;IACA,IAAIA,MAAMC,IAAI,GAAG;QACf,uBAAuB;QACvBF,UAAUI,SAAS,CAACP,KAAK,CAACI,IAAI,EAAE,IAAI,EAAE;QACtCD,UAAUI,SAAS,CAAC,AAACP,CAAAA,KAAK,CAACI,IAAI,EAAE,GAAG,IAAG,KAAM,EAAE;QAC/CD,UAAU;IACZ,CAAC;IACD,IAAIC,MAAMC,GAAG;QACX,wBAAwB;QACxBF,UAAUI,SAAS,CAACP,KAAK,CAACI,IAAI,EAAE,IAAI,EAAE;QACtCD,UAAUI,SAAS,CAAC,AAAEP,CAAAA,KAAK,CAACI,IAAI,EAAE,GAAG,IAAG,KAAM,IAAMJ,KAAK,CAACI,IAAI,EAAE,IAAI,EAAG;QACvED,UAAUI,SAAS,CAAC,AAACP,CAAAA,KAAK,CAACI,IAAI,EAAE,GAAG,IAAG,KAAM,EAAE;QAC/CD,UAAU;IACZ,CAAC;IACD,OAAOA;AACT;AAOO,SAASL,OAAOC,IAAY,EAAc;IAC/C,IAAIA,KAAKO,MAAM,GAAG,MAAM,GAAG;QACzB,MAAM,IAAIE,MAAM,kCAAiC;IACnD,CAAC;IACD,MAAMC,QAAQV,KAAKW,OAAO,CAAC;IAC3B,IAAID,UAAU,CAAC,KAAKA,QAAQV,KAAKO,MAAM,GAAG,GAAG;QAC3C,MAAM,IAAIE,MAAM,kCAAiC;IACnD,CAAC;IACD,MAAMG,gBAAgBZ,KAAKa,QAAQ,CAAC,QAAQ,IAAIb,KAAKa,QAAQ,CAAC,OAAO,IAAI,CAAC;IAC1E,MAAMC,IAAId,KAAKO,MAAM;IACrB,MAAMH,SAAS,IAAID,WAAW,IAAKW,CAAAA,IAAI,CAAA;IACvC,IAAIC;IACJ,IAAK,IAAIV,IAAI,GAAGW,IAAI,GAAGX,IAAIS,GAAGT,KAAK,GAAGW,KAAK,CAAC,CAAE;QAC5CD,SACE,AAACE,cAAcjB,KAAKkB,UAAU,CAACb,OAAO,KACrCY,cAAcjB,KAAKkB,UAAU,CAACb,IAAI,OAAO,KACzCY,cAAcjB,KAAKkB,UAAU,CAACb,IAAI,OAAO,IAC1CY,cAAcjB,KAAKkB,UAAU,CAACb,IAAI;QACpCD,MAAM,CAACY,EAAE,GAAGD,UAAU;QACtBX,MAAM,CAACY,IAAI,EAAE,GAAG,AAACD,UAAU,IAAK;QAChCX,MAAM,CAACY,IAAI,EAAE,GAAGD,SAAS;IAC3B;IACA,OAAOX,OAAOe,QAAQ,CAAC,GAAGf,OAAOG,MAAM,GAAGK;AAC5C;AAEA;;;CAGC,GACD,SAASK,cAAcG,QAAgB,EAAU;IAC/C,IAAIA,YAAYC,YAAYd,MAAM,EAAE;QAClC,MAAM,IAAIE,MAAM,kCAAiC;IACnD,CAAC;IACD,MAAMa,OAAOD,WAAW,CAACD,SAAS;IAClC,IAAIE,SAAS,KAAK;QAChB,MAAM,IAAIb,MAAM,kCAAiC;IACnD,CAAC;IACD,OAAOa;AACT;AAEA,0EAA0E;AAC1E,MAAMd,YAAY;IAChB;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;CACD;AAED,kFAAkF;AAClF,MAAMa,cAAc;IAClB;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAC5I;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAI;IAAK;IAAK;IAAK;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAK;IAAK;IAC/I;IAAG;IAAK;IAAK;IAAK;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAC9I;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;IAAI;CACjG"}

package/dist/cjs/bucket.cjs

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LeakyBucket", {
+    enumerable: true,
+    get: ()=>LeakyBucket
+});
+const _loggerJs = /*#__PURE__*/ _interopRequireDefault(require("./logger.cjs"));
+const _utilsJs = require("./utils.cjs");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+let LeakyBucket = class LeakyBucket {
+    constructor(options){
+        /** The amount of requests that have been used up already. */ this.used = 0;
+        /** The queue of requests to acquire an available request. Mapped by <shardId, resolve()> */ this.queue = [];
+        /** Whether or not the queue is already processing. */ this.processing = false;
+        this.max = options?.max ?? 1;
+        this.refillAmount = options?.refillAmount ? options.refillAmount > this.max ? this.max : options.refillAmount : 1;
+        this.refillInterval = options?.refillInterval ?? 5000;
+    }
+    /** The amount of requests that still remain. */ get remaining() {
+        return this.max < this.used ? 0 : this.max - this.used;
+    }
+    /** Refills the bucket as needed. */ refillBucket() {
+        _loggerJs.default.debug(`[LeakyBucket] Timeout for leaky bucket requests executed. Refilling bucket.`);
+        // Lower the used amount by the refill amount
+        this.used = this.refillAmount > this.used ? 0 : this.used - this.refillAmount;
+        // Reset the refillsAt timestamp since it just got refilled
+        this.refillsAt = undefined;
+        // Reset the timeoutId
+        clearTimeout(this.timeoutId);
+        this.timeoutId = undefined;
+        if (this.used > 0) {
+            this.timeoutId = setTimeout(()=>{
+                this.refillBucket();
+            }, this.refillInterval);
+            this.refillsAt = Date.now() + this.refillInterval;
+        }
+    }
+    /** Begin processing the queue. */ async processQueue() {
+        _loggerJs.default.debug('[LeakyBucket] Processing queue');
+        // There is already a queue that is processing
+        if (this.processing) return _loggerJs.default.debug('[LeakyBucket] Queue is already processing.');
+        this.processing = true;
+        // Begin going through the queue.
+        while(this.queue.length){
+            if (this.remaining) {
+                _loggerJs.default.debug(`[LeakyBucket] Processing queue. Remaining: ${this.remaining} Length: ${this.queue.length}`);
+                // Resolves the promise allowing the paused execution of this request to resolve and continue.
+                this.queue.shift()?.();
+                // A request can be made
+                this.used++;
+                // Create a new timeout for this request if none exists.
+                if (!this.timeoutId) {
+                    _loggerJs.default.debug(`[LeakyBucket] Creating new timeout for leaky bucket requests.`);
+                    this.timeoutId = setTimeout(()=>{
+                        this.refillBucket();
+                    }, this.refillInterval);
+                    // Set the time for when this refill will occur.
+                    this.refillsAt = Date.now() + this.refillInterval;
+                }
+            } else if (this.refillsAt) {
+                const now = Date.now();
+                // If there is time left until next refill, just delay execution.
+                if (this.refillsAt > now) {
+                    _loggerJs.default.debug(`[LeakyBucket] Delaying execution of leaky bucket requests for ${this.refillsAt - now}ms`);
+                    await (0, _utilsJs.delay)(this.refillsAt - now);
+                    _loggerJs.default.debug(`[LeakyBucket] Resuming execution`);
+                } else {
+                    _loggerJs.default.debug(`[LeakyBucket] Delaying execution of leaky bucket requests for 1000ms`);
+                    await (0, _utilsJs.delay)(1000);
+                }
+            }
+        }
+        // Loop has ended mark false so it can restart later when needed
+        this.processing = false;
+    }
+    /** Pauses the execution until the request is available to be made. */ async acquire(highPriority) {
+        return await new Promise((resolve)=>{
+            // High priority requests get added to the start of the queue
+            if (highPriority) this.queue.unshift(resolve);
+            else this.queue.push(resolve);
+            // Each request should trigger the queue to be processed.
+            void this.processQueue();
+        });
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/bucket.ts"],"sourcesContent":["import logger from './logger.js'\nimport { delay } from './utils.js'\n\nexport class LeakyBucket implements LeakyBucketOptions {\n  max: number\n  refillInterval: number\n  refillAmount: number\n\n  /** The amount of requests that have been used up already. */\n  used: number = 0\n  /** The queue of requests to acquire an available request. Mapped by <shardId, resolve()> */\n  queue: Array<(value: void | PromiseLike<void>) => void> = []\n  /** Whether or not the queue is already processing. */\n  processing: boolean = false\n  /** The timeout id for the timer to reduce the used amount by the refill amount. */\n  timeoutId?: NodeJS.Timeout\n  /** The timestamp in milliseconds when the next refill is scheduled. */\n  refillsAt?: number\n\n  constructor(options?: LeakyBucketOptions) {\n    this.max = options?.max ?? 1\n    this.refillAmount = options?.refillAmount ? (options.refillAmount > this.max ? this.max : options.refillAmount) : 1\n    this.refillInterval = options?.refillInterval ?? 5000\n  }\n\n  /** The amount of requests that still remain. */\n  get remaining(): number {\n    return this.max < this.used ? 0 : this.max - this.used\n  }\n\n  /** Refills the bucket as needed. */\n  refillBucket(): void {\n    logger.debug(`[LeakyBucket] Timeout for leaky bucket requests executed. Refilling bucket.`)\n    // Lower the used amount by the refill amount\n    this.used = this.refillAmount > this.used ? 0 : this.used - this.refillAmount\n    // Reset the refillsAt timestamp since it just got refilled\n    this.refillsAt = undefined\n    // Reset the timeoutId\n    clearTimeout(this.timeoutId)\n    this.timeoutId = undefined\n\n    if (this.used > 0) {\n      this.timeoutId = setTimeout(() => {\n        this.refillBucket()\n      }, this.refillInterval)\n      this.refillsAt = Date.now() + this.refillInterval\n    }\n  }\n\n  /** Begin processing the queue. */\n  async processQueue(): Promise<void> {\n    logger.debug('[LeakyBucket] Processing queue')\n\n    // There is already a queue that is processing\n    if (this.processing) return logger.debug('[LeakyBucket] Queue is already processing.')\n\n    this.processing = true\n\n    // Begin going through the queue.\n    while (this.queue.length) {\n      if (this.remaining) {\n        logger.debug(`[LeakyBucket] Processing queue. Remaining: ${this.remaining} Length: ${this.queue.length}`)\n        // Resolves the promise allowing the paused execution of this request to resolve and continue.\n        this.queue.shift()?.()\n        // A request can be made\n        this.used++\n\n        // Create a new timeout for this request if none exists.\n        if (!this.timeoutId) {\n          logger.debug(`[LeakyBucket] Creating new timeout for leaky bucket requests.`)\n\n          this.timeoutId = setTimeout(() => {\n            this.refillBucket()\n          }, this.refillInterval)\n          // Set the time for when this refill will occur.\n          this.refillsAt = Date.now() + this.refillInterval\n        }\n      }\n\n      // Check if a refill is scheduled, since we have used up all available requests\n      else if (this.refillsAt) {\n        const now = Date.now()\n        // If there is time left until next refill, just delay execution.\n        if (this.refillsAt > now) {\n          logger.debug(`[LeakyBucket] Delaying execution of leaky bucket requests for ${this.refillsAt - now}ms`)\n          await delay(this.refillsAt - now)\n          logger.debug(`[LeakyBucket] Resuming execution`)\n        }\n\n        // If the refillsAt has passed but the timeout didn't yet execute delay the execution\n        else {\n          logger.debug(`[LeakyBucket] Delaying execution of leaky bucket requests for 1000ms`)\n          await delay(1000)\n        }\n      }\n    }\n\n    // Loop has ended mark false so it can restart later when needed\n    this.processing = false\n  }\n\n  /** Pauses the execution until the request is available to be made. */\n  async acquire(highPriority?: boolean): Promise<void> {\n    return await new Promise((resolve) => {\n      // High priority requests get added to the start of the queue\n      if (highPriority) this.queue.unshift(resolve)\n      // All other requests get pushed to the end.\n      else this.queue.push(resolve)\n\n      // Each request should trigger the queue to be processed.\n      void this.processQueue()\n    })\n  }\n}\n\nexport interface LeakyBucketOptions {\n  /**\n   * Max requests allowed at once.\n   * @default 1\n   */\n  max?: number\n  /**\n   * Interval in milliseconds between refills.\n   * @default 5000\n   */\n  refillInterval?: number\n  /**\n   * Amount of requests to refill at each interval.\n   * @default 1\n   */\n  refillAmount?: number\n}\n"],"names":["LeakyBucket","constructor","options","used","queue","processing","max","refillAmount","refillInterval","remaining","refillBucket","logger","debug","refillsAt","undefined","clearTimeout","timeoutId","setTimeout","Date","now","processQueue","length","shift","delay","acquire","highPriority","Promise","resolve","unshift","push"],"mappings":"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"}