cloudstorm 0.1.4 → 0.3.0

package/dist/Intents.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * Numeric websocket intents. All available properties:
+ * * `GUILDS`
+ * * `GUILD_MEMBERS`
+ * * `GUILD_BANS`
+ * * `GUILD_EMOJIS_AND_STICKERS`
+ * * `GUILD_INTEGRATIONS`
+ * * `GUILD_WEBHOOKS`
+ * * `GUILD_INVITES`
+ * * `GUILD_VOICE_STATES`
+ * * `GUILD_PRESENCES`
+ * * `GUILD_MESSAGES`
+ * * `GUILD_MESSAGE_REACTIONS`
+ * * `GUILD_MESSAGE_TYPING`
+ * * `DIRECT_MESSAGES`
+ * * `DIRECT_MESSAGE_REACTIONS`
+ * * `DIRECT_MESSAGE_TYPING`
+ * @see {@link https://discord.com/developers/docs/topics/gateway#list-of-intents}
+ */
+const flags = {
+    GUILDS: 1 << 0,
+    GUILD_MEMBERS: 1 << 1,
+    GUILD_BANS: 1 << 2,
+    GUILD_EMOJIS_AND_STICKERS: 1 << 3,
+    GUILD_INTEGRATIONS: 1 << 4,
+    GUILD_WEBHOOKS: 1 << 5,
+    GUILD_INVITES: 1 << 6,
+    GUILD_VOICE_STATES: 1 << 7,
+    GUILD_PRESENCES: 1 << 8,
+    GUILD_MESSAGES: 1 << 9,
+    GUILD_MESSAGE_REACTIONS: 1 << 10,
+    GUILD_MESSAGE_TYPING: 1 << 11,
+    DIRECT_MESSAGES: 1 << 12,
+    DIRECT_MESSAGE_REACTIONS: 1 << 13,
+    DIRECT_MESSAGE_TYPING: 1 << 14,
+};
+/**
+ * Bitfield representing all privileged intents.
+ * @see {@link https://discord.com/developers/docs/topics/gateway#privileged-intents}
+ */
+const privileged = flags.GUILD_MEMBERS | flags.GUILD_PRESENCES;
+/**
+ * Bitfield representing all intents combined.
+ */
+const all = Object.values(flags).reduce((acc, p) => acc | p, 0);
+/**
+ * Bitfield representing all non-privileged intents.
+ */
+const non_privileged = all & ~privileged;
+/**
+ * Resolves bitfields to their numeric form.
+ * @param bit bit(s) to resolve.
+ */
+function resolve(bit = 0) {
+    if (typeof bit === "number" && bit >= 0)
+        return bit;
+    if (typeof bit === "string" && flags[bit])
+        return flags[bit] | 0;
+    // @ts-ignore
+    if (Array.isArray(bit))
+        return bit.map((p) => resolve(p)).reduce((prev, p) => prev | p, 0);
+    throw new RangeError("BITFIELD_INVALID");
+}
+module.exports = {
+    flags,
+    all,
+    privileged,
+    non_privileged,
+    resolve
+};

package/dist/Shard.d.ts

@@ -0,0 +1,69 @@
+/// <reference types="node" />
+import { EventEmitter } from "events";
+import DiscordConnector from "./connector/DiscordConnector";
+interface ShardEvents {
+    disconnect: [number, string, boolean];
+    error: [string];
+    ready: [boolean];
+    queueIdentify: [number];
+}
+interface Shard {
+    addListener<E extends keyof ShardEvents>(event: E, listener: (...args: ShardEvents[E]) => any): this;
+    emit<E extends keyof ShardEvents>(event: E, ...args: ShardEvents[E]): boolean;
+    eventNames(): Array<keyof ShardEvents>;
+    listenerCount(event: keyof ShardEvents): number;
+    listeners(event: keyof ShardEvents): Array<(...args: Array<any>) => any>;
+    off<E extends keyof ShardEvents>(event: E, listener: (...args: ShardEvents[E]) => any): this;
+    on<E extends keyof ShardEvents>(event: E, listener: (...args: ShardEvents[E]) => any): this;
+    once<E extends keyof ShardEvents>(event: E, listener: (...args: ShardEvents[E]) => any): this;
+    prependListener<E extends keyof ShardEvents>(event: E, listener: (...args: ShardEvents[E]) => any): this;
+    prependOnceListener<E extends keyof ShardEvents>(event: E, listener: (...args: ShardEvents[E]) => any): this;
+    rawListeners(event: keyof ShardEvents): Array<(...args: Array<any>) => any>;
+    removeAllListeners(event?: keyof ShardEvents): this;
+    removeListener<E extends keyof ShardEvents>(event: E, listener: (...args: ShardEvents[E]) => any): this;
+}
+/**
+ * Shard class, which provides a wrapper around the DiscordConnector with metadata like the id of the shard.
+ *
+ * This class is automatically instantiated by the library and is documented for reference.
+ */
+declare class Shard extends EventEmitter {
+    id: number;
+    client: import("./Client");
+    ready: boolean;
+    connector: DiscordConnector;
+    /**
+     * Create a new Shard.
+     * @param id id of the shard.
+     * @param client Main class used for forwarding events.
+     */
+    constructor(id: number, client: import("./Client"));
+    /**
+     * Time in ms it took for Discord to ackknowledge an OP 1 HEARTBEAT.
+     */
+    get latency(): number;
+    /**
+     * Create a new connection to Discord.
+     */
+    connect(): void;
+    /**
+     * Close the current connection to Discord.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Send an OP 3 PRESENCE_UPDATE to Discord.
+     * @param data Data to send.
+     */
+    presenceUpdate(data: import("./Types").IPresence): Promise<void>;
+    /**
+     * Send an OP 4 VOICE_STATE_UPDATE to Discord.
+     * @param data Data to send
+     */
+    voiceStateUpdate(data: import("./Types").IVoiceStateUpdate): Promise<void>;
+    /**
+     * Send an OP 8 REQUEST_GUILD_MEMBERS to Discord.
+     * @param data Data to send.
+     */
+    requestGuildMembers(data: import("./Types").IRequestGuildMembers): Promise<void>;
+}
+export = Shard;

package/dist/Shard.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const events_1 = require("events");
+const DiscordConnector_1 = __importDefault(require("./connector/DiscordConnector"));
+const Constants_1 = require("./Constants");
+/**
+ * Shard class, which provides a wrapper around the DiscordConnector with metadata like the id of the shard.
+ *
+ * This class is automatically instantiated by the library and is documented for reference.
+ */
+class Shard extends events_1.EventEmitter {
+    /**
+     * Create a new Shard.
+     * @param id id of the shard.
+     * @param client Main class used for forwarding events.
+     */
+    constructor(id, client) {
+        super();
+        this.id = id;
+        this.client = client;
+        this.ready = false;
+        this.connector = new DiscordConnector_1.default(id, client);
+        this.connector.on("event", (event) => {
+            const newEvent = Object.assign(event, { shard_id: this.id });
+            this.client.emit("event", newEvent);
+            switch (event.op) {
+                case Constants_1.GATEWAY_OP_CODES.DISPATCH:
+                    this.client.emit("dispatch", newEvent);
+                    break;
+                case Constants_1.GATEWAY_OP_CODES.VOICE_STATE_UPDATE:
+                    this.client.emit("voiceStateUpdate", newEvent);
+                    break;
+                default:
+                    break;
+            }
+        });
+        this.connector.on("disconnect", (...args) => {
+            this.ready = false;
+            this.emit("disconnect", ...args);
+        });
+        this.connector.on("error", (err) => {
+            this.emit("error", err);
+        });
+        this.connector.on("ready", (resume) => {
+            this.emit("ready", resume);
+        });
+        this.connector.on("queueIdentify", () => {
+            this.emit("queueIdentify", this.id);
+        });
+    }
+    /**
+     * Time in ms it took for Discord to ackknowledge an OP 1 HEARTBEAT.
+     */
+    get latency() {
+        return this.connector.latency;
+    }
+    /**
+     * Create a new connection to Discord.
+     */
+    connect() {
+        this.connector.connect();
+    }
+    /**
+     * Close the current connection to Discord.
+     */
+    disconnect() {
+        return this.connector.disconnect();
+    }
+    /**
+     * Send an OP 3 PRESENCE_UPDATE to Discord.
+     * @param data Data to send.
+     */
+    presenceUpdate(data) {
+        return this.connector.presenceUpdate(data);
+    }
+    /**
+     * Send an OP 4 VOICE_STATE_UPDATE to Discord.
+     * @param data Data to send
+     */
+    voiceStateUpdate(data) {
+        return this.connector.voiceStateUpdate(data);
+    }
+    /**
+     * Send an OP 8 REQUEST_GUILD_MEMBERS to Discord.
+     * @param data Data to send.
+     */
+    requestGuildMembers(data) {
+        return this.connector.requestGuildMembers(data);
+    }
+}
+module.exports = Shard;

package/dist/ShardManager.d.ts

@@ -0,0 +1,78 @@
+/// <reference types="node" />
+import Shard from "./Shard";
+/**
+ * Class used for managing shards for the user.
+ *
+ * This class is automatically instantiated by the library and is documented for reference.
+ */
+declare class ShardManager {
+    client: import("./Client");
+    options: import("./Client")["options"];
+    shards: {
+        [id: number]: Shard;
+    };
+    connectQueue: Array<{
+        action: string;
+        shard: Shard;
+    }>;
+    lastConnectionAttempt: number | null;
+    connectQueueInterval: NodeJS.Timeout;
+    /**
+     * Create a new ShardManager.
+     */
+    constructor(client: import("./Client"));
+    /**
+     * Create shard instances and add them to the connection queue.
+     */
+    spawn(): void;
+    /**
+     * Disconnect all shards facilitated by this manager.
+     */
+    disconnect(): void;
+    /**
+     * Actually connect/re-identify a single shard spawned by this manager by calling it's connect() or identify() method and reset the connection timer.
+     * @param data Object with a shard and action key.
+     */
+    private _connectShard;
+    /**
+     * Check if there are shards that have been spawned by this manager that are not connected yet and connect them if over 6 seconds have passed since the last attempt.
+     */
+    private _checkQueue;
+    /**
+     * Add event listeners to a shard to that the manager can act on received events.
+     * @param shard Shard to add the event listeners to.
+     */
+    private _addListener;
+    /**
+     * Checks if all shards spawned by this manager are ready.
+     */
+    private _checkReady;
+    /**
+     * Checks if all shards spawned by this manager are disconnected.
+     */
+    private _checkDisconnect;
+    /**
+     * Update the status of all currently connected shards which have been spawned by this manager.
+     * @param data Data to send.
+     */
+    presenceUpdate(data?: import("./Types").IPresence): Promise<void>;
+    /**
+     * Update the status of a single connected shard which has been spawned by this manager.
+     * @param shardId id of the shard.
+     * @param data Data to send.
+     */
+    shardPresenceUpdate(shardId: number, data?: import("./Types").IPresence): Promise<void>;
+    /**
+     * Send an OP 4 VOICE_STATE_UPDATE with a certain shard.
+     * @param shardId id of the shard.
+     * @param data Data to send.
+     */
+    voiceStateUpdate(shardId: number, data: import("./Types").IVoiceStateUpdate): Promise<void>;
+    /**
+     * Send an OP 8 REQUEST_GUILD_MEMBERS with a certain shard.
+     * @param shardId id of the shard.
+     * @param data Data to send.
+     */
+    requestGuildMembers(shardId: number, data: import("./Types").IRequestGuildMembers): Promise<void>;
+}
+export = ShardManager;

package/dist/ShardManager.js

@@ -0,0 +1,210 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const Shard_1 = __importDefault(require("./Shard"));
+/**
+ * Class used for managing shards for the user.
+ *
+ * This class is automatically instantiated by the library and is documented for reference.
+ */
+class ShardManager {
+    /**
+     * Create a new ShardManager.
+     */
+    constructor(client) {
+        this.client = client;
+        this.options = client.options;
+        if (!this.options.connectQueueInterval) {
+            this.options.connectQueueInterval = 1000 * 5;
+        }
+        this.shards = {};
+        this.connectQueue = [];
+        this.lastConnectionAttempt = null;
+        this.connectQueueInterval = setInterval(() => {
+            this._checkQueue();
+        }, this.options.connectQueueInterval);
+    }
+    /**
+     * Create shard instances and add them to the connection queue.
+     */
+    spawn() {
+        const firstShardID = this.options.firstShardId ? this.options.firstShardId : 0;
+        const lastShardId = this.options.lastShardId ? this.options.lastShardId : 0;
+        for (let i = firstShardID; i < lastShardId + 1; i++) {
+            this.client.emit("debug", `Spawned shard ${i}`);
+            this.shards[i] = new Shard_1.default(i, this.client);
+            this.connectQueue.push({ action: "connect", shard: this.shards[i] });
+            this._addListener(this.shards[i]);
+        }
+    }
+    /**
+     * Disconnect all shards facilitated by this manager.
+     */
+    disconnect() {
+        for (const shardKey in this.shards) {
+            if (this.shards[shardKey]) {
+                const shard = this.shards[shardKey];
+                shard.disconnect();
+            }
+        }
+    }
+    /**
+     * Actually connect/re-identify a single shard spawned by this manager by calling it's connect() or identify() method and reset the connection timer.
+     * @param data Object with a shard and action key.
+     */
+    _connectShard(data) {
+        const { action, shard } = data;
+        this.client.emit("debug", `${action === "connect" ? "Connecting" : "Identifying"} Shard ${shard.id} Status: ${shard.connector.status} Ready: ${shard.ready}`);
+        if ((this.lastConnectionAttempt || 0) <= Date.now() - 6000) {
+            if (action === "identify") {
+                this.lastConnectionAttempt = Date.now();
+                shard.connector.identify(true);
+            }
+            else {
+                if (shard.connector.status !== "connecting" && !shard.ready) {
+                    this.lastConnectionAttempt = Date.now();
+                    shard.connect();
+                }
+            }
+        }
+    }
+    /**
+     * Check if there are shards that have been spawned by this manager that are not connected yet and connect them if over 6 seconds have passed since the last attempt.
+     */
+    _checkQueue() {
+        // this.client.emit("debug", `Checking queue Length: ${this.connectQueue.length} LastAttempt: ${this.lastConnectionAttempt} Current Time: ${Date.now()}`);
+        if (this.connectQueue.length > 0 && ((this.lastConnectionAttempt || 0) <= Date.now() - 6000)) {
+            const toConnect = this.connectQueue.splice(0, 1);
+            for (const shard of toConnect) {
+                this._connectShard(shard);
+            }
+        }
+    }
+    /**
+     * Add event listeners to a shard to that the manager can act on received events.
+     * @param shard Shard to add the event listeners to.
+     */
+    _addListener(shard) {
+        shard.on("ready", (resume) => {
+            this.shards[shard.id].ready = true;
+            this.client.emit("debug", `Shard ${shard.id} ${resume ? "has resumed" : "is ready"}`);
+            this.client.emit("shardReady", { id: shard.id, ready: !resume });
+            this._checkReady();
+        });
+        shard.on("error", (error) => {
+            this.client.emit("error", error);
+        });
+        shard.on("disconnect", (code, reason, gracefulClose) => {
+            this.client.emit("debug", `Websocket of shard ${shard.id} closed with code ${code} and reason: ${reason ? reason : "None"}`);
+            if (code === 1000 && gracefulClose) {
+                this._checkDisconnect();
+                return;
+            }
+            this.connectQueue.push({ action: "connect", shard });
+        });
+        shard.on("queueIdentify", (shardId) => {
+            if (!this.shards[shardId]) {
+                this.client.emit("debug", `Received a queueIdentify event for not existing shard ${shardId}`);
+                return;
+            }
+            this.connectQueue.unshift({ action: "identify", shard: this.shards[shardId] });
+        });
+    }
+    /**
+     * Checks if all shards spawned by this manager are ready.
+     */
+    _checkReady() {
+        for (const shardId in this.shards) {
+            if (this.shards[shardId]) {
+                if (!this.shards[shardId].ready) {
+                    return;
+                }
+            }
+        }
+        this.client.emit("ready");
+    }
+    /**
+     * Checks if all shards spawned by this manager are disconnected.
+     */
+    _checkDisconnect() {
+        for (const shardId in this.shards) {
+            if (this.shards[shardId]) {
+                if (this.shards[shardId].connector.status !== "disconnected") {
+                    return;
+                }
+            }
+        }
+        this.client.emit("disconnected");
+    }
+    /**
+     * Update the status of all currently connected shards which have been spawned by this manager.
+     * @param data Data to send.
+     */
+    async presenceUpdate(data = {}) {
+        for (const shardKey in this.shards) {
+            if (this.shards[shardKey]) {
+                const shard = this.shards[shardKey];
+                this.shardPresenceUpdate(shard.id, data);
+            }
+        }
+    }
+    /**
+     * Update the status of a single connected shard which has been spawned by this manager.
+     * @param shardId id of the shard.
+     * @param data Data to send.
+     */
+    shardPresenceUpdate(shardId, data = {}) {
+        return new Promise((res, rej) => {
+            const shard = this.shards[shardId];
+            if (!shard) {
+                rej(new Error(`Shard ${shardId} does not exist`));
+            }
+            if (!shard.ready) {
+                shard.once("ready", () => {
+                    shard.presenceUpdate(data).then(result => res(result)).catch(e => rej(e));
+                });
+            }
+            shard.presenceUpdate(data).then(result => res(result)).catch(e => rej(e));
+        });
+    }
+    /**
+     * Send an OP 4 VOICE_STATE_UPDATE with a certain shard.
+     * @param shardId id of the shard.
+     * @param data Data to send.
+     */
+    voiceStateUpdate(shardId, data) {
+        return new Promise((res, rej) => {
+            const shard = this.shards[shardId];
+            if (!shard) {
+                rej(new Error(`Shard ${shardId} does not exist`));
+            }
+            if (!shard.ready) {
+                shard.once("ready", () => {
+                    shard.voiceStateUpdate(data).then(result => res(result)).catch(e => rej(e));
+                });
+            }
+            shard.voiceStateUpdate(data).then(result => res(result)).catch(e => rej(e));
+        });
+    }
+    /**
+     * Send an OP 8 REQUEST_GUILD_MEMBERS with a certain shard.
+     * @param shardId id of the shard.
+     * @param data Data to send.
+     */
+    requestGuildMembers(shardId, data) {
+        return new Promise((res, rej) => {
+            const shard = this.shards[shardId];
+            if (!shard) {
+                rej(new Error(`Shard ${shardId} does not exist`));
+            }
+            if (!shard.ready) {
+                shard.once("ready", () => {
+                    shard.requestGuildMembers(data).then(result => res(result)).catch(e => rej(e));
+                });
+            }
+            shard.requestGuildMembers(data).then(result => res(result)).catch(e => rej(e));
+        });
+    }
+}
+module.exports = ShardManager;

package/dist/Types.d.ts

@@ -0,0 +1,65 @@
+import Constants from "./Constants";
+export interface IntentFlags {
+    GUILDS: number;
+    GUILD_MEMBERS: number;
+    GUILD_BANS: number;
+    GUILD_EMOJIS_AND_STICKERS: number;
+    GUILD_INTEGRATIONS: number;
+    GUILD_WEBHOOKS: number;
+    GUILD_INVITES: number;
+    GUILD_VOICE_STATES: number;
+    GUILD_PRESENCES: number;
+    GUILD_MESSAGES: number;
+    GUILD_MESSAGE_REACTIONS: number;
+    GUILD_MESSAGE_TYPING: number;
+    DIRECT_MESSAGES: number;
+    DIRECT_MESSAGE_REACTIONS: number;
+    DIRECT_MESSAGE_TYPING: number;
+}
+export declare type IntentResolvable = number | Array<number> | keyof IntentFlags | Array<keyof IntentFlags>;
+export interface IWSMessage {
+    op: typeof Constants["GATEWAY_OP_CODES"][keyof typeof Constants.GATEWAY_OP_CODES];
+    d?: any;
+    s?: number;
+    t?: string;
+}
+export interface IGatewayMessage extends IWSMessage {
+    shard_id: number;
+}
+export interface IPresenceActivity {
+    name: string;
+    type?: 0 | 1 | 2 | 3 | 5;
+    url?: string;
+}
+export interface IPresence {
+    status?: "online" | "idle" | "dnd" | "offline";
+    afk?: boolean;
+    since?: boolean;
+    activities?: Array<IPresenceActivity> | null;
+}
+export interface IClientOptions {
+    largeGuildThreshold?: number;
+    firstShardId?: number;
+    lastShardId?: number;
+    shardAmount?: number;
+    reconnect?: boolean;
+    initialPresence?: IPresence;
+    intents?: IntentResolvable;
+    connectQueueInterval?: number;
+    snowtransferInstance?: import("snowtransfer").SnowTransfer;
+}
+export interface IVoiceStateUpdate {
+    guild_id: string;
+    channel_id?: string | null;
+    self_mute?: boolean;
+    self_deaf?: boolean;
+}
+export interface IRequestGuildMembers {
+    guild_id: string;
+    query?: string | null;
+    limit?: number;
+}
+export interface IShardReady {
+    id: number;
+    ready: boolean;
+}

package/dist/Types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });