elynn-baileys 1.0.1

package/lib/Discord/rest/Bucket.cjs

@@ -0,0 +1,77 @@
+"use strict";
+/** @module Bucket */
+/**
+ * lovingly borrowed from eris
+ * https://github.com/abalabahaha/eris/blob/dev/lib/util/Bucket.js (eb403730855714eafa36c541dbe2cb84c9979158)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/** A bucket. */
+class Bucket {
+    _queue = [];
+    interval;
+    lastReset;
+    lastSend;
+    latencyRef;
+    reservedTokens;
+    timeout;
+    tokenLimit;
+    tokens;
+    constructor(tokenLimit, interval, options) {
+        this.tokenLimit = tokenLimit;
+        this.interval = interval;
+        this.latencyRef = options?.latencyRef ?? { latency: 0 };
+        this.lastReset = this.tokens = this.lastSend = 0;
+        this.reservedTokens = options?.reservedTokens ?? 0;
+        this.timeout = null;
+    }
+    check() {
+        if (this.timeout || this._queue.length === 0) {
+            return;
+        }
+        if (this.lastReset + this.interval + this.tokenLimit * this.latencyRef.latency < Date.now()) {
+            this.lastReset = Date.now();
+            this.tokens = Math.max(0, this.tokens - this.tokenLimit);
+        }
+        let val;
+        let tokensAvailable = this.tokens < this.tokenLimit;
+        let unreservedTokensAvailable = this.tokens < (this.tokenLimit - this.reservedTokens);
+        while (this._queue.length !== 0 && (unreservedTokensAvailable || (tokensAvailable && this._queue[0].priority))) {
+            this.tokens++;
+            tokensAvailable = this.tokens < this.tokenLimit;
+            unreservedTokensAvailable = this.tokens < (this.tokenLimit - this.reservedTokens);
+            const item = this._queue.shift();
+            val = this.latencyRef.latency - Date.now() + this.lastSend;
+            if (this.latencyRef.latency === 0 || val <= 0) {
+                item.func();
+                this.lastSend = Date.now();
+            }
+            else {
+                setTimeout(() => {
+                    item.func();
+                }, val);
+                this.lastSend = Date.now() + val;
+            }
+        }
+        if (this._queue.length !== 0 && !this.timeout) {
+            this.timeout = setTimeout(() => {
+                this.timeout = null;
+                this.check();
+            }, this.tokens < this.tokenLimit ? this.latencyRef.latency : Math.max(0, this.lastReset + this.interval + this.tokenLimit * this.latencyRef.latency - Date.now()));
+        }
+    }
+    /**
+     * Add an item to the queue.
+     * @param func The function to queue.
+     * @param priority If true, the item will be added to the front of the queue.
+     */
+    queue(func, priority = false) {
+        if (priority) {
+            this._queue.unshift({ func, priority });
+        }
+        else {
+            this._queue.push({ func, priority });
+        }
+        this.check();
+    }
+}
+exports.default = Bucket;

package/lib/Discord/rest/Bucket.d.ts

@@ -0,0 +1,32 @@
+/** @module Bucket */
+/**
+ * lovingly borrowed from eris
+ * https://github.com/abalabahaha/eris/blob/dev/lib/util/Bucket.js (eb403730855714eafa36c541dbe2cb84c9979158)
+ */
+/** A bucket. */
+export default class Bucket {
+    private _queue;
+    interval: number;
+    lastReset: number;
+    lastSend: number;
+    latencyRef: {
+        latency: number;
+    };
+    reservedTokens: number;
+    timeout: NodeJS.Timeout | null;
+    tokenLimit: number;
+    tokens: number;
+    constructor(tokenLimit: number, interval: number, options?: {
+        latencyRef?: {
+            latency: number;
+        };
+        reservedTokens?: number;
+    });
+    private check;
+    /**
+     * Add an item to the queue.
+     * @param func The function to queue.
+     * @param priority If true, the item will be added to the front of the queue.
+     */
+    queue(func: () => void, priority?: boolean): void;
+}

package/lib/Discord/rest/Bucket.js

@@ -0,0 +1,77 @@
+"use strict";
+/** @module Bucket */
+/**
+ * lovingly borrowed from eris
+ * https://github.com/abalabahaha/eris/blob/dev/lib/util/Bucket.js (eb403730855714eafa36c541dbe2cb84c9979158)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/** A bucket. */
+class Bucket {
+    _queue = [];
+    interval;
+    lastReset;
+    lastSend;
+    latencyRef;
+    reservedTokens;
+    timeout;
+    tokenLimit;
+    tokens;
+    constructor(tokenLimit, interval, options) {
+        this.tokenLimit = tokenLimit;
+        this.interval = interval;
+        this.latencyRef = options?.latencyRef ?? { latency: 0 };
+        this.lastReset = this.tokens = this.lastSend = 0;
+        this.reservedTokens = options?.reservedTokens ?? 0;
+        this.timeout = null;
+    }
+    check() {
+        if (this.timeout || this._queue.length === 0) {
+            return;
+        }
+        if (this.lastReset + this.interval + this.tokenLimit * this.latencyRef.latency < Date.now()) {
+            this.lastReset = Date.now();
+            this.tokens = Math.max(0, this.tokens - this.tokenLimit);
+        }
+        let val;
+        let tokensAvailable = this.tokens < this.tokenLimit;
+        let unreservedTokensAvailable = this.tokens < (this.tokenLimit - this.reservedTokens);
+        while (this._queue.length !== 0 && (unreservedTokensAvailable || (tokensAvailable && this._queue[0].priority))) {
+            this.tokens++;
+            tokensAvailable = this.tokens < this.tokenLimit;
+            unreservedTokensAvailable = this.tokens < (this.tokenLimit - this.reservedTokens);
+            const item = this._queue.shift();
+            val = this.latencyRef.latency - Date.now() + this.lastSend;
+            if (this.latencyRef.latency === 0 || val <= 0) {
+                item.func();
+                this.lastSend = Date.now();
+            }
+            else {
+                setTimeout(() => {
+                    item.func();
+                }, val);
+                this.lastSend = Date.now() + val;
+            }
+        }
+        if (this._queue.length !== 0 && !this.timeout) {
+            this.timeout = setTimeout(() => {
+                this.timeout = null;
+                this.check();
+            }, this.tokens < this.tokenLimit ? this.latencyRef.latency : Math.max(0, this.lastReset + this.interval + this.tokenLimit * this.latencyRef.latency - Date.now()));
+        }
+    }
+    /**
+     * Add an item to the queue.
+     * @param func The function to queue.
+     * @param priority If true, the item will be added to the front of the queue.
+     */
+    queue(func, priority = false) {
+        if (priority) {
+            this._queue.unshift({ func, priority });
+        }
+        else {
+            this._queue.push({ func, priority });
+        }
+        this.check();
+    }
+}
+exports.default = Bucket;

package/lib/Discord/rest/DiscordHTTPError.cjs

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @module DiscordHTTPError */
+const DiscordRESTError_1 = __importDefault(require("./DiscordRESTError.cjs"));
+/** An HTTP error received from Discord. */
+class DiscordHTTPError extends Error {
+    method;
+    name = "DiscordHTTPError";
+    resBody;
+    response;
+    constructor(res, resBody, method, stack) {
+        // eslint-disable-next-line unicorn/custom-error-definition
+        super();
+        Object.defineProperties(this, {
+            method: {
+                value: method,
+                enumerable: false
+            },
+            response: {
+                value: res,
+                enumerable: false
+            },
+            resBody: {
+                value: resBody,
+                enumerable: false
+            }
+        });
+        let message = `${res.status} ${res.statusText} on ${this.method} ${this.path}`;
+        const errors = DiscordRESTError_1.default.flattenErrors(resBody);
+        if (errors.length !== 0) {
+            message += `\n  ${errors.join("\n  ")}`;
+        }
+        this.message = message;
+        if (stack) {
+            this.stack = this.name + ": " + this.message + "\n" + stack;
+        }
+        else {
+            Error.captureStackTrace(this, DiscordHTTPError);
+        }
+    }
+    get headers() {
+        return this.response.headers;
+    }
+    get path() {
+        return new URL(this.response.url).pathname;
+    }
+    get status() {
+        return this.response.status;
+    }
+    get statusText() {
+        return this.response.statusText;
+    }
+    toJSON() {
+        return {
+            message: this.message,
+            method: this.method,
+            name: this.name,
+            resBody: this.resBody,
+            stack: this.stack ?? ""
+        };
+    }
+}
+exports.default = DiscordHTTPError;

package/lib/Discord/rest/DiscordHTTPError.d.ts

@@ -0,0 +1,15 @@
+import type * as Types from "../types/namespaced";
+import type { RESTMethod } from "../Constants";
+/** An HTTP error received from Discord. */
+export default class DiscordHTTPError extends Error {
+    method: RESTMethod;
+    name: string;
+    resBody: Record<string, unknown> | null;
+    response: Response;
+    constructor(res: Response, resBody: unknown, method: RESTMethod, stack?: string);
+    get headers(): Headers;
+    get path(): string;
+    get status(): number;
+    get statusText(): string;
+    toJSON(): Types.JSON.JSONDiscordHTTPError;
+}

package/lib/Discord/rest/DiscordHTTPError.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @module DiscordHTTPError */
+const DiscordRESTError_1 = __importDefault(require("./DiscordRESTError"));
+/** An HTTP error received from Discord. */
+class DiscordHTTPError extends Error {
+    method;
+    name = "DiscordHTTPError";
+    resBody;
+    response;
+    constructor(res, resBody, method, stack) {
+        // eslint-disable-next-line unicorn/custom-error-definition
+        super();
+        Object.defineProperties(this, {
+            method: {
+                value: method,
+                enumerable: false
+            },
+            response: {
+                value: res,
+                enumerable: false
+            },
+            resBody: {
+                value: resBody,
+                enumerable: false
+            }
+        });
+        let message = `${res.status} ${res.statusText} on ${this.method} ${this.path}`;
+        const errors = DiscordRESTError_1.default.flattenErrors(resBody);
+        if (errors.length !== 0) {
+            message += `\n  ${errors.join("\n  ")}`;
+        }
+        this.message = message;
+        if (stack) {
+            this.stack = this.name + ": " + this.message + "\n" + stack;
+        }
+        else {
+            Error.captureStackTrace(this, DiscordHTTPError);
+        }
+    }
+    get headers() {
+        return this.response.headers;
+    }
+    get path() {
+        return new URL(this.response.url).pathname;
+    }
+    get status() {
+        return this.response.status;
+    }
+    get statusText() {
+        return this.response.statusText;
+    }
+    toJSON() {
+        return {
+            message: this.message,
+            method: this.method,
+            name: this.name,
+            resBody: this.resBody,
+            stack: this.stack ?? ""
+        };
+    }
+}
+exports.default = DiscordHTTPError;

package/lib/Discord/rest/DiscordRESTError.cjs

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/** A REST error received from Discord. */
+class DiscordRESTError extends Error {
+    code;
+    method;
+    name = "DiscordRESTError";
+    resBody;
+    response;
+    constructor(res, resBody, method, stack) {
+        // eslint-disable-next-line unicorn/custom-error-definition
+        super();
+        this.code = Number(resBody.code);
+        Object.defineProperties(this, {
+            method: {
+                value: method,
+                enumerable: false
+            },
+            response: {
+                value: res,
+                enumerable: false
+            },
+            resBody: {
+                value: resBody,
+                enumerable: false
+            }
+        });
+        let message = "message" in resBody ? `${resBody.message} on ${this.method} ${this.path}` : `Unknown Error on ${this.method} ${this.path}`;
+        if ("errors" in resBody) {
+            message += `\n ${DiscordRESTError.flattenErrors(resBody.errors).join("\n ")}`;
+        }
+        else {
+            const errors = DiscordRESTError.flattenErrors(resBody);
+            if (errors.length !== 0) {
+                message += `\n ${errors.join("\n ")}`;
+            }
+        }
+        this.message = message;
+        if (stack) {
+            this.stack = `${this.name}: ${this.message}\n${stack}`;
+        }
+        else {
+            Error.captureStackTrace(this, DiscordRESTError);
+        }
+    }
+    static flattenErrors(errors, keyPrefix = "") {
+        let messages = [];
+        for (const fieldName in errors) {
+            if (!Object.hasOwn(errors, fieldName) || fieldName === "message" || fieldName === "code") {
+                continue;
+            }
+            if (typeof errors[fieldName] === "object" && errors[fieldName] !== null) {
+                if ("_errors" in errors[fieldName]) {
+                    messages = messages.concat(errors[fieldName]._errors.map((err) => `${`${keyPrefix}${fieldName}`}: ${err.message}`));
+                }
+                else if (Array.isArray(errors[fieldName])) {
+                    messages = messages.concat(errors[fieldName].map(str => `${`${keyPrefix}${fieldName}`}: ${typeof str === "object" && "message" in str ? str.message : str}`));
+                }
+                else {
+                    messages = messages.concat(DiscordRESTError.flattenErrors(errors[fieldName], `${keyPrefix}${fieldName}.`));
+                }
+            }
+        }
+        return messages;
+    }
+    get headers() {
+        return this.response.headers;
+    }
+    get path() {
+        return new URL(this.response.url).pathname;
+    }
+    get status() {
+        return this.response.status;
+    }
+    get statusText() {
+        return this.response.statusText;
+    }
+    toJSON() {
+        return {
+            message: this.message,
+            method: this.method,
+            name: this.name,
+            resBody: this.resBody,
+            stack: this.stack ?? ""
+        };
+    }
+}
+exports.default = DiscordRESTError;

package/lib/Discord/rest/DiscordRESTError.d.ts

@@ -0,0 +1,18 @@
+/** @module DiscordRESTError */
+import type * as Types from "../types/namespaced";
+import type { RESTMethod } from "../Constants";
+/** A REST error received from Discord. */
+export default class DiscordRESTError extends Error {
+    code: number;
+    method: RESTMethod;
+    name: string;
+    resBody: Record<string, unknown> | null;
+    response: Response;
+    constructor(res: Response, resBody: Record<string, unknown>, method: RESTMethod, stack?: string);
+    static flattenErrors(errors: Record<string, unknown>, keyPrefix?: string): Array<string>;
+    get headers(): Headers;
+    get path(): string;
+    get status(): number;
+    get statusText(): string;
+    toJSON(): Types.JSON.JSONDiscordRESTError;
+}

package/lib/Discord/rest/DiscordRESTError.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/** A REST error received from Discord. */
+class DiscordRESTError extends Error {
+    code;
+    method;
+    name = "DiscordRESTError";
+    resBody;
+    response;
+    constructor(res, resBody, method, stack) {
+        // eslint-disable-next-line unicorn/custom-error-definition
+        super();
+        this.code = Number(resBody.code);
+        Object.defineProperties(this, {
+            method: {
+                value: method,
+                enumerable: false
+            },
+            response: {
+                value: res,
+                enumerable: false
+            },
+            resBody: {
+                value: resBody,
+                enumerable: false
+            }
+        });
+        let message = "message" in resBody ? `${resBody.message} on ${this.method} ${this.path}` : `Unknown Error on ${this.method} ${this.path}`;
+        if ("errors" in resBody) {
+            message += `\n ${DiscordRESTError.flattenErrors(resBody.errors).join("\n ")}`;
+        }
+        else {
+            const errors = DiscordRESTError.flattenErrors(resBody);
+            if (errors.length !== 0) {
+                message += `\n ${errors.join("\n ")}`;
+            }
+        }
+        this.message = message;
+        if (stack) {
+            this.stack = `${this.name}: ${this.message}\n${stack}`;
+        }
+        else {
+            Error.captureStackTrace(this, DiscordRESTError);
+        }
+    }
+    static flattenErrors(errors, keyPrefix = "") {
+        let messages = [];
+        for (const fieldName in errors) {
+            if (!Object.hasOwn(errors, fieldName) || fieldName === "message" || fieldName === "code") {
+                continue;
+            }
+            if (typeof errors[fieldName] === "object" && errors[fieldName] !== null) {
+                if ("_errors" in errors[fieldName]) {
+                    messages = messages.concat(errors[fieldName]._errors.map((err) => `${`${keyPrefix}${fieldName}`}: ${err.message}`));
+                }
+                else if (Array.isArray(errors[fieldName])) {
+                    messages = messages.concat(errors[fieldName].map(str => `${`${keyPrefix}${fieldName}`}: ${typeof str === "object" && "message" in str ? str.message : str}`));
+                }
+                else {
+                    messages = messages.concat(DiscordRESTError.flattenErrors(errors[fieldName], `${keyPrefix}${fieldName}.`));
+                }
+            }
+        }
+        return messages;
+    }
+    get headers() {
+        return this.response.headers;
+    }
+    get path() {
+        return new URL(this.response.url).pathname;
+    }
+    get status() {
+        return this.response.status;
+    }
+    get statusText() {
+        return this.response.statusText;
+    }
+    toJSON() {
+        return {
+            message: this.message,
+            method: this.method,
+            name: this.name,
+            resBody: this.resBody,
+            stack: this.stack ?? ""
+        };
+    }
+}
+exports.default = DiscordRESTError;