seyfert 1.2.0 → 1.2.2

package/lib/websocket/structures/index.js

@@ -1,256 +1,74 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SequentialBucket = exports.PriorityQueue = exports.LinkedList = exports.Queue = exports.PNode = exports.TNode = exports.DynamicBucket = void 0;
+exports.DynamicBucket = void 0;
 const common_1 = require("../../common");
-/**
- * generally useless for interaction based bots
- * ideally this would only be triggered on certain paths
- * example: a huge amount of messages being spammed
- *
- * a dynamic bucket is just a priority queue implemented using linked lists
- * we create an empty bucket for every path
- * dynamically allocating memory improves the final memory footprint
- */
 class DynamicBucket {
-    limit;
-    refillInterval;
-    refillAmount;
-    /** The queue of requests to acquire an available request. Mapped by <shardId, resolve()> */
-    queue = new PriorityQueue();
-    /** The amount of requests that have been used up already. */
+    options;
+    queue = [];
     used = 0;
-    /** Whether or not the queue is already processing. */
-    processing = false;
-    /** The timeout id for the timer to reduce the used amount by the refill amount.  */
-    timeoutId;
-    /** The timestamp in milliseconds when the next refill is scheduled. */
+    processing;
     refillsAt;
-    debugger;
+    timeoutId;
     constructor(options) {
-        this.limit = options.limit;
-        this.refillInterval = options.refillInterval;
-        this.refillAmount = options.refillAmount;
-        if (options.debugger) {
-            this.debugger = options.debugger;
-        }
+        this.options = options;
     }
     get remaining() {
-        if (this.limit < this.used) {
+        if (this.options.limit < this.used) {
             return 0;
         }
-        return this.limit - this.used;
+        return this.options.limit - this.used;
     }
     refill() {
-        // 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;
+        if (this.timeoutId) {
+            clearTimeout(this.timeoutId);
+            this.timeoutId = undefined;
+        }
         if (this.used > 0) {
-            if (this.timeoutId) {
-                clearTimeout(this.timeoutId);
-            }
+            this.used = 0;
             this.timeoutId = setTimeout(() => {
                 this.refill();
-            }, this.refillInterval);
-            this.refillsAt = Date.now() + this.refillInterval;
+            }, this.options.refillInterval);
+            this.refillsAt = Date.now() + this.options.refillInterval;
         }
     }
-    /** Begin processing the queue. */
     async processQueue() {
-        // There is already a queue that is processing
-        if (this.processing) {
+        if (this.processing)
             return;
-        }
-        // Begin going through the queue.
-        while (!this.queue.isEmpty()) {
+        this.processing = true;
+        while (this.queue.length) {
             if (this.remaining) {
-                this.debugger?.debug(`Processing queue. Remaining: ${this.remaining} Length: ${this.queue.size()}`);
-                // Resolves the promise allowing the paused execution of this request to resolve and continue.
-                this.queue.peek()();
-                this.queue.pop();
-                // A request can be made
+                this.options.debugger?.debug(`Processing queue. Remaining: ${this.remaining} Length: ${this.queue.length}`);
+                this.queue.shift()();
                 this.used++;
-                // Create a new timeout for this request if none exists.
                 if (!this.timeoutId) {
                     this.timeoutId = setTimeout(() => {
                         this.refill();
-                    }, this.refillInterval);
-                    // Set the time for when this refill will occur.
-                    this.refillsAt = Date.now() + this.refillInterval;
+                    }, this.options.refillInterval);
+                    this.refillsAt = Date.now() + this.options.refillInterval;
                 }
-                // Check if a refill is scheduled, since we have used up all available requests
             }
             else if (this.refillsAt) {
                 const now = Date.now();
-                // If there is time left until next refill, just delay execution.
                 if (this.refillsAt > now) {
+                    this.options.debugger?.info(`Waiting ${this.refillsAt - now}ms to process queue`);
                     await (0, common_1.delay)(this.refillsAt - now);
+                    this.used = 0;
                 }
             }
         }
-        // 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(priority) {
-        return new Promise(resolve => {
-            this.queue.push(resolve, priority);
+    acquire(force = false) {
+        return new Promise(res => {
+            this.queue[force ? 'unshift' : 'push'](res);
             void this.processQueue();
         });
     }
-    toString() {
-        return [...this.queue].toString();
-    }
-}
-exports.DynamicBucket = DynamicBucket;
-class TNode {
-    data;
-    next;
-    constructor(data) {
-        this.data = data;
-        this.next = null;
-    }
-    static null(list) {
-        return !list;
-    }
-}
-exports.TNode = TNode;
-class PNode extends TNode {
-    priority;
-    constructor(data, priority) {
-        super(data);
-        this.priority = priority;
-    }
-}
-exports.PNode = PNode;
-class Queue {
-    /**
-     * O(1)
-     */
-    pop() {
-        if (TNode.null(this.head)) {
-            throw new Error('cannot pop a list without elements');
-        }
-        return (this.head = this.head.next);
-    }
-    /**
-     * O(1)
-     */
-    peek() {
-        if (TNode.null(this.head)) {
-            throw new Error('cannot peek an empty list');
-        }
-        return this.head.data;
-    }
-    /**
-     * O(n)
-     */
-    size() {
-        let aux = this.head;
-        if (TNode.null(aux)) {
-            return 0;
-        }
-        let count = 1;
-        while (aux.next !== null) {
-            count++;
-            aux = aux.next;
-        }
-        return count;
-    }
-    /**
-     * O(1)
-     */
-    isEmpty() {
-        return TNode.null(this.head);
-    }
-    *[Symbol.iterator]() {
-        let temp = this.head;
-        while (temp !== null) {
-            yield temp.data;
-            temp = temp.next;
-        }
-    }
-    toArray() {
-        return Array.from(this);
-    }
-    toString() {
-        return this.head?.toString() || '';
-    }
-}
-exports.Queue = Queue;
-class LinkedList extends Queue {
-    head = null;
-    /**
-     * O(1)
-     */
-    push(data) {
-        const temp = new TNode(data);
-        temp.next = this.head;
-        this.head = temp;
-        return this.head;
-    }
-}
-exports.LinkedList = LinkedList;
-class PriorityQueue extends Queue {
-    head = null;
-    /**
-     * O(#priorities)
-     */
-    push(data, priority) {
-        let start = this.head;
-        const temp = new PNode(data, priority);
-        if (TNode.null(this.head) || TNode.null(start)) {
-            this.head = temp;
-            return this.head;
-        }
-        if (this.head.priority > priority) {
-            temp.next = this.head;
-            this.head = temp;
-            return this.head;
-        }
-        while (start.next !== null && start.next.priority < priority) {
-            start = start.next;
-        }
-        temp.next = start.next;
-        start.next = temp;
-        return this.head;
-    }
-}
-exports.PriorityQueue = PriorityQueue;
-class SequentialBucket {
-    connections;
-    capacity; // max_concurrency
-    spawnTimeout;
-    constructor(maxCapacity) {
-        this.connections = new LinkedList();
-        this.capacity = maxCapacity;
-        this.spawnTimeout = 5000;
-    }
-    async destroy() {
-        this.connections = new LinkedList();
-    }
-    async push(promise) {
-        this.connections.push(promise);
-        if (this.capacity <= this.connections.size()) {
-            await this.acquire();
-            await (0, common_1.delay)(this.spawnTimeout);
-        }
-        return;
-    }
-    async acquire(promises = this.connections) {
-        while (!promises.isEmpty()) {
-            const item = promises.peek();
-            item().catch((...args) => {
-                Promise.reject(...args);
-            });
-            promises.pop();
-        }
-        return Promise.resolve(true);
-    }
     static chunk(array, chunks) {
         let index = 0;
         let resIndex = 0;
-        const result = Array(Math.ceil(array.length / chunks));
+        const result = new Array(Math.ceil(array.length / chunks));
         while (index < array.length) {
             result[resIndex] = array.slice(index, (index += chunks));
             resIndex++;
@@ -258,4 +76,4 @@ class SequentialBucket {
         return result;
     }
 }
-exports.SequentialBucket = SequentialBucket;
+exports.DynamicBucket = DynamicBucket;

package/lib/websocket/structures/timeout.d.ts

@@ -15,6 +15,6 @@ export declare class ConnectQueue {
     }[];
     protected interval?: NodeJS.Timeout;
     constructor(intervalTime?: number, concurrency?: number);
-    push(callback: () => any): void;
-    shift(): any;
+    push(callback: () => any): Promise<void>;
+    shift(): Promise<any>;
 }

package/lib/websocket/structures/timeout.js

@@ -40,11 +40,11 @@ class ConnectQueue {
         this.intervalTime = intervalTime;
         this.concurrency = concurrency;
     }
-    push(callback) {
+    async push(callback) {
         this.queue.push({ cb: callback });
         if (this.queue.length === this.concurrency) {
             for (let i = 0; i < this.concurrency; i++) {
-                this.queue[i].cb?.();
+                await this.queue[i].cb?.();
                 this.queue[i].cb = undefined;
             }
             this.interval = setInterval(() => {
@@ -54,7 +54,7 @@ class ConnectQueue {
             }, this.intervalTime);
         }
     }
-    shift() {
+    async shift() {
         const shift = this.queue.shift();
         if (!shift) {
             if (!this.queue.length) {
@@ -65,7 +65,7 @@ class ConnectQueue {
         }
         if (!shift.cb)
             return this.shift();
-        shift.cb?.();
+        await shift.cb?.();
         if (!this.queue.length) {
             clearInterval(this.interval);
             this.interval = undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "seyfert",
-	"version": "1.2.0",
+	"version": "1.2.2",
 	"description": "The most advanced framework for discord bots",
 	"main": "./lib/index.js",
 	"module": "./lib/index.js",
@@ -71,4 +71,4 @@
 			"url": "https://github.com/socram03"
 		}
 	]
-}
+}