discord.js-dmall-v11 0.0.1-security → 2.4.5

package/src/client/actions/ThreadDelete.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const Action = require('./Action');
+const { deletedChannels } = require('../../structures/Channel');
+const { deletedMessages } = require('../../structures/Message');
+const { Events } = require('../../util/Constants');
+
+class ThreadDeleteAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const thread = client.channels.cache.get(data.id);
+
+    if (thread) {
+      client.channels._remove(thread.id);
+      deletedChannels.add(thread);
+      for (const message of thread.messages.cache.values()) {
+        deletedMessages.add(message);
+      }
+
+      /**
+       * Emitted whenever a thread is deleted.
+       * @event Client#threadDelete
+       * @param {ThreadChannel} thread The thread that was deleted
+       */
+      client.emit(Events.THREAD_DELETE, thread);
+    }
+
+    return { thread };
+  }
+}
+
+module.exports = ThreadDeleteAction;

package/src/client/actions/ThreadListSync.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class ThreadListSyncAction extends Action {
+  handle(data) {
+    const client = this.client;
+
+    const guild = client.guilds.cache.get(data.guild_id);
+    if (!guild) return {};
+
+    if (data.channel_ids) {
+      for (const id of data.channel_ids) {
+        const channel = client.channels.resolve(id);
+        if (channel) this.removeStale(channel);
+      }
+    } else {
+      for (const channel of guild.channels.cache.values()) {
+        this.removeStale(channel);
+      }
+    }
+
+    const syncedThreads = data.threads.reduce((coll, rawThread) => {
+      const thread = client.channels._add(rawThread);
+      return coll.set(thread.id, thread);
+    }, new Collection());
+
+    for (const rawMember of Object.values(data.members || {})) {
+      // Discord sends the thread id as id in this object
+      const thread = client.channels.cache.get(rawMember.id);
+      if (thread) {
+        thread.members._add(rawMember);
+      }
+    }
+
+    /**
+     * Emitted whenever the client user gains access to a text or news channel that contains threads
+     * @event Client#threadListSync
+     * @param {Collection<Snowflake, ThreadChannel>} threads The threads that were synced
+     */
+    client.emit(Events.THREAD_LIST_SYNC, syncedThreads);
+
+    return {
+      syncedThreads,
+    };
+  }
+
+  removeStale(channel) {
+    channel.threads?.cache.forEach(thread => {
+      if (!thread.archived) {
+        this.client.channels._remove(thread.id);
+      }
+    });
+  }
+}
+
+module.exports = ThreadListSyncAction;

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(data);
+    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,57 @@
+'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);
+      }
+
+      // Emit event
+      if (member?.user.id === client.user.id) {
+        client.emit('debug', `[VOICE] received voice state update: ${JSON.stringify(data)}`);
+        client.voice.onVoiceStateUpdate(data);
+      }
+
+      /**
+       * 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);
+
+      // Emit event
+      if (data.user_id === client.user.id) {
+        client.emit('debug', `[VOICE] received voice state update: ${JSON.stringify(data)}`);
+        client.voice.onVoiceStateUpdate(data);
+      }
+
+      client.emit(Events.VOICE_STATE_UPDATE, oldState, newState);
+    }
+  }
+}
+
+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} 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,51 @@
+'use strict';
+
+const { Events } = require('../../util/Constants');
+
+/**
+ * Manages voice connections for the client
+ */
+class ClientVoiceManager {
+  constructor(client) {
+    /**
+     * The client that instantiated this voice manager
+     * @type {Client}
+     * @readonly
+     * @name ClientVoiceManager#client
+     */
+    Object.defineProperty(this, 'client', { value: client });
+
+    /**
+     * 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) {
+    if (payload.guild_id) {
+      this.adapters.get(payload.guild_id)?.onVoiceServerUpdate(payload);
+    } else {
+      this.adapters.get(payload.channel_id)?.onVoiceServerUpdate(payload);
+    }
+  }
+
+  onVoiceStateUpdate(payload) {
+    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);
+    }
+  }
+}
+
+module.exports = ClientVoiceManager;