@ovencord/discord.js 14.16.3

package/src/client/actions/GuildScheduledEventUserRemove.ts

@@ -0,0 +1,29 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class GuildScheduledEventUserRemoveAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const guild = client.guilds.cache.get(data.guild_id);
+
+    if (guild) {
+      const guildScheduledEvent = this.getScheduledEvent(data, guild);
+      const user = this.getUser(data);
+
+      if (guildScheduledEvent && user) {
+        /**
+         * Emitted whenever a user unsubscribes from a guild scheduled event
+         *
+         * @event Client#guildScheduledEventUserRemove
+         * @param {GuildScheduledEvent} guildScheduledEvent The guild scheduled event
+         * @param {User} user The user who unsubscribed
+         */
+        client.emit(Events.GuildScheduledEventUserRemove, guildScheduledEvent, user);
+
+        return { guildScheduledEvent, user };
+      }
+    }
+
+    return {};
+  }
+}

package/src/client/actions/GuildSoundboardSoundDelete.ts

@@ -0,0 +1,26 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class GuildSoundboardSoundDeleteAction extends Action {
+  handle(data) {
+    const guild = this.client.guilds.cache.get(data.guild_id);
+
+    if (!guild) return {};
+
+    const soundboardSound = this.getSoundboardSound(data, guild);
+
+    if (soundboardSound) {
+      guild.soundboardSounds.cache.delete(soundboardSound.soundId);
+
+      /**
+       * Emitted whenever a soundboard sound is deleted in a guild.
+       *
+       * @event Client#guildSoundboardSoundDelete
+       * @param {SoundboardSound} soundboardSound The soundboard sound that was deleted
+       */
+      this.client.emit(Events.GuildSoundboardSoundDelete, soundboardSound);
+    }
+
+    return { soundboardSound };
+  }
+}

package/src/client/actions/GuildStickerCreate.ts

@@ -0,0 +1,17 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class GuildStickerCreateAction extends Action {
+  handle(guild, createdSticker) {
+    const already = guild.stickers.cache.has(createdSticker.id);
+    const sticker = guild.stickers._add(createdSticker);
+    /**
+     * Emitted whenever a custom sticker is created in a guild.
+     *
+     * @event Client#stickerCreate
+     * @param {Sticker} sticker The sticker that was created
+     */
+    if (!already) this.client.emit(Events.GuildStickerCreate, sticker);
+    return { sticker };
+  }
+}

package/src/client/actions/GuildStickerDelete.ts

@@ -0,0 +1,16 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class GuildStickerDeleteAction extends Action {
+  handle(sticker) {
+    sticker.guild.stickers.cache.delete(sticker.id);
+    /**
+     * Emitted whenever a custom sticker is deleted in a guild.
+     *
+     * @event Client#stickerDelete
+     * @param {Sticker} sticker The sticker that was deleted
+     */
+    this.client.emit(Events.GuildStickerDelete, sticker);
+    return { sticker };
+  }
+}

package/src/client/actions/GuildStickerUpdate.ts

@@ -0,0 +1,17 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class GuildStickerUpdateAction extends Action {
+  handle(current, data) {
+    const old = current._update(data);
+    /**
+     * Emitted whenever a custom sticker is updated in a guild.
+     *
+     * @event Client#stickerUpdate
+     * @param {Sticker} oldSticker The old sticker
+     * @param {Sticker} newSticker The new sticker
+     */
+    this.client.emit(Events.GuildStickerUpdate, old, current);
+    return { sticker: current };
+  }
+}

package/src/client/actions/GuildStickersUpdate.ts

@@ -0,0 +1,30 @@
+import { Action  } from './Action.js';
+
+export class GuildStickersUpdateAction extends Action {
+  handle(data) {
+    const guild = this.client.guilds.cache.get(data.guild_id);
+    if (!guild?.stickers) return;
+
+    const deletions = new Map(guild.stickers.cache);
+
+    for (const sticker of data.stickers) {
+      // Determine type of sticker event
+      const cachedSticker = guild.stickers.cache.get(sticker.id);
+      if (cachedSticker) {
+        deletions.delete(sticker.id);
+        if (!cachedSticker.equals(sticker)) {
+          // Sticker updated
+          this.client.actions.GuildStickerUpdate.handle(cachedSticker, sticker);
+        }
+      } else {
+        // Sticker added
+        this.client.actions.GuildStickerCreate.handle(guild, sticker);
+      }
+    }
+
+    for (const sticker of deletions.values()) {
+      // Sticker deleted
+      this.client.actions.GuildStickerDelete.handle(sticker);
+    }
+  }
+}

package/src/client/actions/GuildUpdate.ts

@@ -0,0 +1,30 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class GuildUpdateAction extends Action {
+  handle(data) {
+    const client = this.client;
+
+    const guild = client.guilds.cache.get(data.id);
+    if (guild) {
+      const old = guild._update(data);
+      /**
+       * Emitted whenever a guild is updated - e.g. name change.
+       *
+       * @event Client#guildUpdate
+       * @param {Guild} oldGuild The guild before the update
+       * @param {Guild} newGuild The guild after the update
+       */
+      client.emit(Events.GuildUpdate, old, guild);
+      return {
+        old,
+        updated: guild,
+      };
+    }
+
+    return {
+      old: null,
+      updated: null,
+    };
+  }
+}

package/src/client/actions/InteractionCreate.ts

@@ -0,0 +1,104 @@
+import { InteractionType, ComponentType, ApplicationCommandType  } from 'discord-api-types/v10';
+import { AutocompleteInteraction  } from '../../structures/AutocompleteInteraction.js';
+import { ButtonInteraction  } from '../../structures/ButtonInteraction.js';
+import { ChannelSelectMenuInteraction  } from '../../structures/ChannelSelectMenuInteraction.js';
+import { ChatInputCommandInteraction  } from '../../structures/ChatInputCommandInteraction.js';
+import { MentionableSelectMenuInteraction  } from '../../structures/MentionableSelectMenuInteraction.js';
+import { MessageContextMenuCommandInteraction  } from '../../structures/MessageContextMenuCommandInteraction.js';
+import { ModalSubmitInteraction  } from '../../structures/ModalSubmitInteraction.js';
+import { PrimaryEntryPointCommandInteraction  } from '../../structures/PrimaryEntryPointCommandInteraction.js';
+import { RoleSelectMenuInteraction  } from '../../structures/RoleSelectMenuInteraction.js';
+import { StringSelectMenuInteraction  } from '../../structures/StringSelectMenuInteraction.js';
+import { UserContextMenuCommandInteraction  } from '../../structures/UserContextMenuCommandInteraction.js';
+import { UserSelectMenuInteraction  } from '../../structures/UserSelectMenuInteraction.js';
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class InteractionCreateAction extends Action {
+  handle(data) {
+    const client = this.client;
+
+    // Resolve and cache partial channels for Interaction#channel getter
+    const channel = data.channel && this.getChannel(data.channel);
+
+    // Do not emit this for interactions that cache messages that are non-text-based.
+    let InteractionClass;
+
+    switch (data.type) {
+      case InteractionType.ApplicationCommand:
+        switch (data.data.type) {
+          case ApplicationCommandType.ChatInput:
+            InteractionClass = ChatInputCommandInteraction;
+            break;
+          case ApplicationCommandType.User:
+            InteractionClass = UserContextMenuCommandInteraction;
+            break;
+          case ApplicationCommandType.Message:
+            if (channel && !channel.isTextBased()) return;
+            InteractionClass = MessageContextMenuCommandInteraction;
+            break;
+          case ApplicationCommandType.PrimaryEntryPoint:
+            InteractionClass = PrimaryEntryPointCommandInteraction;
+            break;
+          default:
+            client.emit(
+              Events.Debug,
+              `[INTERACTION] Received application command interaction with unknown type: ${data.data.type}`,
+            );
+            return;
+        }
+
+        break;
+      case InteractionType.MessageComponent:
+        if (channel && !channel.isTextBased()) return;
+
+        switch (data.data.component_type) {
+          case ComponentType.Button:
+            InteractionClass = ButtonInteraction;
+            break;
+          case ComponentType.StringSelect:
+            InteractionClass = StringSelectMenuInteraction;
+            break;
+          case ComponentType.UserSelect:
+            InteractionClass = UserSelectMenuInteraction;
+            break;
+          case ComponentType.RoleSelect:
+            InteractionClass = RoleSelectMenuInteraction;
+            break;
+          case ComponentType.MentionableSelect:
+            InteractionClass = MentionableSelectMenuInteraction;
+            break;
+          case ComponentType.ChannelSelect:
+            InteractionClass = ChannelSelectMenuInteraction;
+            break;
+          default:
+            client.emit(
+              Events.Debug,
+              `[INTERACTION] Received component interaction with unknown type: ${data.data.component_type}`,
+            );
+            return;
+        }
+
+        break;
+      case InteractionType.ApplicationCommandAutocomplete:
+        InteractionClass = AutocompleteInteraction;
+        break;
+      case InteractionType.ModalSubmit:
+        InteractionClass = ModalSubmitInteraction;
+        break;
+      default:
+        client.emit(Events.Debug, `[INTERACTION] Received interaction with unknown type: ${data.type}`);
+        return;
+    }
+
+    const interaction = new InteractionClass(client, data);
+
+    /**
+     * Emitted when an interaction is created.
+     *
+     * @event Client#interactionCreate
+     * @param {BaseInteraction} interaction The interaction which was created
+     */
+    client.emit(Events.InteractionCreate, interaction);
+  }
+}

package/src/client/actions/MessageCreate.ts

@@ -0,0 +1,38 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class MessageCreateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = this.getChannel({
+      id: data.channel_id,
+      author: data.author,
+      ...('guild_id' in data && { guild_id: data.guild_id }),
+    });
+    if (channel) {
+      if (!channel.isTextBased()) return {};
+
+      if (channel.isThread()) {
+        channel.messageCount++;
+        channel.totalMessageSent++;
+      }
+
+      const existing = channel.messages.cache.get(data.id);
+      if (existing && existing.author?.id !== this.client.user.id) return { message: existing };
+      const message = existing ?? channel.messages._add(data);
+      channel.lastMessageId = data.id;
+
+      /**
+       * Emitted whenever a message is created.
+       *
+       * @event Client#messageCreate
+       * @param {Message} message The created message
+       */
+      client.emit(Events.MessageCreate, message);
+
+      return { message };
+    }
+
+    return {};
+  }
+}

package/src/client/actions/MessageDelete.ts

@@ -0,0 +1,29 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class MessageDeleteAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = this.getChannel({ id: data.channel_id, ...('guild_id' in data && { guild_id: data.guild_id }) });
+    let message;
+    if (channel) {
+      if (!channel.isTextBased()) return {};
+
+      if (channel.isThread()) channel.messageCount--;
+
+      message = this.getMessage(data, channel);
+      if (message) {
+        channel.messages.cache.delete(message.id);
+        /**
+         * Emitted whenever a message is deleted.
+         *
+         * @event Client#messageDelete
+         * @param {Message} message The deleted message
+         */
+        client.emit(Events.MessageDelete, message);
+      }
+    }
+
+    return { message };
+  }
+}

package/src/client/actions/MessageDeleteBulk.ts

@@ -0,0 +1,45 @@
+import { Collection  } from '@ovencord/collection';
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class MessageDeleteBulkAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = client.channels.cache.get(data.channel_id);
+
+    if (channel) {
+      if (!channel.isTextBased()) return {};
+
+      if (channel.isThread()) channel.messageCount -= data.ids.length;
+
+      const ids = data.ids;
+      const messages = new Collection();
+      for (const id of ids) {
+        const message = this.getMessage(
+          {
+            id,
+            guild_id: data.guild_id,
+          },
+          channel,
+          false,
+        );
+        if (message) {
+          messages.set(message.id, message);
+          channel.messages.cache.delete(id);
+        }
+      }
+
+      /**
+       * Emitted whenever messages are deleted in bulk.
+       *
+       * @event Client#messageDeleteBulk
+       * @param {Collection<Snowflake, Message>} messages The deleted messages, mapped by their id
+       * @param {GuildTextBasedChannel} channel The channel that the messages were deleted in
+       */
+      if (messages.size > 0) client.emit(Events.MessageBulkDelete, messages, channel);
+      return { messages };
+    }
+
+    return {};
+  }
+}

package/src/client/actions/MessagePollVoteAdd.ts

@@ -0,0 +1,37 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class MessagePollVoteAddAction extends Action {
+  handle(data) {
+    const channel = this.getChannel({ id: data.channel_id, ...('guild_id' in data && { guild_id: data.guild_id }) });
+    if (!channel?.isTextBased()) return false;
+
+    const message = this.getMessage(data, channel);
+    if (!message) return false;
+
+    const poll = this.getPoll(data, message, channel);
+    if (!poll) return false;
+
+    const answer = poll.answers.get(data.answer_id);
+    if (!answer) return false;
+
+    const user = this.getUser(data);
+
+    if (user) {
+      answer.voters._add(user);
+    }
+
+    answer.voteCount++;
+
+    /**
+     * Emitted whenever a user votes in a poll.
+     *
+     * @event Client#messagePollVoteAdd
+     * @param {PollAnswer} pollAnswer The answer that was voted on
+     * @param {Snowflake} userId The id of the user that voted
+     */
+    this.client.emit(Events.MessagePollVoteAdd, answer, data.user_id);
+
+    return { poll };
+  }
+}

package/src/client/actions/MessagePollVoteRemove.ts

@@ -0,0 +1,35 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class MessagePollVoteRemoveAction extends Action {
+  handle(data) {
+    const channel = this.getChannel({ id: data.channel_id, ...('guild_id' in data && { guild_id: data.guild_id }) });
+    if (!channel?.isTextBased()) return false;
+
+    const message = this.getMessage(data, channel);
+    if (!message) return false;
+
+    const poll = this.getPoll(data, message, channel);
+    if (!poll) return false;
+
+    const answer = poll.answers.get(data.answer_id);
+    if (!answer) return false;
+
+    answer.voters.cache.delete(data.user_id);
+
+    if (answer.voteCount > 0) {
+      answer.voteCount--;
+    }
+
+    /**
+     * Emitted whenever a user removes their vote in a poll.
+     *
+     * @event Client#messagePollVoteRemove
+     * @param {PollAnswer} pollAnswer The answer where the vote was removed
+     * @param {Snowflake} userId The id of the user that removed their vote
+     */
+    this.client.emit(Events.MessagePollVoteRemove, answer, data.user_id);
+
+    return { poll };
+  }
+}

package/src/client/actions/MessageReactionAdd.ts

@@ -0,0 +1,68 @@
+import { Events  } from '../../util/Events.js';
+import { Partials  } from '../../util/Partials.js';
+import { Action  } from './Action.js';
+
+/*
+{ user_id: 'id',
+     message_id: 'id',
+     emoji: { name: '�', id: null },
+     channel_id: 'id',
+     burst: boolean
+     // If originating from a guild
+     guild_id: 'id',
+     member: { ..., user: { ... } } }
+*/
+
+export class MessageReactionAddAction extends Action {
+  handle(data, fromStructure = false) {
+    if (!data.emoji) return false;
+
+    const user = this.getUserFromMember(data);
+    if (!user) return false;
+
+    // Verify channel
+    const channel = this.getChannel({
+      id: data.channel_id,
+      ...('guild_id' in data && { guild_id: data.guild_id }),
+      user_id: data.user_id,
+      ...this.spreadInjectedData(data),
+    });
+
+    if (!channel?.isTextBased()) return false;
+
+    // Verify message
+    const message = this.getMessage(data, channel);
+    if (!message) return false;
+
+    // Verify reaction
+    const includePartial = this.client.options.partials.includes(Partials.Reaction);
+    if (message.partial && !includePartial) return false;
+    const reaction = message.reactions._add({
+      emoji: data.emoji,
+      count: message.partial ? null : 0,
+      me: user.id === this.client.user.id,
+      burst_colors: data.burst_colors,
+    });
+    if (!reaction) return false;
+    reaction._add(user, data.burst);
+    if (fromStructure) return { message, reaction, user };
+    /**
+     * Provides additional information about altered reaction
+     *
+     * @typedef {Object} MessageReactionEventDetails
+     * @property {ReactionType} type The type of the reaction
+     * @property {boolean} burst Determines whether a super reaction was used
+     */
+    /**
+     * Emitted whenever a reaction is added to a cached message.
+     *
+     * @event Client#messageReactionAdd
+     * @param {MessageReaction} messageReaction The reaction object
+     * @param {User} user The user that applied the guild or reaction emoji
+     * @param {MessageReactionEventDetails} details Details of adding the reaction
+     */
+    this.client.emit(Events.MessageReactionAdd, reaction, user, { type: data.type, burst: data.burst });
+
+    return { message, reaction, user };
+  }
+}

package/src/client/actions/MessageReactionRemove.ts

@@ -0,0 +1,47 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+/*
+{ user_id: 'id',
+     message_id: 'id',
+     emoji: { name: '�', id: null },
+     channel_id: 'id',
+     guild_id: 'id' }
+*/
+
+export class MessageReactionRemoveAction extends Action {
+  handle(data) {
+    if (!data.emoji) return false;
+
+    const user = this.getUser(data);
+    if (!user) return false;
+
+    // Verify channel
+    const channel = this.getChannel({
+      id: data.channel_id,
+      ...('guild_id' in data && { guild_id: data.guild_id }),
+      user_id: data.user_id,
+    });
+    if (!channel?.isTextBased()) return false;
+
+    // Verify message
+    const message = this.getMessage(data, channel);
+    if (!message) return false;
+
+    // Verify reaction
+    const reaction = this.getReaction(data, message, user);
+    if (!reaction) return false;
+    reaction._remove(user, data.burst);
+    /**
+     * Emitted whenever a reaction is removed from a cached message.
+     *
+     * @event Client#messageReactionRemove
+     * @param {MessageReaction} messageReaction The reaction object
+     * @param {User} user The user whose emoji or reaction emoji was removed
+     * @param {MessageReactionEventDetails} details Details of removing the reaction
+     */
+    this.client.emit(Events.MessageReactionRemove, reaction, user, { type: data.type, burst: data.burst });
+
+    return { message, reaction, user };
+  }
+}

package/src/client/actions/MessageReactionRemoveAll.ts

@@ -0,0 +1,30 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class MessageReactionRemoveAllAction extends Action {
+  handle(data) {
+    // Verify channel
+    const channel = this.getChannel({ id: data.channel_id, ...('guild_id' in data && { guild_id: data.guild_id }) });
+    if (!channel?.isTextBased()) return false;
+
+    // Verify message
+    const message = this.getMessage(data, channel);
+    if (!message) return false;
+
+    // Copy removed reactions to emit for the event.
+    const removed = message.reactions.cache.clone();
+
+    message.reactions.cache.clear();
+    this.client.emit(Events.MessageReactionRemoveAll, message, removed);
+
+    return { message };
+  }
+}
+
+/**
+ * Emitted whenever all reactions are removed from a cached message.
+ *
+ * @event Client#messageReactionRemoveAll
+ * @param {Message} message The message the reactions were removed from
+ * @param {Collection<string|Snowflake, MessageReaction>} reactions The cached message reactions that were removed.
+ */

package/src/client/actions/MessageReactionRemoveEmoji.ts

@@ -0,0 +1,25 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class MessageReactionRemoveEmojiAction extends Action {
+  handle(data) {
+    const channel = this.getChannel({ id: data.channel_id, ...('guild_id' in data && { guild_id: data.guild_id }) });
+    if (!channel?.isTextBased()) return false;
+
+    const message = this.getMessage(data, channel);
+    if (!message) return false;
+
+    const reaction = this.getReaction(data, message);
+    if (!reaction) return false;
+    if (!message.partial) message.reactions.cache.delete(reaction.emoji.id ?? reaction.emoji.name);
+
+    /**
+     * Emitted when a bot removes an emoji reaction from a cached message.
+     *
+     * @event Client#messageReactionRemoveEmoji
+     * @param {MessageReaction} reaction The reaction that was removed
+     */
+    this.client.emit(Events.MessageReactionRemoveEmoji, reaction);
+    return { reaction };
+  }
+}

package/src/client/actions/MessageUpdate.ts

@@ -0,0 +1,22 @@
+import { Action  } from './Action.js';
+
+export class MessageUpdateAction extends Action {
+  handle(data) {
+    const channel = this.getChannel({ id: data.channel_id, ...('guild_id' in data && { guild_id: data.guild_id }) });
+    if (channel) {
+      if (!channel.isTextBased()) return {};
+
+      const { id, channel_id, guild_id, author, timestamp, type } = data;
+      const message = this.getMessage({ id, channel_id, guild_id, author, timestamp, type }, channel);
+      if (message) {
+        const old = message._update(data);
+        return {
+          old,
+          updated: message,
+        };
+      }
+    }
+
+    return {};
+  }
+}