seyfert 0.1.0

package/lib/websocket/structures/index.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SequentialBucket = exports.PriorityQueue = exports.LinkedList = exports.Queue = exports.PNode = exports.TNode = 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. */
+    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. */
+    refillsAt;
+    debugger;
+    constructor(options) {
+        this.limit = options.limit;
+        this.refillInterval = options.refillInterval;
+        this.refillAmount = options.refillAmount;
+        if (options.debugger) {
+            this.debugger = options.debugger;
+        }
+    }
+    get remaining() {
+        if (this.limit < this.used) {
+            return 0;
+        }
+        return this.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.used > 0) {
+            if (this.timeoutId) {
+                clearTimeout(this.timeoutId);
+            }
+            this.timeoutId = setTimeout(() => {
+                this.refill();
+            }, this.refillInterval);
+            this.refillsAt = Date.now() + this.refillInterval;
+        }
+    }
+    /** Begin processing the queue. */
+    async processQueue() {
+        // There is already a queue that is processing
+        if (this.processing) {
+            return;
+        }
+        // Begin going through the queue.
+        while (!this.queue.isEmpty()) {
+            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.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;
+                }
+                // 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) {
+                    await (0, common_1.delay)(this.refillsAt - now);
+                }
+            }
+        }
+        // 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);
+            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));
+        while (index < array.length) {
+            result[resIndex] = array.slice(index, (index += chunks));
+            resIndex++;
+        }
+        return result;
+    }
+}
+exports.SequentialBucket = SequentialBucket;

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

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+export declare class ConnectTimeout {
+    intervalTime: number;
+    readonly promises: ((x: boolean) => any)[];
+    protected interval?: NodeJS.Timeout;
+    constructor(intervalTime?: number);
+    wait(): Promise<boolean>;
+    shift(): void;
+}
+export declare class ConnectQueue {
+    intervalTime: number;
+    concurrency: number;
+    readonly queue: {
+        cb: (() => any) | undefined;
+    }[];
+    protected interval?: NodeJS.Timeout;
+    constructor(intervalTime?: number, concurrency?: number);
+    push(callback: () => any): void;
+    shift(): any;
+}

package/lib/websocket/structures/timeout.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectQueue = exports.ConnectTimeout = void 0;
+class ConnectTimeout {
+    intervalTime;
+    promises = [];
+    interval = undefined;
+    constructor(intervalTime = 5000) {
+        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;
+    }
+    shift() {
+        this.promises.shift()?.(true);
+        if (!this.promises.length) {
+            clearInterval(this.interval);
+            this.interval = undefined;
+        }
+    }
+}
+exports.ConnectTimeout = ConnectTimeout;
+class ConnectQueue {
+    intervalTime;
+    concurrency;
+    queue = [];
+    interval = undefined;
+    constructor(intervalTime = 5000, concurrency = 1) {
+        this.intervalTime = intervalTime;
+        this.concurrency = concurrency;
+    }
+    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?.();
+                this.queue[i].cb = undefined;
+            }
+            this.interval = setInterval(() => {
+                for (let i = 0; i < this.concurrency; i++) {
+                    this.shift();
+                }
+            }, this.intervalTime);
+        }
+    }
+    shift() {
+        const shift = this.queue.shift();
+        if (!shift) {
+            if (!this.queue.length) {
+                clearInterval(this.interval);
+                this.interval = undefined;
+            }
+            return;
+        }
+        if (!shift.cb)
+            return this.shift();
+        shift.cb?.();
+        if (!this.queue.length) {
+            clearInterval(this.interval);
+            this.interval = undefined;
+        }
+    }
+}
+exports.ConnectQueue = ConnectQueue;

package/package.json

@@ -0,0 +1,70 @@
+{
+	"name": "seyfert",
+	"version": "0.1.0",
+	"main": "./lib/index.js",
+	"module": "./lib/index.js",
+	"types": "./lib/index.d.ts",
+	"files": [
+		"lib/**"
+	],
+	"scripts": {
+		"build": "tsc --outDir ./lib",
+		"dev": "swc src -d lib -w",
+		"prepublishOnly": "npm run build",
+		"prepare": "npm run build && husky install",
+		"lint": "biome lint --apply ./src",
+		"format": "biome format --write ./src",
+		"check-h": "biome check --apply ./src",
+		"check": "biome check --apply --changed --no-errors-on-unmatched ./src"
+	},
+	"author": "MARCROCK22",
+	"license": "ISC",
+	"dependencies": {
+		"@sapphire/async-queue": "^1.5.1",
+		"chokidar": "^3.5.3",
+		"discord-api-types": "^0.37.67",
+		"form-data": "^4.0.0",
+		"ioredis": "^5.3.2",
+		"magic-bytes.js": "^1.7.0",
+		"ts-mixer": "^6.0.3",
+		"ws": "^8.16.0"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "1.5.0",
+		"@swc/cli": "^0.1.63",
+		"@swc/core": "^1.3.102",
+		"@types/node": "^20.10.7",
+		"@types/ws": "^8.5.10",
+		"husky": "^8.0.3",
+		"nodemon": "^3.0.2",
+		"typescript": "^5.3.3"
+	},
+	"optionalDependencies": {
+		"tweetnacl": "^1.0.3",
+		"uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.39.0"
+	},
+	"homepage": "https://biscuitjs.com",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/potoland/potocuit.git"
+	},
+	"bugs": {
+		"url": "https://github.com/potoland/potocuit"
+	},
+	"keywords": [
+		"api",
+		"discord",
+		"bots",
+		"typescript",
+		"botdev"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"contributors": [
+		{
+			"name": "socram03",
+			"url": "https://github.com/socram03"
+		}
+	]
+}