elynn-baileys 1.0.1

package/lib/Discord/util/Time.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Time {
+    client;
+    /** When the first shard connect happened, reset if all shards disconnect. */
+    connect = null;
+    /** When all shards disconnected, reset on any shard connect. */
+    disconnect = null;
+    /** When the first shard ready happened, reset if all shards disconnect. */
+    ready = null;
+    /** When the most recent shard connect happened. */
+    shardConnect = null;
+    /** When the most recent shard disconnect happened. */
+    shardDisconnect = null;
+    /** When the most recent shard pre-ready happened. */
+    shardPreReady = null;
+    /** When the most recent shard ready happened. */
+    shardReady = null;
+    /** When the most recent shard resume happened. */
+    shardResume = null;
+    /** When the client started. */
+    start = null;
+    constructor(client) {
+        Object.defineProperty(this, "client", {
+            value: client,
+            writable: false,
+            enumerable: false,
+            configurable: false
+        });
+    }
+    /** @internal */
+    _setConnect(value) {
+        this.shardConnect = value;
+        this.disconnect = null;
+        if (!this.connect) {
+            this.connect = value;
+        }
+    }
+    /** @internal */
+    _setDisconnect(value) {
+        this.shardDisconnect = value;
+        const noneReady = this.client.shards.every(shard => !shard.ready);
+        if (noneReady) {
+            this.connect = null;
+            this.disconnect = value;
+            this.ready = null;
+            this.start = null;
+        }
+    }
+    /** @internal */
+    _setPreReady(value) {
+        this.shardPreReady = value;
+    }
+    /** @internal */
+    _setReady(value) {
+        this.shardReady = value;
+        if (!this.ready)
+            this.ready = value;
+    }
+    /** @internal */
+    _setResume(value) {
+        this.shardResume = value;
+    }
+    /** @internal */
+    _setStart(value) {
+        if (!this.start) {
+            this.start = value;
+        }
+    }
+    reset() {
+        this.connect = null;
+        this.disconnect = null;
+        this.ready = null;
+        this.start = null;
+        this.shardConnect = null;
+        this.shardDisconnect = null;
+        this.shardPreReady = null;
+        this.shardReady = null;
+        this.shardResume = null;
+    }
+    /** @internal */
+    set(type, value) {
+        switch (type) {
+            case "connect": return this._setConnect(value);
+            case "disconnect": return this._setDisconnect(value);
+            case "preReady": return this._setPreReady(value);
+            case "ready": return this._setReady(value);
+            case "resume": return this._setResume(value);
+            case "start": return this._setStart(value);
+        }
+    }
+}
+exports.default = Time;

package/lib/Discord/util/TypedCollection.cjs

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @module TypedCollection */
+const Collection_1 = __importDefault(require("./Collection.cjs"));
+const Base_1 = __importDefault(require("../structures/Base.cjs"));
+/** This is an internal class, you should not use it in your projects. If you want a collection type for your own projects, look at {@link Collection}. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+class TypedCollection extends Collection_1.default {
+    _baseObject;
+    extraOptions;
+    limit;
+    constructor(baseObject, client, limit = Infinity, extraOptions) {
+        super();
+        if (!(baseObject.prototype instanceof Base_1.default)) {
+            throw new TypeError("baseObject must be a class that extends Base.");
+        }
+        this._baseObject = baseObject;
+        this.limit = limit;
+        this.extraOptions = {
+            construct: extraOptions?.construct ?? ((data, ...extra) => new baseObject(data, client, ...extra)),
+            delete: extraOptions?.delete ?? (() => { })
+        };
+    }
+    /** @hidden */
+    add(value) {
+        if ("id" in value) {
+            if (this.limit === 0) {
+                return value;
+            }
+            this.set(value.id, value);
+            if (this.limit && this.size > this.limit) {
+                const iter = this.keys();
+                while (this.size > this.limit) {
+                    const val = iter.next().value;
+                    if (val === undefined) {
+                        break;
+                    }
+                    this.delete(val);
+                }
+            }
+            return value;
+        }
+        else {
+            const err = new Error(`${this.constructor.name}#add: value must have an id property`);
+            Object.defineProperty(err, "_object", { value });
+            throw err;
+        }
+    }
+    clear() {
+        for (const key of this.keys()) {
+            this.extraOptions.delete(key);
+        }
+        super.clear();
+    }
+    delete(key) {
+        this.extraOptions.delete(key);
+        return super.delete(key);
+    }
+    /** @hidden */
+    update(value, ...extra) {
+        if (value instanceof this._baseObject) {
+            if ("update" in value) {
+                value["update"].call(value, value);
+            }
+            return value;
+        }
+        // if the object does not have a direct id, we're forced to construct a whole new object
+        let item = "id" in value && value.id ? this.get(value.id) : undefined;
+        if (!item) {
+            item = this.add(this.extraOptions.construct(value, ...extra));
+        }
+        else if ("update" in item) {
+            item["update"].call(item, value);
+        }
+        return item;
+    }
+}
+exports.default = TypedCollection;

package/lib/Discord/util/TypedCollection.d.ts

@@ -0,0 +1,24 @@
+/** @module TypedCollection */
+import Collection from "./Collection";
+import type * as Types from "../types/namespaced";
+import type Client from "../Client";
+import Base from "../structures/Base";
+export interface ExtraOptions<M extends Record<string, any>, C extends Base, E extends Array<unknown> = []> {
+    construct?(this: void, data: M, ...extra: E): C;
+    delete?(this: void, key: string): void;
+}
+/** This is an internal class, you should not use it in your projects. If you want a collection type for your own projects, look at {@link Collection}. */
+export default class TypedCollection<M extends Record<string, any>, C extends Base, E extends Array<unknown> = []> extends Collection<string, C> {
+    private _baseObject;
+    extraOptions: Required<ExtraOptions<M, C, E>>;
+    limit: number;
+    constructor(baseObject: Types.Shared.AnyClass<M, C, E>, client: Client, limit?: number, extraOptions?: ExtraOptions<M, C, E>);
+    /** @hidden */
+    add<T extends C>(value: T): T;
+    clear(): void;
+    delete(key: string): boolean;
+    /** @hidden */
+    update(value: C | Partial<M> & {
+        id?: string;
+    }, ...extra: E): C;
+}

package/lib/Discord/util/TypedCollection.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @module TypedCollection */
+const Collection_1 = __importDefault(require("./Collection"));
+const Base_1 = __importDefault(require("../structures/Base"));
+/** This is an internal class, you should not use it in your projects. If you want a collection type for your own projects, look at {@link Collection}. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+class TypedCollection extends Collection_1.default {
+    _baseObject;
+    extraOptions;
+    limit;
+    constructor(baseObject, client, limit = Infinity, extraOptions) {
+        super();
+        if (!(baseObject.prototype instanceof Base_1.default)) {
+            throw new TypeError("baseObject must be a class that extends Base.");
+        }
+        this._baseObject = baseObject;
+        this.limit = limit;
+        this.extraOptions = {
+            construct: extraOptions?.construct ?? ((data, ...extra) => new baseObject(data, client, ...extra)),
+            delete: extraOptions?.delete ?? (() => { })
+        };
+    }
+    /** @hidden */
+    add(value) {
+        if ("id" in value) {
+            if (this.limit === 0) {
+                return value;
+            }
+            this.set(value.id, value);
+            if (this.limit && this.size > this.limit) {
+                const iter = this.keys();
+                while (this.size > this.limit) {
+                    const val = iter.next().value;
+                    if (val === undefined) {
+                        break;
+                    }
+                    this.delete(val);
+                }
+            }
+            return value;
+        }
+        else {
+            const err = new Error(`${this.constructor.name}#add: value must have an id property`);
+            Object.defineProperty(err, "_object", { value });
+            throw err;
+        }
+    }
+    clear() {
+        for (const key of this.keys()) {
+            this.extraOptions.delete(key);
+        }
+        super.clear();
+    }
+    delete(key) {
+        this.extraOptions.delete(key);
+        return super.delete(key);
+    }
+    /** @hidden */
+    update(value, ...extra) {
+        if (value instanceof this._baseObject) {
+            if ("update" in value) {
+                value["update"].call(value, value);
+            }
+            return value;
+        }
+        // if the object does not have a direct id, we're forced to construct a whole new object
+        let item = "id" in value && value.id ? this.get(value.id) : undefined;
+        if (!item) {
+            item = this.add(this.extraOptions.construct(value, ...extra));
+        }
+        else if ("update" in item) {
+            item["update"].call(item, value);
+        }
+        return item;
+    }
+}
+exports.default = TypedCollection;

package/lib/Discord/util/TypedEmitter.cjs

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @module TypedEmitter */
+const Errors_1 = require("./Errors.cjs");
+const node_events_1 = __importDefault(require("node:events"));
+class TypedEmitter extends node_events_1.default {
+    emit(eventName, ...args) {
+        if (this.listenerCount(eventName) === 0) {
+            if (eventName === "error") {
+                throw new Errors_1.UncaughtError(args[0]);
+            }
+            return false;
+        }
+        return super.emit(eventName, ...args);
+    }
+}
+exports.default = TypedEmitter;

package/lib/Discord/util/TypedEmitter.d.ts

@@ -0,0 +1,18 @@
+import EventEmitter from "node:events";
+declare interface TypedEmitter<Events extends Record<string | symbol, any>> extends EventEmitter {
+    addListener<K extends keyof Events>(event: K, listener: (...args: Events[K]) => void): this;
+    emit<K extends keyof Events>(eventName: K, ...args: Events[K]): boolean;
+    listenerCount(eventName: keyof Events): number;
+    listeners(eventName: keyof Events): Array<Function>;
+    off<K extends keyof Events>(event: K, listener: (...args: Events[K]) => void): this;
+    on<K extends keyof Events>(event: K, listener: (...args: Events[K]) => void): this;
+    once<K extends keyof Events>(event: K, listener: (...args: Events[K]) => void): this;
+    prependListener<K extends keyof Events>(event: K, listener: (...args: Events[K]) => void): this;
+    prependOnceListener<K extends keyof Events>(event: K, listener: (...args: Events[K]) => void): this;
+    rawListeners(eventName: keyof Events): Array<Function>;
+    removeAllListeners(event?: keyof Events): this;
+    removeListener<K extends keyof Events>(event: K, listener: (...args: Events[K]) => void): this;
+}
+declare class TypedEmitter<Events extends Record<string | symbol, any>> extends EventEmitter {
+}
+export default TypedEmitter;

package/lib/Discord/util/TypedEmitter.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @module TypedEmitter */
+const Errors_1 = require("./Errors");
+const node_events_1 = __importDefault(require("node:events"));
+class TypedEmitter extends node_events_1.default {
+    emit(eventName, ...args) {
+        if (this.listenerCount(eventName) === 0) {
+            if (eventName === "error") {
+                throw new Errors_1.UncaughtError(args[0]);
+            }
+            return false;
+        }
+        return super.emit(eventName, ...args);
+    }
+}
+exports.default = TypedEmitter;