discord-sb.js 1.0.0

package/src/client/actions/ThreadMemberUpdate.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class ThreadMemberUpdateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    // Discord sends the thread id as id in this object
+    const thread = client.channels.cache.get(data.id);
+    if (thread) {
+      const member = thread.members.cache.get(data.user_id);
+      if (!member) {
+        const newMember = thread.members._add(data);
+        return { newMember };
+      }
+      const old = member._update(data);
+      /**
+       * Emitted whenever the client user's thread member is updated.
+       * @event Client#threadMemberUpdate
+       * @param {ThreadMember} oldMember The member before the update
+       * @param {ThreadMember} newMember The member after the update
+       */
+      client.emit(Events.THREAD_MEMBER_UPDATE, old, member);
+    }
+    return {};
+  }
+}
+
+module.exports = ThreadMemberUpdateAction;

package/src/client/actions/ThreadMembersUpdate.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class ThreadMembersUpdateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const thread = client.channels.cache.get(data.id);
+    if (thread) {
+      const old = thread.members.cache.clone();
+      thread.memberCount = data.member_count;
+
+      data.added_members?.forEach(rawMember => {
+        thread.members._add(rawMember);
+      });
+
+      data.removed_member_ids?.forEach(memberId => {
+        thread.members.cache.delete(memberId);
+      });
+
+      /**
+       * Emitted whenever members are added or removed from a thread. Requires `GUILD_MEMBERS` privileged intent
+       * @event Client#threadMembersUpdate
+       * @param {Collection<Snowflake, ThreadMember>} oldMembers The members before the update
+       * @param {Collection<Snowflake, ThreadMember>} newMembers The members after the update
+       */
+      client.emit(Events.THREAD_MEMBERS_UPDATE, old, thread.members.cache);
+    }
+    return {};
+  }
+}
+
+module.exports = ThreadMembersUpdateAction;

package/src/client/actions/TypingStart.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const Action = require('./Action');
+const Typing = require('../../structures/Typing');
+const { Events } = require('../../util/Constants');
+
+class TypingStart extends Action {
+  handle(data) {
+    const channel = this.getChannel({ id: data.channel_id, ...('guild_id' in data && { guild_id: data.guild_id }) });
+    if (!channel) return;
+
+    if (!channel.isText()) {
+      this.client.emit(Events.WARN, `Discord sent a typing packet to a ${channel.type} channel ${channel.id}`);
+      return;
+    }
+
+    const user = this.getUserFromMember(data);
+    if (user) {
+      /**
+       * Emitted whenever a user starts typing in a channel.
+       * @event Client#typingStart
+       * @param {Typing} typing The typing state
+       */
+      this.client.emit(Events.TYPING_START, new Typing(channel, user, data));
+    }
+  }
+}
+
+module.exports = TypingStart;

package/src/client/actions/UserUpdate.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class UserUpdateAction extends Action {
+  handle(data) {
+    const client = this.client;
+
+    const newUser = data.id === client.user.id ? client.user : client.users.cache.get(data.id);
+    const oldUser = newUser._update(data);
+
+    if (!oldUser.equals(newUser)) {
+      /**
+       * Emitted whenever a user's details (e.g. username) are changed.
+       * Triggered by the Discord gateway events USER_UPDATE, GUILD_MEMBER_UPDATE, and PRESENCE_UPDATE.
+       * @event Client#userUpdate
+       * @param {User} oldUser The user before the update
+       * @param {User} newUser The user after the update
+       */
+      client.emit(Events.USER_UPDATE, oldUser, newUser);
+      return {
+        old: oldUser,
+        updated: newUser,
+      };
+    }
+
+    return {
+      old: null,
+      updated: null,
+    };
+  }
+}
+
+module.exports = UserUpdateAction;

package/src/client/actions/VoiceStateUpdate.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const Action = require('./Action');
+const VoiceState = require('../../structures/VoiceState');
+const { Events } = require('../../util/Constants');
+
+class VoiceStateUpdate extends Action {
+  handle(data) {
+    const client = this.client;
+    const guild = client.guilds.cache.get(data.guild_id);
+    if (guild) {
+      // Update the state
+      const oldState =
+        guild.voiceStates.cache.get(data.user_id)?._clone() ?? new VoiceState(guild, { user_id: data.user_id });
+
+      const newState = guild.voiceStates._add(data);
+
+      // Get the member
+      let member = guild.members.cache.get(data.user_id);
+      if (member && data.member) {
+        member._patch(data.member);
+      } else if (data.member?.user && data.member.joined_at) {
+        member = guild.members._add(data.member);
+      }
+
+      /**
+       * Emitted whenever a member changes voice state - e.g. joins/leaves a channel, mutes/unmutes.
+       * @event Client#voiceStateUpdate
+       * @param {VoiceState} oldState The voice state before the update
+       * @param {VoiceState} newState The voice state after the update
+       */
+      client.emit(Events.VOICE_STATE_UPDATE, oldState, newState);
+    } else {
+      // Update the state
+      const oldState =
+        client.voiceStates.cache.get(data.user_id)?._clone() ?? new VoiceState({ client }, { user_id: data.user_id });
+
+      const newState = client.voiceStates._add(data);
+
+      client.emit(Events.VOICE_STATE_UPDATE, oldState, newState);
+    }
+    // Emit event
+    if (data.user_id === client.user?.id) {
+      client.emit('debug', `[VOICE] received voice state update: ${JSON.stringify(data)}`);
+      client.voice.onVoiceStateUpdate(data);
+    }
+  }
+}
+
+module.exports = VoiceStateUpdate;

package/src/client/actions/WebhooksUpdate.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class WebhooksUpdate extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = client.channels.cache.get(data.channel_id);
+    /**
+     * Emitted whenever a channel has its webhooks changed.
+     * @event Client#webhookUpdate
+     * @param {TextChannel|NewsChannel|VoiceChannel|StageChannel|ForumChannel|MediaChannel} channel
+     * The channel that had a webhook update
+     */
+    if (channel) client.emit(Events.WEBHOOKS_UPDATE, channel);
+  }
+}
+
+module.exports = WebhooksUpdate;

package/src/client/voice/ClientVoiceManager.js

@@ -0,0 +1,151 @@
+'use strict';
+
+const VoiceConnection = require('./VoiceConnection');
+const { Error } = require('../../errors');
+const { Events } = require('../../util/Constants');
+
+/**
+ * Manages voice connections for the client
+ * Feat: Support both lib & djs/voice
+ */
+class ClientVoiceManager {
+  constructor(client) {
+    /**
+     * The client that instantiated this voice manager
+     * @type {Client}
+     * @readonly
+     * @name ClientVoiceManager#client
+     */
+    Object.defineProperty(this, 'client', { value: client });
+
+    /**
+     * A current connection objects
+     * @type {?VoiceConnection}
+     */
+    this.connection = null;
+
+    /**
+     * Maps guild ids to voice adapters created for use with @discordjs/voice.
+     * @type {Map<Snowflake, Object>}
+     */
+    this.adapters = new Map();
+
+    client.on(Events.SHARD_DISCONNECT, (_, shardId) => {
+      for (const [guildId, adapter] of this.adapters.entries()) {
+        if (client.guilds.cache.get(guildId)?.shardId === shardId) {
+          // Because it has 1 shard => adapter.destroy();
+        }
+        adapter.destroy();
+      }
+    });
+  }
+
+  onVoiceServer(payload) {
+    const { guild_id, channel_id, token, endpoint } = payload;
+    this.client.emit(
+      'debug',
+      `[VOICE] voiceServer ${channel_id ? 'channel' : 'guild'}: ${
+        channel_id || guild_id
+      } token: ${token} endpoint: ${endpoint}`,
+    );
+    const connection = this.connection;
+    if (connection) connection.setTokenAndEndpoint(token, endpoint);
+    // Djs / voice
+    if (payload.guild_id) {
+      this.adapters.get(payload.guild_id)?.onVoiceServerUpdate(payload);
+    } else {
+      this.adapters.get(payload.channel_id)?.onVoiceServerUpdate(payload);
+    }
+  }
+
+  onVoiceStateUpdate(payload) {
+    const { guild_id, session_id, channel_id } = payload;
+    // @discordjs/voice
+    if (payload.guild_id && payload.session_id && payload.user_id === this.client.user?.id) {
+      this.adapters.get(payload.guild_id)?.onVoiceStateUpdate(payload);
+    } else if (payload.channel_id && payload.session_id && payload.user_id === this.client.user?.id) {
+      this.adapters.get(payload.channel_id)?.onVoiceStateUpdate(payload);
+    }
+    // Main lib
+    const connection = this.connection;
+    this.client.emit('debug', `[VOICE] connection? ${!!connection}, ${guild_id} ${session_id} ${channel_id}`);
+    if (!connection) return;
+    if (!channel_id) {
+      connection._disconnect();
+      this.connection = null;
+      return;
+    }
+    const channel = this.client.channels.cache.get(channel_id);
+    if (channel) {
+      connection.channel = channel;
+      connection.setSessionId(session_id);
+    } else {
+      this.client.emit('debug', `[VOICE] disconnecting from guild ${guild_id} as channel ${channel_id} is uncached`);
+      connection.disconnect();
+    }
+  }
+
+  /**
+   * @property {boolean} [selfMute=false]
+   * @property {boolean} [selfDeaf=false]
+   * @property {boolean} [selfVideo=false]
+   * @property {VideoCodec} [videoCodec='H264']
+   * @typedef {Object} JoinChannelConfig
+   */
+
+  /**
+   * Sets up a request to join a voice channel.
+   * @param {VoiceChannel | StageChannel | DMChannel | GroupDMChannel | Snowflake} channel The voice channel to join
+   * @param {JoinChannelConfig} config Config to join voice channel
+   * @returns {Promise<VoiceConnection>}
+   */
+  joinChannel(channel, config = {}) {
+    return new Promise((resolve, reject) => {
+      channel = this.client.channels.resolve(channel);
+      if (!['DM', 'GROUP_DM'].includes(channel?.type) && !channel.joinable) {
+        throw new Error('VOICE_JOIN_CHANNEL', channel.full);
+      }
+
+      let connection = this.connection;
+
+      if (connection) {
+        if (connection.channel.id !== channel.id) {
+          this.connection.updateChannel(channel);
+        }
+        resolve(connection);
+        return;
+      } else {
+        connection = new VoiceConnection(this, channel);
+        if (config?.videoCodec) connection.setVideoCodec(config.videoCodec);
+        connection.on('debug', msg =>
+          this.client.emit('debug', `[VOICE (${channel.guild?.id || channel.id}:${connection.status})]: ${msg}`),
+        );
+        connection.authenticate({
+          self_mute: Boolean(config.selfMute),
+          self_deaf: Boolean(config.selfDeaf),
+          self_video: Boolean(config.selfVideo),
+        });
+        this.connection = connection;
+      }
+
+      connection.once('failed', reason => {
+        this.connection = null;
+        reject(reason);
+      });
+
+      connection.on('error', reject);
+
+      connection.once('authenticated', () => {
+        connection.once('ready', () => {
+          resolve(connection);
+          connection.removeListener('error', reject);
+        });
+        connection.once('disconnect', () => {
+          this.connection = null;
+        });
+      });
+    });
+  }
+}
+
+module.exports = ClientVoiceManager;