seyfert 1.2.1 → 1.2.2

package/lib/websocket/discord/shard.js

@@ -23,7 +23,7 @@ class Shard {
         ack: true,
     };
     bucket;
-    offlineSendQueue = new structures_1.PriorityQueue();
+    offlineSendQueue = [];
     constructor(id, options) {
         this.id = id;
         this.options = options;
@@ -34,12 +34,7 @@ class Shard {
         if (options.debugger)
             this.debugger = options.debugger;
         const safe = this.calculateSafeRequests();
-        this.bucket = new structures_1.DynamicBucket({
-            limit: safe,
-            refillAmount: safe,
-            refillInterval: 6e4,
-            debugger: this.debugger,
-        });
+        this.bucket = new structures_1.DynamicBucket({ refillInterval: 6e4, limit: safe, debugger: options.debugger });
     }
     get latency() {
         return this.heart.lastAck && this.heart.lastBeat
@@ -76,7 +71,7 @@ class Shard {
             this.heart.ack = true;
         };
     }
-    async send(priority, message) {
+    async send(force, message) {
         this.debugger?.info(`[Shard #${this.id}] Sending: ${v10_1.GatewayOpcodes[message.op]} ${JSON.stringify(message.d, (_, value) => {
             if (typeof value === 'string')
                 return value.replace(this.options.token, v => {
@@ -85,13 +80,13 @@ class Shard {
                 });
             return value;
         }, 1)}`);
-        await this.checkOffline(priority);
-        await this.bucket.acquire(priority);
-        await this.checkOffline(priority);
+        await this.checkOffline(force);
+        await this.bucket.acquire(force);
+        await this.checkOffline(force);
         this.websocket?.send(JSON.stringify(message));
     }
     async identify() {
-        await this.send(0, {
+        await this.send(true, {
             op: v10_1.GatewayOpcodes.Identify,
             d: {
                 token: `Bot ${this.options.token}`,
@@ -107,7 +102,7 @@ class Shard {
         return !!(this.data.resume_gateway_url && this.data.session_id && this.data.resumeSeq !== null);
     }
     async resume() {
-        await this.send(0, {
+        await this.send(true, {
             op: v10_1.GatewayOpcodes.Resume,
             d: {
                 seq: this.data.resumeSeq,
@@ -185,13 +180,13 @@ class Shard {
                 {
                     switch (packet.t) {
                         case v10_1.GatewayDispatchEvents.Resumed:
-                            this.offlineSendQueue.toArray().map((resolve) => resolve());
+                            this.offlineSendQueue.map((resolve) => resolve());
                             this.options.handlePayload(this.id, packet);
                             break;
                         case v10_1.GatewayDispatchEvents.Ready: {
                             this.data.resume_gateway_url = packet.d.resume_gateway_url;
                             this.data.session_id = packet.d.session_id;
-                            this.offlineSendQueue.toArray().map((resolve) => resolve());
+                            this.offlineSendQueue.map((resolve) => resolve());
                             this.options.handlePayload(this.id, packet);
                             break;
                         }
@@ -251,9 +246,9 @@ class Shard {
         }
         return this.onpacket(JSON.parse(data));
     }
-    checkOffline(priority) {
+    checkOffline(force) {
         if (!this.isOpen) {
-            return new Promise(resolve => this.offlineSendQueue.push(resolve, priority));
+            return new Promise(resolve => this.offlineSendQueue[force ? 'unshift' : 'push'](resolve));
         }
         return Promise.resolve();
     }

package/lib/websocket/discord/sharder.d.ts

@@ -22,7 +22,7 @@ export declare class ShardManager extends Map<number, Shard> {
     disconnect(shardId: number): Promise<void> | undefined;
     disconnectAll(): Promise<unknown>;
     setShardPresence(shardId: number, payload: GatewayUpdatePresence['d']): void;
-    setPresence(payload: GatewayUpdatePresence['d']): Promise<void> | undefined;
+    setPresence(payload: GatewayUpdatePresence['d']): Promise<void>;
     joinVoice(guild_id: string, channel_id: string, options: ObjectToLower<Pick<GatewayVoiceStateUpdate['d'], 'self_deaf' | 'self_mute'>>): void;
     leaveVoice(guild_id: string): void;
     send<T extends GatewaySendPayload>(shardId: number, payload: T): void;

package/lib/websocket/discord/sharder.js

@@ -82,7 +82,7 @@ class ShardManager extends Map {
      */
     spawnBuckets() {
         this.debugger?.info('#0 Preparing buckets');
-        const chunks = structures_1.SequentialBucket.chunk(new Array(this.shardEnd - this.shardStart), this.concurrency);
+        const chunks = structures_1.DynamicBucket.chunk(new Array(this.shardEnd - this.shardStart), this.concurrency);
         chunks.forEach((arr, index) => {
             for (let i = 0; i < arr.length; i++) {
                 const id = i + (index > 0 ? index * this.concurrency : 0) + this.shardStart;
@@ -155,7 +155,7 @@ class ShardManager extends Map {
                 payload,
             });
         }
-        this.get(shardId)?.send(1, payload);
+        this.get(shardId)?.send(false, payload);
     }
 }
 exports.ShardManager = ShardManager;

package/lib/websocket/discord/workermanager.js

@@ -83,7 +83,7 @@ class WorkerManager extends Map {
     }
     prepareSpaces() {
         this.debugger?.info('Preparing buckets');
-        const chunks = structures_1.SequentialBucket.chunk(new Array(this.shardEnd - this.shardStart), this.options.shardsPerWorker);
+        const chunks = structures_1.DynamicBucket.chunk(new Array(this.shardEnd - this.shardStart), this.options.shardsPerWorker);
         chunks.forEach((shards, index) => {
             for (let i = 0; i < shards.length; i++) {
                 const id = i + (index > 0 ? index * this.options.shardsPerWorker : 0) + this.shardStart;

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

@@ -1,117 +1,24 @@
 /// <reference types="node" />
-import type { Logger } from '../../common';
-/**
- * just any kind of request to queue and resolve later
- */
-export type QueuedRequest = (value: void | Promise<void>) => Promise<unknown> | any;
+import { type Logger } from '../../common';
 /**
  * options of the dynamic bucket
  */
 export interface DynamicBucketOptions {
     limit: number;
     refillInterval: number;
-    refillAmount: number;
     debugger?: Logger;
 }
-/**
- * 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
- */
 export declare class DynamicBucket {
-    limit: number;
-    refillInterval: number;
-    refillAmount: number;
-    /** The queue of requests to acquire an available request. Mapped by <shardId, resolve()> */
-    queue: PriorityQueue<QueuedRequest>;
-    /** The amount of requests that have been used up already. */
+    options: DynamicBucketOptions;
+    queue: ((value?: unknown) => any)[];
     used: number;
-    /** 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. */
+    processing?: boolean;
     refillsAt?: number;
-    debugger?: Logger;
+    timeoutId?: NodeJS.Timeout;
     constructor(options: DynamicBucketOptions);
     get remaining(): number;
     refill(): void;
-    /** Begin processing the queue. */
     processQueue(): Promise<void>;
-    /** Pauses the execution until the request is available to be made. */
-    acquire(priority: number): Promise<void>;
-    toString(): string;
-}
-/**
- * abstract node lol
- */
-export interface AbstractNode<T> {
-    data: T;
-    next: this | null;
-}
-export interface QueuePusher<T> {
-    push(data: T): NonNullable<TNode<T>>;
-}
-export interface QueuePusherWithPriority<T> {
-    push(data: T, priority: number): NonNullable<PNode<T>>;
-}
-export declare class TNode<T> implements AbstractNode<T> {
-    data: T;
-    next: this | null;
-    constructor(data: T);
-    static null<T>(list: AbstractNode<T> | null): list is null;
-}
-export declare class PNode<T> extends TNode<T> {
-    priority: number;
-    constructor(data: T, priority: number);
-}
-export declare abstract class Queue<T> {
-    protected abstract head: AbstractNode<T> | null;
-    /**
-     * O(1)
-     */
-    pop(): AbstractNode<T> | null;
-    /**
-     * O(1)
-     */
-    peek(): T;
-    /**
-     * O(n)
-     */
-    size(): number;
-    /**
-     * O(1)
-     */
-    isEmpty(): boolean;
-    [Symbol.iterator](): IterableIterator<T>;
-    toArray(): T[];
-    toString(): string;
-}
-export declare class LinkedList<T> extends Queue<T> implements QueuePusher<T> {
-    protected head: TNode<T> | null;
-    /**
-     * O(1)
-     */
-    push(data: T): NonNullable<TNode<T>>;
-}
-export declare class PriorityQueue<T> extends Queue<T> implements QueuePusherWithPriority<T> {
-    protected head: PNode<T> | null;
-    /**
-     * O(#priorities)
-     */
-    push(data: T, priority: number): NonNullable<PNode<T>>;
-}
-export declare class SequentialBucket {
-    private connections;
-    private capacity;
-    private spawnTimeout;
-    constructor(maxCapacity: number);
-    destroy(): Promise<void>;
-    push(promise: QueuedRequest): Promise<void>;
-    acquire(promises?: LinkedList<QueuedRequest>): Promise<boolean>;
+    acquire(force?: boolean): Promise<unknown>;
     static chunk<T>(array: T[], chunks: number): T[][];
 }

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.1",
+	"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"
 		}
 	]
-}
+}