seyfert 1.2.1 → 1.2.3

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

@@ -9,18 +9,15 @@ class ConnectTimeout {
         this.intervalTime = intervalTime;
     }
     wait() {
-        let resolve = (_x) => {
-            //
-        };
-        const promise = new Promise(r => (resolve = r));
-        if (!this.promises.length) {
-            this.interval = setInterval(() => {
-                this.shift();
-            }, this.intervalTime);
-            resolve(true);
-        }
-        this.promises.push(resolve);
-        return promise;
+        return new Promise(res => {
+            if (!this.promises.length) {
+                this.interval = setInterval(() => {
+                    this.shift();
+                }, this.intervalTime);
+                res(true);
+            }
+            this.promises.push(res);
+        });
     }
     shift() {
         this.promises.shift()?.(true);
@@ -40,11 +37,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 +51,7 @@ class ConnectQueue {
             }, this.intervalTime);
         }
     }
-    shift() {
+    async shift() {
         const shift = this.queue.shift();
         if (!shift) {
             if (!this.queue.length) {
@@ -65,7 +62,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.3",
 	"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"
 		}
 	]
-}
+}

package/lib/api/CDN.d.ts

@@ -1,212 +0,0 @@
-import { type ImageExtension, type ImageSize, type StickerExtension } from './utils/constants.js';
-/**
- * The options used for image URLs
- */
-export interface BaseImageURLOptions {
-    /**
-     * The extension to use for the image URL
-     *
-     * @defaultValue `'webp'`
-     */
-    extension?: ImageExtension;
-    /**
-     * The size specified in the image URL
-     */
-    size?: ImageSize;
-}
-/**
- * The options used for image URLs with animated content
- */
-export interface ImageURLOptions extends BaseImageURLOptions {
-    /**
-     * Whether or not to prefer the static version of an image asset.
-     */
-    forceStatic?: boolean;
-}
-/**
- * The options to use when making a CDN URL
- */
-export interface MakeURLOptions {
-    /**
-     * The allowed extensions that can be used
-     */
-    allowedExtensions?: readonly string[];
-    /**
-     * The extension to use for the image URL
-     *
-     * @defaultValue `'webp'`
-     */
-    extension?: ImageExtension | StickerExtension | undefined;
-    /**
-     * The size specified in the image URL
-     */
-    size?: ImageSize;
-}
-/**
- * The CDN link builder
- */
-export declare class CDN {
-    private readonly base;
-    constructor(base?: string);
-    /**
-     * Generates an app asset URL for a client's asset.
-     *
-     * @param clientId - The client id that has the asset
-     * @param assetHash - The hash provided by Discord for this asset
-     * @param options - Optional options for the asset
-     */
-    appAsset(clientId: string, assetHash: string, options?: Readonly<BaseImageURLOptions>): string;
-    /**
-     * Generates an app icon URL for a client's icon.
-     *
-     * @param clientId - The client id that has the icon
-     * @param iconHash - The hash provided by Discord for this icon
-     * @param options - Optional options for the icon
-     */
-    appIcon(clientId: string, iconHash: string, options?: Readonly<BaseImageURLOptions>): string;
-    /**
-     * Generates an avatar URL, e.g. for a user or a webhook.
-     *
-     * @param id - The id that has the icon
-     * @param avatarHash - The hash provided by Discord for this avatar
-     * @param options - Optional options for the avatar
-     */
-    avatar(id: string, avatarHash: string, options?: Readonly<ImageURLOptions>): string;
-    /**
-     * Generates a user avatar decoration URL.
-     *
-     * @param userId - The id of the user
-     * @param userAvatarDecoration - The hash provided by Discord for this avatar decoration
-     * @param options - Optional options for the avatar decoration
-     */
-    avatarDecoration(userId: string, userAvatarDecoration: string, options?: Readonly<BaseImageURLOptions>): string;
-    /**
-     * Generates a banner URL, e.g. for a user or a guild.
-     *
-     * @param id - The id that has the banner splash
-     * @param bannerHash - The hash provided by Discord for this banner
-     * @param options - Optional options for the banner
-     */
-    banner(id: string, bannerHash: string, options?: Readonly<ImageURLOptions>): string;
-    /**
-     * Generates an icon URL for a channel, e.g. a group DM.
-     *
-     * @param channelId - The channel id that has the icon
-     * @param iconHash - The hash provided by Discord for this channel
-     * @param options - Optional options for the icon
-     */
-    channelIcon(channelId: string, iconHash: string, options?: Readonly<BaseImageURLOptions>): string;
-    /**
-     * Generates a default avatar URL
-     *
-     * @param index - The default avatar index
-     * @remarks
-     * To calculate the index for a user do `(userId >> 22) % 6`,
-     * or `discriminator % 5` if they're using the legacy username system.
-     */
-    defaultAvatar(index: number): string;
-    /**
-     * Generates a discovery splash URL for a guild's discovery splash.
-     *
-     * @param guildId - The guild id that has the discovery splash
-     * @param splashHash - The hash provided by Discord for this splash
-     * @param options - Optional options for the splash
-     */
-    discoverySplash(guildId: string, splashHash: string, options?: Readonly<BaseImageURLOptions>): string;
-    /**
-     * Generates an emoji's URL for an emoji.
-     *
-     * @param emojiId - The emoji id
-     * @param options - Optional options for the emoji
-     */
-    emoji(emojiId: string, options?: Readonly<BaseImageURLOptions>): string;
-    /**
-     * Generates a guild member avatar URL.
-     *
-     * @param guildId - The id of the guild
-     * @param userId - The id of the user
-     * @param avatarHash - The hash provided by Discord for this avatar
-     * @param options - Optional options for the avatar
-     */
-    guildMemberAvatar(guildId: string, userId: string, avatarHash: string, options?: Readonly<ImageURLOptions>): string;
-    /**
-     * Generates a guild member banner URL.
-     *
-     * @param guildId - The id of the guild
-     * @param userId - The id of the user
-     * @param bannerHash - The hash provided by Discord for this banner
-     * @param options - Optional options for the banner
-     */
-    guildMemberBanner(guildId: string, userId: string, bannerHash: string, options?: Readonly<ImageURLOptions>): string;
-    /**
-     * Generates an icon URL, e.g. for a guild.
-     *
-     * @param id - The id that has the icon splash
-     * @param iconHash - The hash provided by Discord for this icon
-     * @param options - Optional options for the icon
-     */
-    icon(id: string, iconHash: string, options?: Readonly<ImageURLOptions>): string;
-    /**
-     * Generates a URL for the icon of a role
-     *
-     * @param roleId - The id of the role that has the icon
-     * @param roleIconHash - The hash provided by Discord for this role icon
-     * @param options - Optional options for the role icon
-     */
-    roleIcon(roleId: string, roleIconHash: string, options?: Readonly<BaseImageURLOptions>): string;
-    /**
-     * Generates a guild invite splash URL for a guild's invite splash.
-     *
-     * @param guildId - The guild id that has the invite splash
-     * @param splashHash - The hash provided by Discord for this splash
-     * @param options - Optional options for the splash
-     */
-    splash(guildId: string, splashHash: string, options?: Readonly<BaseImageURLOptions>): string;
-    /**
-     * Generates a sticker URL.
-     *
-     * @param stickerId - The sticker id
-     * @param extension - The extension of the sticker
-     * @privateRemarks
-     * Stickers cannot have a `.webp` extension, so we default to a `.png`
-     */
-    sticker(stickerId: string, extension?: StickerExtension): string;
-    /**
-     * Generates a sticker pack banner URL.
-     *
-     * @param bannerId - The banner id
-     * @param options - Optional options for the banner
-     */
-    stickerPackBanner(bannerId: string, options?: Readonly<BaseImageURLOptions>): string;
-    /**
-     * Generates a team icon URL for a team's icon.
-     *
-     * @param teamId - The team id that has the icon
-     * @param iconHash - The hash provided by Discord for this icon
-     * @param options - Optional options for the icon
-     */
-    teamIcon(teamId: string, iconHash: string, options?: Readonly<BaseImageURLOptions>): string;
-    /**
-     * Generates a cover image for a guild scheduled event.
-     *
-     * @param scheduledEventId - The scheduled event id
-     * @param coverHash - The hash provided by discord for this cover image
-     * @param options - Optional options for the cover image
-     */
-    guildScheduledEventCover(scheduledEventId: string, coverHash: string, options?: Readonly<BaseImageURLOptions>): string;
-    /**
-     * Constructs the URL for the resource, checking whether or not `hash` starts with `a_` if `dynamic` is set to `true`.
-     *
-     * @param route - The base cdn route
-     * @param hash - The hash provided by Discord for this icon
-     * @param options - Optional options for the link
-     */
-    private dynamicMakeURL;
-    /**
-     * Constructs the URL for the resource
-     *
-     * @param route - The base cdn route
-     * @param options - The extension/size options for the link
-     */
-    private makeURL;
-}