disgroove 3.0.0-dev.72bf12 → 3.0.0-dev.7dc321a

package/dist/lib/gateway/Shard.js

@@ -41,615 +41,145 @@ const ws_1 = __importDefault(require("ws"));
 const constants_1 = require("../constants");
 const utils_1 = require("../utils");
 const pkg = __importStar(require("../../package.json"));
-const transformers_1 = require("../transformers");
+const Transmitter_1 = require("./Transmitter");
+const Dispatcher_1 = require("./Dispatcher");
 class Shard {
     id;
-    heartbeatInterval;
     client;
-    ws;
+    heartbeatInterval;
     sessionId;
     resumeGatewayURL;
     sequence;
+    ws;
+    transmitter;
+    dispatcher;
     constructor(id, client) {
         this.id = id;
-        this.heartbeatInterval = null;
         this.client = client;
-        this.ws = new ws_1.default("wss://gateway.discord.gg/?v=10&encoding=json", this.client.ws);
+        this.heartbeatInterval = null;
         this.sessionId = null;
         this.resumeGatewayURL = null;
         this.sequence = null;
+        this.ws = new ws_1.default("wss://gateway.discord.gg/?v=10&encoding=json", this.client.ws);
+        this.transmitter = new Transmitter_1.Transmitter(this.ws);
+        this.dispatcher = new Dispatcher_1.Dispatcher(this);
     }
     /** https://discord.com/developers/docs/topics/gateway#connections */
-    connect(reconnect) {
+    connect() {
         if (this.ws) {
-            this.ws.on("open", () => this.onWebSocketOpen(reconnect));
+            this.ws.on("open", () => this.onWebSocketOpen());
             this.ws.on("message", (data) => this.onWebSocketMessage(data));
             this.ws.on("error", (err) => this.onWebSocketError(err));
             this.ws.on("close", (code, reason) => this.onWebSocketClose(code, reason));
         }
     }
     /** https://discord.com/developers/docs/events/gateway#initiating-a-disconnect */
-    disconnect() {
+    disconnect(reconnect) {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
         if (this.ws) {
-            if (this.heartbeatInterval) {
-                clearInterval(this.heartbeatInterval);
-                this.heartbeatInterval = null;
-            }
             if (this.ws.readyState !== ws_1.default.CLOSED) {
                 this.ws.removeAllListeners();
-                this.ws.close(1000, "Session Invalidated - Disconnect");
+                if (reconnect &&
+                    this.sessionId &&
+                    this.sequence &&
+                    this.resumeGatewayURL) {
+                    if (this.ws.readyState === ws_1.default.OPEN) {
+                        this.ws.terminate();
+                    }
+                    else {
+                        this.ws.close(1000, "Resume Attempt - Reconnect");
+                    }
+                }
+                else {
+                    this.ws.close(1000, "Session Invalidated - Disconnect");
+                }
                 this.ws = null;
+                this.transmitter = new Transmitter_1.Transmitter(null);
+            }
+            if (reconnect &&
+                this.sessionId &&
+                this.sequence &&
+                this.resumeGatewayURL) {
+                this.ws = new ws_1.default(this.resumeGatewayURL, this.client.ws);
+                this.transmitter = new Transmitter_1.Transmitter(this.ws);
+                this.connect();
             }
         }
     }
-    /** https://discord.com/developers/docs/topics/gateway-events#heartbeat */
-    heartbeat(lastSequence) {
-        if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
-            this.ws.send(JSON.stringify({
-                op: constants_1.GatewayOPCodes.Heartbeat,
-                d: lastSequence,
-            }));
-        }
-    }
-    /** https://discord.com/developers/docs/topics/gateway-events#identify */
-    identify(options) {
-        if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
-            this.ws.send(JSON.stringify({
-                op: constants_1.GatewayOPCodes.Identify,
-                d: {
-                    token: options.token,
-                    properties: {
-                        os: options.properties.os,
-                        browser: options.properties.browser,
-                        device: options.properties.device,
-                    },
-                    compress: options.compress,
-                    large_threshold: options.largeThreshold,
-                    shard: options.shard,
-                    presence: options.presence,
-                    intents: options.intents,
-                },
-            }));
-        }
-    }
-    onDispatch(packet) {
-        this.sequence = packet.s;
-        this.client.emit("dispatch", packet, this.id);
-        switch (packet.t) {
-            case constants_1.GatewayEvents.Ready:
-                {
-                    this.sessionId = packet.d.session_id;
-                    this.resumeGatewayURL = `${packet.d.resume_gateway_url}?v=10&encoding=json`;
-                    this.client.user = transformers_1.Users.userFromRaw(packet.d.user);
-                    this.client.application = packet.d.application;
-                    this.client.emit("ready");
-                }
-                break;
-            case constants_1.GatewayEvents.Resumed:
-                this.client.emit("resumed");
-                break;
-            case constants_1.GatewayEvents.RateLimited:
-                switch (packet.d.opcode) {
-                    case constants_1.GatewayOPCodes.RequestGuildMembers: {
-                        this.client.emit("rateLimited", {
-                            opcode: constants_1.GatewayOPCodes.RequestGuildMembers,
-                            retryAfter: packet.d.retry_after,
-                            meta: {
-                                guildId: packet.d.meta.guild_id,
-                                nonce: packet.d.nonce,
-                            },
-                        });
-                    }
-                }
-                break;
-            case constants_1.GatewayEvents.ApplicationCommandPermissionsUpdate:
-                this.client.emit("applicationCommandPermissionsUpdate", transformers_1.Guilds.guildApplicationCommandPermissionsFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.AutoModerationRuleCreate:
-                this.client.emit("autoModerationRuleCreate", transformers_1.AutoModeration.autoModerationRuleFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.AutoModerationRuleUpdate:
-                this.client.emit("autoModerationRuleUpdate", transformers_1.AutoModeration.autoModerationRuleFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.AutoModerationRuleDelete:
-                this.client.emit("autoModerationRuleDelete", transformers_1.AutoModeration.autoModerationRuleFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.AutoModerationActionExecution:
-                this.client.emit("autoModerationActionExecution", {
-                    guildId: packet.d.guild_id,
-                    action: {
-                        type: packet.d.action.type,
-                        metadata: {
-                            channelId: packet.d.action.metadata.channel_id,
-                            durationSeconds: packet.d.action.metadata.duration_seconds,
-                            customMessage: packet.d.action.metadata.custom_message,
-                        },
-                    },
-                    ruleId: packet.d.rule_id,
-                    ruleTriggerType: packet.d.rule_trigger_type,
-                    userId: packet.d.user_id,
-                    channelId: packet.d.channel_id,
-                    messageId: packet.d.message_id,
-                    alertSystemMessageId: packet.d.alert_system_message_id,
-                    content: packet.d.content,
-                    matchedKeyword: packet.d.matched_keyword,
-                    matchedContent: packet.d.matched_content,
-                });
-                break;
-            case constants_1.GatewayEvents.ChannelCreate:
-                this.client.emit("channelCreate", transformers_1.Channels.channelFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.ChannelUpdate:
-                this.client.emit("channelUpdate", transformers_1.Channels.channelFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.ChannelDelete:
-                this.client.emit("channelDelete", transformers_1.Channels.channelFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.ChannelPinsUpdate:
-                this.client.emit("channelPinsUpdate", {
-                    guildId: packet.d.guild_id,
-                    channelId: packet.d.channel_id,
-                    lastPinTimestamp: packet.d.last_pin_timestamp,
-                });
-                break;
-            case constants_1.GatewayEvents.ThreadCreate:
-                this.client.emit("threadCreate", transformers_1.Channels.channelFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.ThreadUpdate:
-                this.client.emit("threadUpdate", transformers_1.Channels.channelFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.ThreadDelete:
-                this.client.emit("threadDelete", transformers_1.Channels.channelFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.ThreadListSync:
-                this.client.emit("threadListSync", {
-                    guildId: packet.d.guild_id,
-                    channelIds: packet.d.channel_ids,
-                    threads: packet.d.threads.map((thread) => transformers_1.Channels.channelFromRaw(thread)),
-                    members: packet.d.members.map((threadMember) => transformers_1.Channels.threadMemberFromRaw(threadMember)),
-                });
-                break;
-            case constants_1.GatewayEvents.ThreadMemberUpdate:
-                this.client.emit("threadMemberUpdate", {
-                    id: packet.d.id,
-                    userId: packet.d.user_id,
-                    joinTimestamp: packet.d.join_timestamp,
-                    flags: packet.d.flags,
-                    member: packet.d.member !== undefined
-                        ? transformers_1.Guilds.guildMemberFromRaw(packet.d.member)
-                        : undefined,
-                    guildId: packet.d.guild_id,
-                });
-                break;
-            case constants_1.GatewayEvents.ThreadMembersUpdate:
-                this.client.emit("threadMembersUpdate", {
-                    id: packet.d.id,
-                    guildId: packet.d.guild_id,
-                    memberCount: packet.d.member_count,
-                    addedMembers: packet.d.members.map((threadMember) => transformers_1.Channels.threadMemberFromRaw(threadMember)),
-                    removedMemberIds: packet.d.removed_member_ids,
-                });
-                break;
-            case constants_1.GatewayEvents.EntitlementCreate:
-                this.client.emit("entitlementCreate", transformers_1.Entitlements.entitlementFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.EntitlementUpdate:
-                this.client.emit("entitlementUpdate", transformers_1.Entitlements.entitlementFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.EntitlementDelete:
-                this.client.emit("entitlementDelete", transformers_1.Entitlements.entitlementFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.GuildCreate:
-                {
-                    this.client.guildShardMap[packet.d.id] = this.id;
-                    this.client.guilds.set(packet.d.id, transformers_1.Guilds.guildFromRaw(packet.d));
-                    this.client.emit("guildCreate", transformers_1.Guilds.guildFromRaw(packet.d));
-                }
-                break;
-            case constants_1.GatewayEvents.GuildUpdate:
-                {
-                    this.client.guilds.set(packet.d.id, transformers_1.Guilds.guildFromRaw(packet.d));
-                    this.client.emit("guildUpdate", transformers_1.Guilds.guildFromRaw(packet.d));
-                }
-                break;
-            case constants_1.GatewayEvents.GuildDelete:
-                {
-                    delete this.client.guildShardMap[packet.d.id];
-                    this.client.guilds.delete(packet.d.id);
-                    this.client.emit("guildDelete", {
-                        id: packet.d.id,
-                        unavailable: packet.d.unavailable,
-                    });
-                }
-                break;
-            case constants_1.GatewayEvents.GuildAuditLogEntryCreate:
-                this.client.emit("guildAuditLogEntryCreate", {
-                    ...transformers_1.AuditLogs.auditLogEntryFromRaw(packet.d),
-                    guildId: packet.d.guild_id,
-                });
-                break;
-            case constants_1.GatewayEvents.GuildBanAdd:
-                this.client.emit("guildBanAdd", {
-                    guildId: packet.d.guild_id,
-                    user: transformers_1.Users.userFromRaw(packet.d.user),
-                });
-                break;
-            case constants_1.GatewayEvents.GuildBanRemove:
-                this.client.emit("guildBanRemove", {
-                    guildId: packet.d.guild_id,
-                    user: transformers_1.Users.userFromRaw(packet.d.user),
-                });
-                break;
-            case constants_1.GatewayEvents.GuildEmojisUpdate:
-                this.client.emit("guildEmojisUpdate", packet.d.emojis.map((emoji) => transformers_1.Emojis.emojiFromRaw(emoji)), packet.d.guild_id);
-                break;
-            case constants_1.GatewayEvents.GuildStickersUpdate:
-                this.client.emit("guildStickersUpdate", packet.d.stickers.map((sticker) => transformers_1.Stickers.stickerFromRaw(sticker)), packet.d.guild_id);
-                break;
-            case constants_1.GatewayEvents.GuildIntegrationsUpdate:
-                this.client.emit("guildIntegrationsUpdate", packet.d.guild_id);
-                break;
-            case constants_1.GatewayEvents.GuildMemberAdd:
-                this.client.emit("guildMemberAdd", {
-                    ...transformers_1.Guilds.guildMemberFromRaw(packet.d),
-                    guildId: packet.d.guild_id,
-                });
-                break;
-            case constants_1.GatewayEvents.GuildMemberRemove:
-                this.client.emit("guildMemberRemove", {
-                    guildId: packet.d.guild_id,
-                    user: transformers_1.Users.userFromRaw(packet.d.user),
-                });
-                break;
-            case constants_1.GatewayEvents.GuildMemberUpdate:
-                this.client.emit("guildMemberUpdate", {
-                    guildId: packet.d.guild_id,
-                    roles: packet.d.roles,
-                    user: transformers_1.Users.userFromRaw(packet.d.user),
-                    nick: packet.d.nick,
-                    avatar: packet.d.avatar,
-                    banner: packet.d.banner,
-                    joinedAt: packet.d.joined_at,
-                    premiumSince: packet.d.premium_since,
-                    deaf: packet.d.deaf,
-                    mute: packet.d.mute,
-                    pending: packet.d.pending,
-                    communicationDisabledUntil: packet.d.communication_disabled_until,
-                    flags: packet.d.flags,
-                    avatarDecorationData: packet.d.avatar_decoration_data !== undefined
-                        ? {
-                            asset: packet.d.asset,
-                            skuId: packet.d.sku_id,
-                        }
-                        : undefined,
-                });
-                break;
-            case constants_1.GatewayEvents.GuildMembersChunk:
-                this.client.emit("guildMembersChunk", {
-                    guildId: packet.d.guild_id,
-                    members: packet.d.members.map((guildMember) => transformers_1.Guilds.guildMemberFromRaw(guildMember)),
-                    chunkIndex: packet.d.chunk_index,
-                    chunkCount: packet.d.chunk_count,
-                    notFound: packet.d.not_found,
-                    presences: packet.d.presences?.map((presence) => transformers_1.Presences.presenceFromRaw(presence)),
-                    nonce: packet.d.nonce,
-                });
-                break;
-            case constants_1.GatewayEvents.GuildRoleCreate:
-                this.client.emit("guildRoleCreate", transformers_1.Roles.roleFromRaw(packet.d.role), packet.d.guild_id);
-                break;
-            case constants_1.GatewayEvents.GuildRoleUpdate:
-                this.client.emit("guildRoleUpdate", transformers_1.Roles.roleFromRaw(packet.d.role), packet.d.guild_id);
-                break;
-            case constants_1.GatewayEvents.GuildRoleDelete:
-                this.client.emit("guildRoleDelete", packet.d.role_id, packet.d.guild_id);
-                break;
-            case constants_1.GatewayEvents.GuildScheduledEventCreate:
-                this.client.emit("guildScheduledEventCreate", transformers_1.GuildScheduledEvents.guildScheduledEventFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.GuildScheduledEventUpdate:
-                this.client.emit("guildScheduledEventUpdate", transformers_1.GuildScheduledEvents.guildScheduledEventFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.GuildScheduledEventDelete:
-                this.client.emit("guildScheduledEventDelete", transformers_1.GuildScheduledEvents.guildScheduledEventFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.GuildScheduledEventUserAdd:
-                this.client.emit("guildScheduledEventUserAdd", packet.d.user_id, packet.d.guild_scheduled_event_id, packet.d.guild_id);
-                break;
-            case constants_1.GatewayEvents.GuildScheduledEventUserRemove:
-                this.client.emit("guildScheduledEventUserRemove", packet.d.user_id, packet.d.guild_scheduled_event_id, packet.d.guild_id);
-                break;
-            case constants_1.GatewayEvents.GuildSoundboardSoundCreate:
-                this.client.emit("guildSoundboardSoundCreate", transformers_1.Soundboards.soundboardSoundFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.GuildSoundboardSoundUpdate:
-                this.client.emit("guildSoundboardSoundUpdate", transformers_1.Soundboards.soundboardSoundFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.GuildSoundboardSoundDelete:
-                this.client.emit("guildSoundboardSoundDelete", {
-                    soundId: packet.d.sound_id,
-                    guildId: packet.d.guild_id,
-                });
-                break;
-            case constants_1.GatewayEvents.GuildSoundboardSoundsUpdate:
-                this.client.emit("guildSoundboardSoundsUpdate", packet.d.soundboard_sounds.map((sound) => transformers_1.Soundboards.soundboardSoundFromRaw(sound)), packet.d.guild_id);
-                break;
-            case constants_1.GatewayEvents.SoundboardSounds:
-                this.client.emit("soundboardSounds", packet.d.soundboard_sounds.map((sound) => transformers_1.Soundboards.soundboardSoundFromRaw(sound)), packet.d.guild_id);
-                break;
-            case constants_1.GatewayEvents.IntegrationCreate:
-                this.client.emit("integrationCreate", {
-                    ...transformers_1.Guilds.integrationFromRaw(packet.d),
-                    guildId: packet.d.guild_id,
-                });
-                break;
-            case constants_1.GatewayEvents.IntegrationUpdate:
-                this.client.emit("integrationUpdate", {
-                    ...transformers_1.Guilds.integrationFromRaw(packet.d),
-                    guildId: packet.d.guild_id,
-                });
-                break;
-            case constants_1.GatewayEvents.IntegrationDelete:
-                this.client.emit("integrationDelete", {
-                    id: packet.d.id,
-                    guildId: packet.d.guild_id,
-                    applicationId: packet.d.application_id,
-                });
-                break;
-            case constants_1.GatewayEvents.InteractionCreate:
-                this.client.emit("interactionCreate", transformers_1.Interactions.interactionFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.InviteCreate:
-                this.client.emit("inviteCreate", {
-                    channelId: packet.d.channel_id,
-                    code: packet.d.code,
-                    createdAt: packet.d.created_at,
-                    guildId: packet.d.guild_id,
-                    inviter: packet.d.inviter !== undefined
-                        ? transformers_1.Users.userFromRaw(packet.d.inviter)
-                        : undefined,
-                    maxAge: packet.d.max_age,
-                    maxUses: packet.d.max_uses,
-                    targetType: packet.d.target_type,
-                    targetUser: packet.d.target_user !== undefined
-                        ? transformers_1.Users.userFromRaw(packet.d.target_user)
-                        : undefined,
-                    targetApplication: packet.d.target_application !== undefined
-                        ? transformers_1.Applications.applicationFromRaw(packet.d.target_application)
-                        : undefined,
-                    temporary: packet.d.temporary,
-                    uses: packet.d.uses,
-                    expiresAt: packet.d.expires_at,
-                });
-                break;
-            case constants_1.GatewayEvents.InviteDelete:
-                this.client.emit("inviteDelete", {
-                    channelId: packet.d.channel_id,
-                    guildId: packet.d.guild_id,
-                    code: packet.d.code,
-                });
-                break;
-            case constants_1.GatewayEvents.MessageCreate:
-                this.client.emit("messageCreate", {
-                    ...transformers_1.Messages.messageFromRaw(packet.d),
-                    guildId: packet.d.guild_id,
-                    member: packet.d.member !== undefined
-                        ? transformers_1.Guilds.guildMemberFromRaw(packet.d.member)
-                        : undefined,
-                    mentions: packet.d.mentions.map((mention) => transformers_1.Users.userFromRaw(mention)),
-                });
-                break;
-            case constants_1.GatewayEvents.MessageUpdate:
-                this.client.emit("messageUpdate", transformers_1.Messages.messageFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.MessageDelete:
-                this.client.emit("messageDelete", {
-                    id: packet.d.id,
-                    channelId: packet.d.channel_id,
-                    guildId: packet.d.guild_id,
-                });
-                break;
-            case constants_1.GatewayEvents.MessageDeleteBulk:
-                this.client.emit("messageDeleteBulk", {
-                    ids: packet.d.ids,
-                    channelId: packet.d.channel_id,
-                    guildId: packet.d.guild_id,
-                });
-                break;
-            case constants_1.GatewayEvents.MessageReactionAdd:
-                this.client.emit("messageReactionAdd", {
-                    userId: packet.d.user_id,
-                    channelId: packet.d.user_id,
-                    messageId: packet.d.user_id,
-                    guildId: packet.d.user_id,
-                    member: packet.d.member !== undefined
-                        ? transformers_1.Guilds.guildMemberFromRaw(packet.d.member)
-                        : undefined,
-                    emoji: transformers_1.Emojis.emojiFromRaw(packet.d.emoji),
-                    messageAuthorId: packet.d.message_author_id,
-                    burst: packet.d.burst,
-                    burstColors: packet.d.burst_colors,
-                    type: packet.d.type,
-                });
-                break;
-            case constants_1.GatewayEvents.MessageReactionRemove:
-                this.client.emit("messageReactionRemove", {
-                    userId: packet.d.user_id,
-                    channelId: packet.d.user_id,
-                    messageId: packet.d.user_id,
-                    guildId: packet.d.user_id,
-                    emoji: transformers_1.Emojis.emojiFromRaw(packet.d.emoji),
-                    burst: packet.d.burst,
-                    type: packet.d.type,
-                });
-                break;
-            case constants_1.GatewayEvents.MessageReactionRemoveAll:
-                this.client.emit("messageReactionRemoveAll", {
-                    channelId: packet.d.channel_id,
-                    messageId: packet.d.message_id,
-                    guildId: packet.d.guild_id,
-                });
-                break;
-            case constants_1.GatewayEvents.MessageReactionRemoveEmoji:
-                this.client.emit("messageReactionRemoveEmoji", {
-                    channelId: packet.d.channel_id,
-                    guildId: packet.d.guild_id,
-                    messageId: packet.d.message_id,
-                    emoji: transformers_1.Emojis.emojiFromRaw(packet.d.emoji),
-                });
-                break;
-            case constants_1.GatewayEvents.PresenceUpdate:
-                this.client.emit("presenceUpdate", transformers_1.Presences.presenceFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.StageInstanceCreate:
-                this.client.emit("stageInstanceCreate", transformers_1.StageInstances.stageInstanceFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.StageInstanceUpdate:
-                this.client.emit("stageInstanceUpdate", transformers_1.StageInstances.stageInstanceFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.StageInstanceDelete:
-                this.client.emit("stageInstanceDelete", transformers_1.StageInstances.stageInstanceFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.TypingStart:
-                this.client.emit("typingStart", {
-                    channelId: packet.d.channel_id,
-                    guildId: packet.d.guild_id,
-                    userId: packet.d.user_id,
-                    timestamp: packet.d.timestamp,
-                    member: packet.d.member !== undefined
-                        ? transformers_1.Guilds.guildMemberFromRaw(packet.d.member)
-                        : undefined,
-                });
-                break;
-            case constants_1.GatewayEvents.UserUpdate:
-                this.client.emit("userUpdate", transformers_1.Users.userFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.VoiceChannelEffectSend:
-                this.client.emit("voiceChannelEffectSend", {
-                    channelId: packet.d.channel_id,
-                    guildId: packet.d.guild_id,
-                    userId: packet.d.user_id,
-                    emoji: packet.d.emoji !== null
-                        ? transformers_1.Emojis.emojiFromRaw(packet.d.emoji)
+    identify() {
+        this.transmitter.identify({
+            token: this.client.token,
+            properties: {
+                os: this.client.properties?.os ?? process.platform,
+                browser: this.client.properties?.browser ?? pkg.name,
+                device: this.client.properties?.device ?? pkg.name,
+            },
+            compress: this.client.compress,
+            largeThreshold: this.client.largeThreshold,
+            shard: [this.id, this.client.shardsCount],
+            presence: this.client.presence !== undefined
+                ? {
+                    since: this.client.presence.status === constants_1.StatusTypes.Idle
+                        ? Date.now()
                         : null,
-                    animationType: packet.d.animation_type,
-                    animationId: packet.d.animation_id,
-                    soundId: packet.d.sound_id,
-                    soundVolume: packet.d.sound_volume,
-                });
-                break;
-            case constants_1.GatewayEvents.VoiceStateUpdate:
-                this.client.emit("voiceStateUpdate", transformers_1.Voice.voiceStateFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.VoiceServerUpdate:
-                {
-                    this.client.emit("voiceServerUpdate", {
-                        token: packet.d.token,
-                        guildId: packet.d.guild_id,
-                        endpoint: packet.d.endpoint,
-                    });
+                    activities: this.client.presence.activities?.map((activity) => ({
+                        name: activity.type === constants_1.ActivityType.Custom
+                            ? "Custom Status"
+                            : activity.name,
+                        type: activity.type,
+                        url: activity.url,
+                        state: activity.state,
+                    })),
+                    status: this.client.presence.status ?? constants_1.StatusTypes.Online,
+                    afk: !!this.client.presence.afk,
                 }
-                break;
-            case constants_1.GatewayEvents.WebhooksUpdate:
-                this.client.emit("webhooksUpdate", packet.d.channel_id, packet.d.guild_id);
-                break;
-            case constants_1.GatewayEvents.SubscriptionCreate:
-                this.client.emit("subscriptionCreate", transformers_1.Subscriptions.subscriptionFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.SubscriptionUpdate:
-                this.client.emit("subscriptionUpdate", transformers_1.Subscriptions.subscriptionFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.SubscriptionDelete:
-                this.client.emit("subscriptionDelete", transformers_1.Subscriptions.subscriptionFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.MessagePollVoteAdd:
-                this.client.emit("messagePollVoteAdd", {
-                    userId: packet.d.user_id,
-                    channelId: packet.d.channel_id,
-                    messageId: packet.d.message_id,
-                    guildId: packet.d.guild_id,
-                    answerId: packet.d.answer_id,
-                });
-                break;
-            case constants_1.GatewayEvents.MessagePollVoteRemove:
-                this.client.emit("messagePollVoteRemove", {
-                    userId: packet.d.user_id,
-                    channelId: packet.d.channel_id,
-                    messageId: packet.d.message_id,
-                    guildId: packet.d.guild_id,
-                    answerId: packet.d.answer_id,
-                });
-                break;
-        }
-    }
-    onWebSocketOpen(reconnect) {
-        if (reconnect) {
-            this.resume({
-                token: this.client.token,
-                sessionId: this.sessionId,
-                seq: this.sequence,
-            });
-        }
-        else {
-            this.identify({
-                token: this.client.token,
-                properties: {
-                    os: this.client.properties?.os ?? process.platform,
-                    browser: this.client.properties?.browser ?? pkg.name,
-                    device: this.client.properties?.device ?? pkg.name,
-                },
-                compress: this.client.compress,
-                largeThreshold: this.client.largeThreshold,
-                shard: [this.id, this.client.shardsCount],
-                presence: this.client.presence !== undefined
-                    ? {
-                        since: this.client.presence.status === constants_1.StatusTypes.Idle
-                            ? Date.now()
-                            : null,
-                        activities: this.client.presence.activities?.map((activity) => ({
-                            name: activity.type === constants_1.ActivityType.Custom
-                                ? "Custom Status"
-                                : activity.name,
-                            type: activity.type,
-                            url: activity.url,
-                            state: activity.state,
-                        })),
-                        status: this.client.presence.status ?? constants_1.StatusTypes.Online,
-                        afk: !!this.client.presence.afk,
-                    }
-                    : undefined,
-                intents: this.client.intents,
-            });
-        }
+                : undefined,
+            intents: this.client.intents,
+        });
     }
+    onWebSocketOpen() { }
     onWebSocketMessage(data) {
         const packet = JSON.parse(data.toString());
         switch (packet.op) {
             case constants_1.GatewayOPCodes.Dispatch:
-                this.onDispatch(packet);
+                this.sequence = packet.s;
+                this.client.emit("dispatch", packet, this.id);
+                this.dispatcher.dispatch(packet.t, packet.d);
                 break;
+            case constants_1.GatewayOPCodes.Heartbeat:
+                this.client.emit("heartbeat", this.id);
+                this.transmitter.heartbeat(this.sequence);
             case constants_1.GatewayOPCodes.Reconnect:
                 {
-                    this.client.emit("reconnect");
-                    this.reconnect();
+                    this.client.emit("reconnect", this.id);
+                    this.disconnect(this.client.reconnect);
                 }
                 break;
             case constants_1.GatewayOPCodes.InvalidSession:
                 {
-                    this.client.emit("invalidSession");
+                    this.client.emit("invalidSession", this.id);
                     if (packet.d) {
-                        this.reconnect();
+                        this.resume();
                     }
-                    else if (this.ws) {
-                        this.ws.close(1000, "Invalid Session - Identify required");
-                        this.ws = new ws_1.default("wss://gateway.discord.gg/?v=10&encoding=json", this.client.ws);
-                        this.connect(false);
+                    else {
+                        this.sequence = null;
+                        this.sessionId = null;
+                        this.identify();
                     }
                 }
                 break;
             case constants_1.GatewayOPCodes.Hello:
                 {
-                    this.heartbeatInterval = setInterval(() => this.heartbeat(null), packet.d.heartbeat_interval);
+                    this.heartbeatInterval = setInterval(() => this.transmitter.heartbeat(this.sequence), packet.d.heartbeat_interval);
+                    if (this.sessionId && this.sequence && this.resumeGatewayURL) {
+                        this.resume();
+                    }
+                    else {
+                        this.identify();
+                    }
                     this.client.emit("hello", packet.d.heartbeat_interval, this.id);
                 }
                 break;
@@ -662,9 +192,9 @@ class Shard {
         throw err;
     }
     onWebSocketClose(code, reason) {
+        let reconnect = false;
         switch (code) {
             case 1000:
-                this.disconnect();
                 break;
             case constants_1.GatewayCloseEventCodes.UnknownError:
             case constants_1.GatewayCloseEventCodes.UnknownOPCode:
@@ -674,95 +204,19 @@ class Shard {
             case constants_1.GatewayCloseEventCodes.InvalidSequence:
             case constants_1.GatewayCloseEventCodes.RateLimited:
             case constants_1.GatewayCloseEventCodes.SessionTimedOut:
-                this.reconnect();
+                reconnect = this.client.reconnect;
                 break;
             default:
-                this.disconnect();
                 throw new utils_1.GatewayError(code, reason.toString());
         }
-    }
-    /** https://discord.com/developers/docs/events/gateway#resuming */
-    reconnect() {
-        if (this.ws && this.resumeGatewayURL && this.sessionId && this.sequence) {
-            this.ws.close(1000, "Resume Attempt - Reconnect");
-            this.ws = new ws_1.default(this.resumeGatewayURL, this.client.ws);
-            this.connect(true);
-        }
-    }
-    /** https://discord.com/developers/docs/topics/gateway-events#request-guild-members */
-    requestGuildMembers(options) {
-        if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
-            this.ws.send(JSON.stringify({
-                op: constants_1.GatewayOPCodes.RequestGuildMembers,
-                d: {
-                    guild_id: options.guildId,
-                    query: options.query,
-                    limit: options.limit,
-                    presences: options.presences,
-                    user_ids: options.userIds,
-                    nonce: options.nonce,
-                },
-            }));
-        }
-    }
-    /** https://discord.com/developers/docs/topics/gateway-events#request-soundboard-sounds */
-    requestSoundboardSounds(options) {
-        if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
-            this.ws.send(JSON.stringify({
-                op: constants_1.GatewayOPCodes.RequestSoundboardSounds,
-                d: {
-                    guild_ids: options.guildIds,
-                },
-            }));
-        }
-    }
-    /** https://discord.com/developers/docs/topics/gateway-events#resume */
-    resume(options) {
-        if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
-            this.ws.send(JSON.stringify({
-                op: constants_1.GatewayOPCodes.Resume,
-                d: {
-                    token: options.token,
-                    session_id: options.sessionId,
-                    seq: options.seq,
-                },
-            }));
-        }
-    }
-    /** https://discord.com/developers/docs/topics/gateway-events#update-presence */
-    updatePresence(options) {
-        if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
-            this.ws.send(JSON.stringify({
-                op: constants_1.GatewayOPCodes.PresenceUpdate,
-                d: {
-                    since: options.status === constants_1.StatusTypes.Idle ? Date.now() : null,
-                    activities: options.activities?.map((activity) => ({
-                        name: activity.type === constants_1.ActivityType.Custom
-                            ? "Custom Status"
-                            : activity.name,
-                        type: activity.type,
-                        url: activity.url,
-                        state: activity.state,
-                    })),
-                    status: options.status ?? constants_1.StatusTypes.Online,
-                    afk: !!options.afk,
-                },
-            }));
-        }
-    }
-    /** https://discord.com/developers/docs/topics/gateway-events#update-voice-state */
-    updateVoiceState(options) {
-        if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
-            this.ws.send(JSON.stringify({
-                op: constants_1.GatewayOPCodes.VoiceStateUpdate,
-                d: {
-                    guild_id: options.guildId,
-                    channel_id: options.channelId,
-                    self_mute: options.selfMute,
-                    self_deaf: options.selfDeaf,
-                },
-            }));
-        }
+        this.disconnect(reconnect);
+    }
+    resume() {
+        this.transmitter.resume({
+            token: this.client.token,
+            sessionId: this.sessionId,
+            seq: this.sequence,
+        });
     }
 }
 exports.Shard = Shard;