cloudstorm 0.4.0 → 0.4.3

package/README.md

@@ -17,9 +17,7 @@ const { Client } = require("cloudstorm");
 const bot = new Client(token, { intents: ["GUILDS"] });
 const startup = async () => {
 	await bot.connect();
-	bot.on("ready", () => {
-		console.log("Bot received ready event");
-	});
+	bot.on("ready", () => console.log("Bot received ready event"););
 };
 startup().catch(e => {
 	console.error("Error on startup!");
@@ -44,7 +42,7 @@ So an event you receive may look like this:
 		"roles": [],
 		"status": "offline",
 		"user": {
-		"id": "id"
+			"id": "id"
 		}
 	}
 }

package/dist/Client.js

@@ -4,13 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 const version = require("../package.json").version;
 const events_1 = require("events");
-let Erlpack;
-try {
-    Erlpack = require("erlpack");
-}
-catch (e) {
-    Erlpack = null;
-}
 const Constants_1 = __importDefault(require("./Constants"));
 const snowtransfer_1 = require("snowtransfer");
 const ShardManager_1 = __importDefault(require("./ShardManager"));
@@ -24,9 +17,8 @@ class Client extends events_1.EventEmitter {
      */
     constructor(token, options = {}) {
         super();
-        if (!token) {
+        if (!token)
             throw new Error("Missing token!");
-        }
         this.options = {
             largeGuildThreshold: 250,
             firstShardId: 0,
@@ -37,7 +29,7 @@ class Client extends events_1.EventEmitter {
             token: "",
             ws: {
                 compress: true,
-                socket: undefined
+                encoding: "json"
             }
         };
         this._restClient = options.snowtransferInstance ? options.snowtransferInstance : new snowtransfer_1.SnowTransfer(token);
@@ -95,8 +87,7 @@ class Client extends events_1.EventEmitter {
      * });
      */
     async presenceUpdate(data) {
-        await this.shardManager.presenceUpdate(data);
-        void undefined;
+        return this.shardManager.presenceUpdate(data);
     }
     /**
      * Send an OP 3 PRESENCE_UPDATE to Discord, which updates the status of a single shard facilitated by this client's ShardManager.
@@ -159,9 +150,8 @@ class Client extends events_1.EventEmitter {
      * });
      */
     requestGuildMembers(shardId, data) {
-        if (!data.guild_id) {
+        if (!data.guild_id)
             throw new Error("You need to pass a guild_id");
-        }
         return this.shardManager.requestGuildMembers(shardId, data);
     }
     /**
@@ -169,8 +159,8 @@ class Client extends events_1.EventEmitter {
      * @param gatewayUrl Base gateway wss url to update the cached endpoint to.
      */
     _updateEndpoint(gatewayUrl) {
-        var _a;
-        this.options.endpoint = `${gatewayUrl}?v=${Constants_1.default.GATEWAY_VERSION}&encoding=${Erlpack ? "etf" : "json"}${((_a = this.options.ws) === null || _a === void 0 ? void 0 : _a.compress) ? "&compress=zlib-stream" : ""}`;
+        var _a, _b;
+        this.options.endpoint = `${gatewayUrl}?v=${Constants_1.default.GATEWAY_VERSION}&encoding=${((_a = this.options.ws) === null || _a === void 0 ? void 0 : _a.encoding) === "etf" ? "etf" : "json"}${((_b = this.options.ws) === null || _b === void 0 ? void 0 : _b.compress) ? "&compress=zlib-stream" : ""}`;
     }
 }
 Client.default = Client;

package/dist/Intents.d.ts

@@ -14,6 +14,8 @@ export declare const flags: {
     DIRECT_MESSAGES: number;
     DIRECT_MESSAGE_REACTIONS: number;
     DIRECT_MESSAGE_TYPING: number;
+    MESSAGE_CONTENT: number;
+    GUILD_SCHEDULED_EVENTS: number;
 };
 export declare const privileged: number;
 export declare const all: number;

package/dist/Intents.js

@@ -17,8 +17,10 @@ exports.flags = {
     DIRECT_MESSAGES: 1 << 12,
     DIRECT_MESSAGE_REACTIONS: 1 << 13,
     DIRECT_MESSAGE_TYPING: 1 << 14,
+    MESSAGE_CONTENT: 1 << 15,
+    GUILD_SCHEDULED_EVENTS: 1 >> 16
 };
-exports.privileged = exports.flags.GUILD_MEMBERS | exports.flags.GUILD_PRESENCES | exports.flags.GUILD_MESSAGES;
+exports.privileged = exports.flags.GUILD_MEMBERS | exports.flags.GUILD_PRESENCES | exports.flags.MESSAGE_CONTENT;
 exports.all = Object.values(exports.flags).reduce((acc, p) => acc | p, 0);
 exports.non_privileged = exports.all & ~exports.privileged;
 function resolve(bit = 0) {

package/dist/Shard.d.ts

@@ -3,7 +3,6 @@ import { EventEmitter } from "events";
 import DiscordConnector from "./connector/DiscordConnector";
 interface ShardEvents {
     disconnect: [number, string, boolean];
-    error: [string];
     ready: [boolean];
     queueIdentify: [number];
 }

package/dist/Shard.js

@@ -40,15 +40,8 @@ class Shard extends events_1.EventEmitter {
             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);
-        });
+        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.

package/dist/ShardManager.js

@@ -15,9 +15,8 @@ class ShardManager {
     constructor(client) {
         this.client = client;
         this.options = client.options;
-        if (!this.options.connectQueueInterval) {
+        if (!this.options.connectQueueInterval)
             this.options.connectQueueInterval = 1000 * 5;
-        }
         this.shards = {};
         this.connectQueue = [];
         this.lastConnectionAttempt = null;
@@ -92,9 +91,6 @@ class ShardManager {
             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) {
@@ -117,9 +113,8 @@ class ShardManager {
     _checkReady() {
         for (const shardId in this.shards) {
             if (this.shards[shardId]) {
-                if (!this.shards[shardId].ready) {
+                if (!this.shards[shardId].ready)
                     return;
-                }
             }
         }
         this.client.emit("ready");
@@ -130,9 +125,8 @@ class ShardManager {
     _checkDisconnect() {
         for (const shardId in this.shards) {
             if (this.shards[shardId]) {
-                if (this.shards[shardId].connector.status !== "disconnected") {
+                if (this.shards[shardId].connector.status !== "disconnected")
                     return;
-                }
             }
         }
         this.client.emit("disconnected");
@@ -157,14 +151,10 @@ class ShardManager {
     shardPresenceUpdate(shardId, data) {
         return new Promise((res, rej) => {
             const shard = this.shards[shardId];
-            if (!shard) {
+            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));
-                });
-            }
+            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));
         });
     }
@@ -176,14 +166,10 @@ class ShardManager {
     voiceStateUpdate(shardId, data) {
         return new Promise((res, rej) => {
             const shard = this.shards[shardId];
-            if (!shard) {
+            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));
-                });
-            }
+            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));
         });
     }
@@ -195,14 +181,10 @@ class ShardManager {
     requestGuildMembers(shardId, data) {
         return new Promise((res, rej) => {
             const shard = this.shards[shardId];
-            if (!shard) {
+            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));
-                });
-            }
+            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));
         });
     }

package/dist/Types.d.ts

@@ -1,4 +1,3 @@
-import Constants from "./Constants";
 export interface IntentFlags {
     GUILDS: number;
     GUILD_MEMBERS: number;
@@ -18,53 +17,27 @@ export interface IntentFlags {
 }
 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];
+    op: import("discord-typings").GatewayOpcode;
     d?: any;
     s?: number;
-    t?: string;
+    t?: import("discord-typings").GatewayEvent;
 }
 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;
+    initialPresence?: import("discord-typings").GatewayPresenceUpdate;
     intents?: IntentResolvable;
     connectQueueInterval?: number;
     snowtransferInstance?: import("snowtransfer").SnowTransfer;
     ws?: IClientWSOptions;
 }
-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;
-}
 export interface IClientWSOptions {
     compress?: boolean;
-    socket?: import("ws").ClientOptions;
+    encoding?: "etf" | "json";
 }

package/dist/connector/DiscordConnector.d.ts

@@ -5,8 +5,8 @@ interface ConnectorEvents {
     queueIdentify: [number];
     event: [import("../Types").IWSMessage];
     ready: [boolean];
-    error: [string];
     disconnect: [number, string, boolean];
+    stateChange: ["connecting" | "identifying" | "resuming" | "ready" | "disconnected"];
 }
 interface DiscordConnector {
     addListener<E extends keyof ConnectorEvents>(event: E, listener: (...args: ConnectorEvents[E]) => any): this;
@@ -33,16 +33,17 @@ declare class DiscordConnector extends EventEmitter {
     client: import("../Client");
     options: import("../Client")["options"];
     reconnect: boolean;
-    betterWs: BetterWs | null;
+    betterWs: BetterWs;
     heartbeatTimeout: NodeJS.Timeout | null;
     heartbeatInterval: number;
     _trace: string | null;
     seq: number;
-    status: string;
+    status: "connecting" | "identifying" | "resuming" | "ready" | "disconnected";
     sessionId: string | null;
     lastACKAt: number;
     lastHeartbeatSend: number;
     latency: number;
+    private _closing;
     static readonly default: typeof DiscordConnector;
     /**
      * Create a new Discord Connector.
@@ -53,7 +54,7 @@ declare class DiscordConnector extends EventEmitter {
     /**
      * Connect to Discord.
      */
-    connect(): void;
+    connect(): Promise<void>;
     /**
      * Close the websocket connection and disconnect.
      */