@discordeno/utils 19.0.0-next.c32e90e → 19.0.0-next.c460c88

package/README.md

@@ -149,6 +149,6 @@ and unofficial templates:
 
 ## Links
 
-- [Website](https://discordeno.mod.land)
+- [Website](https://discordeno.js.org/)
 - [Documentation](https://doc.deno.land/https/deno.land/x/discordeno/mod.ts)
 - [Discord](https://discord.com/invite/5vBgXk3UcZ)

package/dist/bucket.d.ts

@@ -1,55 +1,43 @@
-import type { PickPartial } from '@discordeno/types';
-/** A Leaky Bucket.
- * Useful for rate limiting purposes.
- * This uses `performance.now()` instead of `Date.now()` for higher accuracy.
- *
- * NOTE: This bucket is lazy, means it only updates when a related method is called.
- */
-export interface LeakyBucket {
-    /** How many tokens this bucket can hold. */
+/// <reference types="node" />
+export declare class LeakyBucket implements LeakyBucketOptions {
     max: number;
-    /** Amount of tokens gained per interval.
-     * If bigger than `max` it will be pressed to `max`.
-     */
-    refillAmount: number;
-    /** Interval at which the bucket gains tokens. */
     refillInterval: number;
-    /** Acquire tokens from the bucket.
-     * Resolves when the tokens are acquired and available.
-     * @param {boolean} [highPriority=false] Whether this acquire is should be done asap.
-     */
-    acquire: (amount: number, highPriority?: boolean) => Promise<void>;
-    /** Returns the number of milliseconds until the next refill. */
-    nextRefill: () => number;
-    /** Current tokens in the bucket. */
-    tokens: () => number;
-    /** @private Internal track of when the last refill of tokens was.
-     * DO NOT TOUCH THIS! Unless you know what you are doing ofc :P
-     */
-    lastRefill: number;
-    /** @private Internal state of whether currently it is allowed to acquire tokens.
-     * DO NOT TOUCH THIS! Unless you know what you are doing ofc :P
+    refillAmount: number;
+    /** The amount of requests that have been used up already. */
+    used: number;
+    /** The queue of requests to acquire an available request. Mapped by <shardId, resolve()> */
+    queue: Array<(value: void | PromiseLike<void>) => void>;
+    /** Whether or not the queue is already processing. */
+    processing: boolean;
+    /** The timeout id for the timer to reduce the used amount by the refill amount. */
+    timeoutId?: NodeJS.Timeout;
+    /** The timestamp in milliseconds when the next refill is scheduled. */
+    refillsAt?: number;
+    constructor(options?: LeakyBucketOptions);
+    /** The amount of requests that still remain. */
+    get remaining(): number;
+    /** Refills the bucket as needed. */
+    refillBucket(): void;
+    /** Begin processing the queue. */
+    processQueue(): Promise<void>;
+    /** Pauses the execution until the request is available to be made. */
+    acquire(highPriority?: boolean): Promise<void>;
+}
+export interface LeakyBucketOptions {
+    /**
+     * Max requests allowed at once.
+     * @default 1
      */
-    allowAcquire: boolean;
-    /** @private Internal number of currently available tokens.
-     * DO NOT TOUCH THIS! Unless you know what you are doing ofc :P
+    max?: number;
+    /**
+     * Interval in milliseconds between refills.
+     * @default 5000
      */
-    tokensState: number;
-    /** @private Internal array of promises necessary to guarantee no race conditions.
-     * DO NOT TOUCH THIS! Unless you know what you are doing ofc :P
+    refillInterval?: number;
+    /**
+     * Amount of requests to refill at each interval.
+     * @default 1
      */
-    waiting: Array<(_?: unknown) => void>;
+    refillAmount?: number;
 }
-export declare function createLeakyBucket({ max, refillInterval, refillAmount, tokens, waiting, ...rest }: Omit<PickPartial<LeakyBucket, 'max' | 'refillInterval' | 'refillAmount'>, 'tokens'> & {
-    /** Current tokens in the bucket.
-     * @default max
-     */
-    tokens?: number;
-}): LeakyBucket;
-/** Update the tokens of that bucket.
- * @returns {number} The amount of current available tokens.
- */
-export declare function updateTokens(bucket: LeakyBucket): number;
-export declare function nextRefill(bucket: LeakyBucket): number;
-export declare function acquire(bucket: LeakyBucket, amount: number, highPriority?: boolean): Promise<void>;
 //# sourceMappingURL=bucket.d.ts.map

package/dist/bucket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bucket.d.ts","sourceRoot":"","sources":["../src/bucket.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAGpD;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,4CAA4C;IAC5C,GAAG,EAAE,MAAM,CAAA;IACX;;OAEG;IACH,YAAY,EAAE,MAAM,CAAA;IACpB,iDAAiD;IACjD,cAAc,EAAE,MAAM,CAAA;IAEtB;;;OAGG;IACH,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAElE,gEAAgE;IAChE,UAAU,EAAE,MAAM,MAAM,CAAA;IAExB,oCAAoC;IACpC,MAAM,EAAE,MAAM,MAAM,CAAA;IAEpB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAA;IAElB;;OAEG;IACH,YAAY,EAAE,OAAO,CAAA;IAErB;;OAEG;IACH,WAAW,EAAE,MAAM,CAAA;IAEnB;;OAEG;IACH,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC,CAAA;CACtC;AAED,wBAAgB,iBAAiB,CAAC,EAChC,GAAG,EACH,cAAc,EACd,YAAY,EACZ,MAAM,EACN,OAAO,EACP,GAAG,IAAI,EACR,EAAE,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,KAAK,GAAG,gBAAgB,GAAG,cAAc,CAAC,EAAE,QAAQ,CAAC,GAAG;IACvF;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,GAAG,WAAW,CAyBd;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CASxD;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAKtD;AAED,wBAAsB,OAAO,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,UAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CA+CtG"}
+{"version":3,"file":"bucket.d.ts","sourceRoot":"","sources":["../src/bucket.ts"],"names":[],"mappings":";AAGA,qBAAa,WAAY,YAAW,kBAAkB;IACpD,GAAG,EAAE,MAAM,CAAA;IACX,cAAc,EAAE,MAAM,CAAA;IACtB,YAAY,EAAE,MAAM,CAAA;IAEpB,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAI;IAChB,4FAA4F;IAC5F,KAAK,EAAE,KAAK,CAAC,CAAC,KAAK,EAAE,IAAI,GAAG,WAAW,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,CAAK;IAC5D,sDAAsD;IACtD,UAAU,EAAE,OAAO,CAAQ;IAC3B,mFAAmF;IACnF,SAAS,CAAC,EAAE,MAAM,CAAC,OAAO,CAAA;IAC1B,uEAAuE;IACvE,SAAS,CAAC,EAAE,MAAM,CAAA;gBAEN,OAAO,CAAC,EAAE,kBAAkB;IAMxC,gDAAgD;IAChD,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,oCAAoC;IACpC,YAAY,IAAI,IAAI;IAkBpB,kCAAkC;IAC5B,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAmDnC,sEAAsE;IAChE,OAAO,CAAC,YAAY,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;CAWrD;AAED,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB"}

package/dist/bucket.js

@@ -1,80 +1,80 @@
+import logger from './logger.js';
 import { delay } from './utils.js';
-export function createLeakyBucket({ max , refillInterval , refillAmount , tokens , waiting , ...rest }) {
-    return {
-        max,
-        refillInterval,
-        refillAmount: refillAmount > max ? max : refillAmount,
-        lastRefill: performance.now(),
-        allowAcquire: true,
-        nextRefill: function() {
-            return nextRefill(this);
-        },
-        tokens: function() {
-            return updateTokens(this);
-        },
-        acquire: async function(amount, highPriority) {
-            return await acquire(this, amount, highPriority);
-        },
-        tokensState: tokens ?? max,
-        waiting: waiting ?? [],
-        ...rest
-    };
-}
-/** Update the tokens of that bucket.
- * @returns {number} The amount of current available tokens.
- */ export function updateTokens(bucket) {
-    const timePassed = performance.now() - bucket.lastRefill;
-    const missedRefills = Math.floor(timePassed / bucket.refillInterval);
-    // The refill shall not exceed the max amount of tokens.
-    bucket.tokensState = Math.min(bucket.tokensState + bucket.refillAmount * missedRefills, bucket.max);
-    bucket.lastRefill += bucket.refillInterval * missedRefills;
-    return bucket.tokensState;
-}
-export function nextRefill(bucket) {
-    // Since this bucket is lazy update the tokens before calculating the next refill.
-    updateTokens(bucket);
-    return performance.now() - bucket.lastRefill + bucket.refillInterval;
-}
-export async function acquire(bucket, amount, highPriority = false) {
-    // To prevent the race condition of 2 acquires happening at once,
-    // check whether its currently allowed to acquire.
-    if (!bucket.allowAcquire) {
-        // create, push, and wait until the current running acquiring is finished.
-        await new Promise((resolve)=>{
-            if (highPriority) {
-                bucket.waiting.unshift(resolve);
-            } else {
-                bucket.waiting.push(resolve);
+export 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() {
+        logger.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() {
+        logger.debug('[LeakyBucket] Processing queue');
+        // There is already a queue that is processing
+        if (this.processing) return logger.debug('[LeakyBucket] Queue is already processing.');
+        this.processing = true;
+        // Begin going through the queue.
+        while(this.queue.length){
+            if (this.remaining) {
+                logger.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) {
+                    logger.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) {
+                    logger.debug(`[LeakyBucket] Delaying execution of leaky bucket requests for ${this.refillsAt - now}ms`);
+                    await delay(this.refillsAt - now);
+                    logger.debug(`[LeakyBucket] Resuming execution`);
+                } else {
+                    logger.debug(`[LeakyBucket] Delaying execution of leaky bucket requests for 1000ms`);
+                    await delay(1000);
+                }
             }
-        });
-        // Somehow another acquire has started,
-        // so need to wait again.
-        if (!bucket.allowAcquire) {
-            return await acquire(bucket, amount);
         }
+        // Loop has ended mark false so it can restart later when needed
+        this.processing = false;
     }
-    bucket.allowAcquire = false;
-    // Since the bucket is lazy update the tokens now,
-    // and also get the current amount of available tokens
-    const currentTokens = updateTokens(bucket);
-    // It's possible that more than available tokens have been acquired,
-    // so calculate the amount of milliseconds to wait until this acquire is good to go.
-    if (currentTokens < amount) {
-        const tokensNeeded = amount - currentTokens;
-        const refillsNeeded = Math.ceil(tokensNeeded / bucket.refillAmount);
-        const waitTime = bucket.refillInterval * refillsNeeded;
-        await delay(waitTime);
-        // Update the tokens again to ensure nothing has been missed.
-        updateTokens(bucket);
+    /** 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();
+        });
     }
-    // In order to not subtract too much from the tokens,
-    // calculate what is actually needed to subtract.
-    const toSubtract = (amount % bucket.refillAmount) ?? amount;
-    bucket.tokensState -= toSubtract;
-    // Allow the next acquire to happen.
-    bucket.allowAcquire = true;
-    // If there is an acquire waiting, let it continue.
-    bucket.waiting.shift()?.();
 }
 
 //# sourceMappingURL=bucket.js.map

package/dist/bucket.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/bucket.ts"],"sourcesContent":["import type { PickPartial } from '@discordeno/types'\nimport { delay } from './utils.js'\n\n/** A Leaky Bucket.\n * Useful for rate limiting purposes.\n * This uses `performance.now()` instead of `Date.now()` for higher accuracy.\n *\n * NOTE: This bucket is lazy, means it only updates when a related method is called.\n */\nexport interface LeakyBucket {\n  /** How many tokens this bucket can hold. */\n  max: number\n  /** Amount of tokens gained per interval.\n   * If bigger than `max` it will be pressed to `max`.\n   */\n  refillAmount: number\n  /** Interval at which the bucket gains tokens. */\n  refillInterval: number\n\n  /** Acquire tokens from the bucket.\n   * Resolves when the tokens are acquired and available.\n   * @param {boolean} [highPriority=false] Whether this acquire is should be done asap.\n   */\n  acquire: (amount: number, highPriority?: boolean) => Promise<void>\n\n  /** Returns the number of milliseconds until the next refill. */\n  nextRefill: () => number\n\n  /** Current tokens in the bucket. */\n  tokens: () => number\n\n  /** @private Internal track of when the last refill of tokens was.\n   * DO NOT TOUCH THIS! Unless you know what you are doing ofc :P\n   */\n  lastRefill: number\n\n  /** @private Internal state of whether currently it is allowed to acquire tokens.\n   * DO NOT TOUCH THIS! Unless you know what you are doing ofc :P\n   */\n  allowAcquire: boolean\n\n  /** @private Internal number of currently available tokens.\n   * DO NOT TOUCH THIS! Unless you know what you are doing ofc :P\n   */\n  tokensState: number\n\n  /** @private Internal array of promises necessary to guarantee no race conditions.\n   * DO NOT TOUCH THIS! Unless you know what you are doing ofc :P\n   */\n  waiting: Array<(_?: unknown) => void>\n}\n\nexport function createLeakyBucket({\n  max,\n  refillInterval,\n  refillAmount,\n  tokens,\n  waiting,\n  ...rest\n}: Omit<PickPartial<LeakyBucket, 'max' | 'refillInterval' | 'refillAmount'>, 'tokens'> & {\n  /** Current tokens in the bucket.\n   * @default max\n   */\n  tokens?: number\n}): LeakyBucket {\n  return {\n    max,\n    refillInterval,\n    refillAmount: refillAmount > max ? max : refillAmount,\n    lastRefill: performance.now(),\n    allowAcquire: true,\n\n    nextRefill: function () {\n      return nextRefill(this)\n    },\n\n    tokens: function () {\n      return updateTokens(this)\n    },\n\n    acquire: async function (amount, highPriority) {\n      return await acquire(this, amount, highPriority)\n    },\n\n    tokensState: tokens ?? max,\n    waiting: waiting ?? [],\n\n    ...rest,\n  }\n}\n\n/** Update the tokens of that bucket.\n * @returns {number} The amount of current available tokens.\n */\nexport function updateTokens(bucket: LeakyBucket): number {\n  const timePassed = performance.now() - bucket.lastRefill\n  const missedRefills = Math.floor(timePassed / bucket.refillInterval)\n\n  // The refill shall not exceed the max amount of tokens.\n  bucket.tokensState = Math.min(bucket.tokensState + bucket.refillAmount * missedRefills, bucket.max)\n  bucket.lastRefill += bucket.refillInterval * missedRefills\n\n  return bucket.tokensState\n}\n\nexport function nextRefill(bucket: LeakyBucket): number {\n  // Since this bucket is lazy update the tokens before calculating the next refill.\n  updateTokens(bucket)\n\n  return performance.now() - bucket.lastRefill + bucket.refillInterval\n}\n\nexport async function acquire(bucket: LeakyBucket, amount: number, highPriority = false): Promise<void> {\n  // To prevent the race condition of 2 acquires happening at once,\n  // check whether its currently allowed to acquire.\n  if (!bucket.allowAcquire) {\n    // create, push, and wait until the current running acquiring is finished.\n    await new Promise((resolve) => {\n      if (highPriority) {\n        bucket.waiting.unshift(resolve)\n      } else {\n        bucket.waiting.push(resolve)\n      }\n    })\n\n    // Somehow another acquire has started,\n    // so need to wait again.\n    if (!bucket.allowAcquire) {\n      return await acquire(bucket, amount)\n    }\n  }\n\n  bucket.allowAcquire = false\n  // Since the bucket is lazy update the tokens now,\n  // and also get the current amount of available tokens\n  const currentTokens = updateTokens(bucket)\n\n  // It's possible that more than available tokens have been acquired,\n  // so calculate the amount of milliseconds to wait until this acquire is good to go.\n  if (currentTokens < amount) {\n    const tokensNeeded = amount - currentTokens\n    const refillsNeeded = Math.ceil(tokensNeeded / bucket.refillAmount)\n\n    const waitTime = bucket.refillInterval * refillsNeeded\n    await delay(waitTime)\n\n    // Update the tokens again to ensure nothing has been missed.\n    updateTokens(bucket)\n  }\n\n  // In order to not subtract too much from the tokens,\n  // calculate what is actually needed to subtract.\n  const toSubtract = amount % bucket.refillAmount ?? amount\n  bucket.tokensState -= toSubtract\n\n  // Allow the next acquire to happen.\n  bucket.allowAcquire = true\n  // If there is an acquire waiting, let it continue.\n  bucket.waiting.shift()?.()\n}\n"],"names":["delay","createLeakyBucket","max","refillInterval","refillAmount","tokens","waiting","rest","lastRefill","performance","now","allowAcquire","nextRefill","updateTokens","acquire","amount","highPriority","tokensState","bucket","timePassed","missedRefills","Math","floor","min","Promise","resolve","unshift","push","currentTokens","tokensNeeded","refillsNeeded","ceil","waitTime","toSubtract","shift"],"mappings":"AACA,SAASA,KAAK,QAAQ,aAAY;AAmDlC,OAAO,SAASC,kBAAkB,EAChCC,IAAG,EACHC,eAAc,EACdC,aAAY,EACZC,OAAM,EACNC,QAAO,EACP,GAAGC,MAMJ,EAAe;IACd,OAAO;QACLL;QACAC;QACAC,cAAcA,eAAeF,MAAMA,MAAME,YAAY;QACrDI,YAAYC,YAAYC,GAAG;QAC3BC,cAAc,IAAI;QAElBC,YAAY,WAAY;YACtB,OAAOA,WAAW,IAAI;QACxB;QAEAP,QAAQ,WAAY;YAClB,OAAOQ,aAAa,IAAI;QAC1B;QAEAC,SAAS,eAAgBC,MAAM,EAAEC,YAAY,EAAE;YAC7C,OAAO,MAAMF,QAAQ,IAAI,EAAEC,QAAQC;QACrC;QAEAC,aAAaZ,UAAUH;QACvBI,SAASA,WAAW,EAAE;QAEtB,GAAGC,IAAI;IACT;AACF,CAAC;AAED;;CAEC,GACD,OAAO,SAASM,aAAaK,MAAmB,EAAU;IACxD,MAAMC,aAAaV,YAAYC,GAAG,KAAKQ,OAAOV,UAAU;IACxD,MAAMY,gBAAgBC,KAAKC,KAAK,CAACH,aAAaD,OAAOf,cAAc;IAEnE,wDAAwD;IACxDe,OAAOD,WAAW,GAAGI,KAAKE,GAAG,CAACL,OAAOD,WAAW,GAAGC,OAAOd,YAAY,GAAGgB,eAAeF,OAAOhB,GAAG;IAClGgB,OAAOV,UAAU,IAAIU,OAAOf,cAAc,GAAGiB;IAE7C,OAAOF,OAAOD,WAAW;AAC3B,CAAC;AAED,OAAO,SAASL,WAAWM,MAAmB,EAAU;IACtD,kFAAkF;IAClFL,aAAaK;IAEb,OAAOT,YAAYC,GAAG,KAAKQ,OAAOV,UAAU,GAAGU,OAAOf,cAAc;AACtE,CAAC;AAED,OAAO,eAAeW,QAAQI,MAAmB,EAAEH,MAAc,EAAEC,eAAe,KAAK,EAAiB;IACtG,iEAAiE;IACjE,kDAAkD;IAClD,IAAI,CAACE,OAAOP,YAAY,EAAE;QACxB,0EAA0E;QAC1E,MAAM,IAAIa,QAAQ,CAACC,UAAY;YAC7B,IAAIT,cAAc;gBAChBE,OAAOZ,OAAO,CAACoB,OAAO,CAACD;YACzB,OAAO;gBACLP,OAAOZ,OAAO,CAACqB,IAAI,CAACF;YACtB,CAAC;QACH;QAEA,uCAAuC;QACvC,yBAAyB;QACzB,IAAI,CAACP,OAAOP,YAAY,EAAE;YACxB,OAAO,MAAMG,QAAQI,QAAQH;QAC/B,CAAC;IACH,CAAC;IAEDG,OAAOP,YAAY,GAAG,KAAK;IAC3B,kDAAkD;IAClD,sDAAsD;IACtD,MAAMiB,gBAAgBf,aAAaK;IAEnC,oEAAoE;IACpE,oFAAoF;IACpF,IAAIU,gBAAgBb,QAAQ;QAC1B,MAAMc,eAAed,SAASa;QAC9B,MAAME,gBAAgBT,KAAKU,IAAI,CAACF,eAAeX,OAAOd,YAAY;QAElE,MAAM4B,WAAWd,OAAOf,cAAc,GAAG2B;QACzC,MAAM9B,MAAMgC;QAEZ,6DAA6D;QAC7DnB,aAAaK;IACf,CAAC;IAED,qDAAqD;IACrD,iDAAiD;IACjD,MAAMe,aAAalB,CAAAA,SAASG,OAAOd,YAAY,AAAD,KAAKW;IACnDG,OAAOD,WAAW,IAAIgB;IAEtB,oCAAoC;IACpCf,OAAOP,YAAY,GAAG,IAAI;IAC1B,mDAAmD;IACnDO,OAAOZ,OAAO,CAAC4B,KAAK;AACtB,CAAC"}
+{"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":["logger","delay","LeakyBucket","constructor","options","used","queue","processing","max","refillAmount","refillInterval","remaining","refillBucket","debug","refillsAt","undefined","clearTimeout","timeoutId","setTimeout","Date","now","processQueue","length","shift","acquire","highPriority","Promise","resolve","unshift","push"],"mappings":"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"}

package/dist/builders/embeds.d.ts

@@ -0,0 +1,146 @@
+import type { DiscordEmbed, DiscordEmbedAuthor, DiscordEmbedField, DiscordEmbedFooter, DiscordEmbedImage, DiscordEmbedThumbnail, DiscordEmbedVideo } from '@discordeno/types';
+/**
+ * A builder to help create Discord embeds.
+ *
+ * @export
+ * @class EmbedsBuilder
+ * @typedef {EmbedsBuilder}
+ * @extends {Array<DiscordEmbed>}
+ * @example
+ * const embeds = new EmbedBuilder()
+ *  .setTitle('My Embed')
+ *  .setDescription('This is my new embed')
+ *  .newEmbed()
+ *  .setTitle('My Second Embed')
+ */
+export declare class EmbedsBuilder extends Array<DiscordEmbed> {
+    #private;
+    /**
+     * Adds a new field to the embed fields array.
+     *
+     * @param {string} name - Field name
+     * @param {string} value - Field value
+     * @param {?boolean} [inline=false] - Field should be inline or not.
+     * @returns {EmbedsBuilder}
+     */
+    addField(name: string, value: string, inline?: boolean): EmbedsBuilder;
+    /**
+     * Creates a blank embed.
+     *
+     * @returns {EmbedsBuilder}
+     */
+    newEmbed(): EmbedsBuilder;
+    /**
+     * Set the current embed author.
+     *
+     * @param {string} name - Name of the author
+     * @param {?Omit<DiscordEmbedAuthor, 'name'>} [options] - Extra author options
+     * @returns {EmbedsBuilder}
+     */
+    setAuthor(name: string, options?: Omit<DiscordEmbedAuthor, 'name'>): EmbedsBuilder;
+    /**
+     * Set the color on the side of the current embed.
+     *
+     * @param {(number | string)} color - The color, in base16 or hex color code
+     * @returns {EmbedsBuilder}
+     */
+    setColor(color: number | string): EmbedsBuilder;
+    /**
+     * Set the current embed to a different index.
+     *
+     * WARNING: Only use this method if you know what you're doing. Make sure to set it back to the latest when you're done.
+     *
+     * @param {?number} [index] - The index of the embed in the EmbedsBuilder array
+     * @returns {EmbedsBuilder}
+     */
+    setCurrentEmbed(index?: number): EmbedsBuilder;
+    /**
+     * Set the description of the current embed.
+     *
+     * @param {string} description - Description
+     * @returns {EmbedsBuilder}
+     */
+    setDescription(description: string): EmbedsBuilder;
+    /**
+     * Overwrite all fields on the current embed.
+     *
+     * @param {DiscordEmbedField[]} fields
+     * @returns {EmbedsBuilder}
+     */
+    setFields(fields: DiscordEmbedField[]): EmbedsBuilder;
+    /**
+     * Set the footer in the current embed.
+     *
+     * @param {string} text - The text to display in the footer
+     * @param {?Omit<DiscordEmbedFooter, 'text'>} [options]
+     * @returns {EmbedsBuilder}
+     */
+    setFooter(text: string, options?: Omit<DiscordEmbedFooter, 'text'>): EmbedsBuilder;
+    /**
+     * Set the image in the current embed.
+     *
+     * @param {string} url - URL of the image
+     * @param {?Omit<DiscordEmbedImage, 'url'>} [options]
+     * @returns {EmbedsBuilder}
+     */
+    setImage(url: string, options?: Omit<DiscordEmbedImage, 'url'>): EmbedsBuilder;
+    /**
+     * Set the provider of the current embed.
+     *
+     * @param {string} name
+     * @param {?string} [url]
+     * @returns {EmbedsBuilder}
+     */
+    setProvider(name: string, url?: string): EmbedsBuilder;
+    /**
+     * Set the color of the current embed to a random value.
+     *
+     * @returns {EmbedsBuilder}
+     */
+    setRandomColor(): EmbedsBuilder;
+    /**
+     * Set the title of the current embed.
+     *
+     * @param {string} title
+     * @param {?string} [url]
+     * @returns {EmbedsBuilder}
+     */
+    setTitle(title: string, url?: string): EmbedsBuilder;
+    /**
+     * Set the timestamp of the current embed.
+     *
+     * @param {?(string | number | Date)} [timestamp]
+     * @returns {EmbedsBuilder}
+     */
+    setTimestamp(timestamp?: string | number | Date): EmbedsBuilder;
+    /**
+     * Set the thumbnail of the current embed.
+     *
+     * @param {string} url - URL of the image
+     * @param {?Omit<DiscordEmbedThumbnail, 'url'>} [options]
+     * @returns {EmbedsBuilder}
+     */
+    setThumbnail(url: string, options?: Omit<DiscordEmbedThumbnail, 'url'>): EmbedsBuilder;
+    /**
+     * Set the URL of the current embed title.
+     *
+     * @param {string} url
+     * @returns {EmbedsBuilder}
+     */
+    setUrl(url: string): EmbedsBuilder;
+    /**
+     * Set the video of the current embed.
+     *
+     * @param {string} url
+     * @param {?Omit<DiscordEmbedVideo, 'url'>} [options]
+     * @returns {EmbedsBuilder}
+     */
+    setVideo(url: string, options?: Omit<DiscordEmbedVideo, 'url'>): EmbedsBuilder;
+    /**
+     * Validate all embeds available against current known Discord limits to help prevent bad requests.
+     *
+     * @returns {EmbedsBuilder}
+     */
+    validate(): EmbedsBuilder;
+}
+//# sourceMappingURL=embeds.d.ts.map

package/dist/builders/embeds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embeds.d.ts","sourceRoot":"","sources":["../../src/builders/embeds.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,EACjB,qBAAqB,EACrB,iBAAiB,EAClB,MAAM,mBAAmB,CAAA;AAE1B;;;;;;;;;;;;;GAaG;AACH,qBAAa,aAAc,SAAQ,KAAK,CAAC,YAAY,CAAC;;IAGpD;;;;;;;OAOG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,aAAa;IActE;;;;OAIG;IACH,QAAQ,IAAI,aAAa;IAWzB;;;;;;OAMG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,kBAAkB,EAAE,MAAM,CAAC,GAAG,aAAa;IAUlF;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,aAAa;IAW/C;;;;;;;OAOG;IACH,eAAe,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,aAAa;IAgB9C;;;;;OAKG;IACH,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,aAAa;IAMlD;;;;;OAKG;IACH,SAAS,CAAC,MAAM,EAAE,iBAAiB,EAAE,GAAG,aAAa;IAMrD;;;;;;OAMG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,kBAAkB,EAAE,MAAM,CAAC,GAAG,aAAa;IAUlF;;;;;;OAMG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,KAAK,CAAC,GAAG,aAAa;IAU9E;;;;;;OAMG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,aAAa;IAStD;;;;OAIG;IACH,cAAc,IAAI,aAAa;IAI/B;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,aAAa;IAUpD;;;;;OAKG;IACH,YAAY,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,aAAa;IAM/D;;;;;;OAMG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,qBAAqB,EAAE,KAAK,CAAC,GAAG,aAAa;IAUtF;;;;;OAKG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa;IAMlC;;;;;;OAMG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,KAAK,CAAC,GAAG,aAAa;IAU9E;;;;OAIG;IACH,QAAQ,IAAI,aAAa;CA4F1B"}