@ovencord/discord.js 14.16.3

package/src/client/websocket/handlers/GUILD_MEMBER_ADD.ts

@@ -0,0 +1,17 @@
+
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+  if (guild) {
+    guild.memberCount++;
+    const member = guild.members._add(data);
+    /**
+     * Emitted whenever a user joins a guild.
+     *
+     * @event Client#guildMemberAdd
+     * @param {GuildMember} member The member that has joined a guild
+     */
+    client.emit(Events.GuildMemberAdd, member);
+  }
+};

package/src/client/websocket/handlers/GUILD_MEMBER_REMOVE.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, packet) => {
+  client.actions.GuildMemberRemove.handle(packet.d);
+};

package/src/client/websocket/handlers/GUILD_MEMBER_UPDATE.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, packet) => {
+  client.actions.GuildMemberUpdate.handle(packet.d);
+};

package/src/client/websocket/handlers/GUILD_ROLE_CREATE.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, packet) => {
+  client.actions.GuildRoleCreate.handle(packet.d);
+};

package/src/client/websocket/handlers/GUILD_ROLE_DELETE.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, packet) => {
+  client.actions.GuildRoleDelete.handle(packet.d);
+};

package/src/client/websocket/handlers/GUILD_ROLE_UPDATE.ts

@@ -0,0 +1,21 @@
+
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+  if (!guild) return;
+
+  const role = guild.roles.cache.get(data.role.id);
+  if (!role) return;
+
+  const old = role._update(data.role);
+
+  /**
+   * Emitted whenever a guild role is updated.
+   *
+   * @event Client#roleUpdate
+   * @param {Role} oldRole The role before the update
+   * @param {Role} newRole The role after the update
+   */
+  client.emit(Events.GuildRoleUpdate, old, role);
+};

package/src/client/websocket/handlers/GUILD_SCHEDULED_EVENT_CREATE.ts

@@ -0,0 +1,17 @@
+
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+  if (!guild) return;
+
+  const guildScheduledEvent = guild.scheduledEvents._add(data);
+
+  /**
+   * Emitted whenever a guild scheduled event is created.
+   *
+   * @event Client#guildScheduledEventCreate
+   * @param {GuildScheduledEvent} guildScheduledEvent The created guild scheduled event
+   */
+  client.emit(Events.GuildScheduledEventCreate, guildScheduledEvent);
+};

package/src/client/websocket/handlers/GUILD_SCHEDULED_EVENT_DELETE.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, packet) => {
+  client.actions.GuildScheduledEventDelete.handle(packet.d);
+};

package/src/client/websocket/handlers/GUILD_SCHEDULED_EVENT_UPDATE.ts

@@ -0,0 +1,19 @@
+
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+  if (!guild) return;
+
+  const oldGuildScheduledEvent = guild.scheduledEvents.cache.get(data.id)?._clone() ?? null;
+  const newGuildScheduledEvent = guild.scheduledEvents._add(data);
+
+  /**
+   * Emitted whenever a guild scheduled event gets updated.
+   *
+   * @event Client#guildScheduledEventUpdate
+   * @param {?GuildScheduledEvent} oldGuildScheduledEvent The guild scheduled event object before the update
+   * @param {GuildScheduledEvent} newGuildScheduledEvent The guild scheduled event object after the update
+   */
+  client.emit(Events.GuildScheduledEventUpdate, oldGuildScheduledEvent, newGuildScheduledEvent);
+};

package/src/client/websocket/handlers/GUILD_SCHEDULED_EVENT_USER_ADD.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, packet) => {
+  client.actions.GuildScheduledEventUserAdd.handle(packet.d);
+};

package/src/client/websocket/handlers/GUILD_SCHEDULED_EVENT_USER_REMOVE.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, packet) => {
+  client.actions.GuildScheduledEventUserRemove.handle(packet.d);
+};

package/src/client/websocket/handlers/GUILD_SOUNDBOARD_SOUNDS_UPDATE.ts

@@ -0,0 +1,24 @@
+
+import { Collection  } from '@ovencord/collection';
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+
+  if (!guild) return;
+
+  const soundboardSounds = new Collection();
+
+  for (const soundboardSound of data.soundboard_sounds) {
+    soundboardSounds.set(soundboardSound.sound_id, guild.soundboardSounds._add(soundboardSound));
+  }
+
+  /**
+   * Emitted whenever multiple guild soundboard sounds are updated.
+   *
+   * @event Client#guildSoundboardSoundsUpdate
+   * @param {Collection<Snowflake, SoundboardSound>} soundboardSounds The updated soundboard sounds
+   * @param {Guild} guild The guild that the soundboard sounds are from
+   */
+  client.emit(Events.GuildSoundboardSoundsUpdate, soundboardSounds, guild);
+};

package/src/client/websocket/handlers/GUILD_SOUNDBOARD_SOUND_CREATE.ts

@@ -0,0 +1,18 @@
+
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+
+  if (!guild) return;
+
+  const soundboardSound = guild.soundboardSounds._add(data);
+
+  /**
+   * Emitted whenever a guild soundboard sound is created.
+   *
+   * @event Client#guildSoundboardSoundCreate
+   * @param {SoundboardSound} soundboardSound The created guild soundboard sound
+   */
+  client.emit(Events.GuildSoundboardSoundCreate, soundboardSound);
+};

package/src/client/websocket/handlers/GUILD_SOUNDBOARD_SOUND_DELETE.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, { d: data }) => {
+  client.actions.GuildSoundboardSoundDelete.handle(data);
+};

package/src/client/websocket/handlers/GUILD_SOUNDBOARD_SOUND_UPDATE.ts

@@ -0,0 +1,20 @@
+
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+
+  if (!guild) return;
+
+  const oldGuildSoundboardSound = guild.soundboardSounds.cache.get(data.sound_id)?._clone() ?? null;
+  const newGuildSoundboardSound = guild.soundboardSounds._add(data);
+
+  /**
+   * Emitted whenever a guild soundboard sound is updated.
+   *
+   * @event Client#guildSoundboardSoundUpdate
+   * @param {?SoundboardSound} oldGuildSoundboardSound The guild soundboard sound before the update
+   * @param {SoundboardSound} newGuildSoundboardSound The guild soundboard sound after the update
+   */
+  client.emit(Events.GuildSoundboardSoundUpdate, oldGuildSoundboardSound, newGuildSoundboardSound);
+};

package/src/client/websocket/handlers/GUILD_STICKERS_UPDATE.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, packet) => {
+  client.actions.GuildStickersUpdate.handle(packet.d);
+};

package/src/client/websocket/handlers/GUILD_UPDATE.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, packet) => {
+  client.actions.GuildUpdate.handle(packet.d);
+};

package/src/client/websocket/handlers/INTERACTION_CREATE.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, packet) => {
+  client.actions.InteractionCreate.handle(packet.d);
+};

package/src/client/websocket/handlers/INVITE_CREATE.ts

@@ -0,0 +1,20 @@
+
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  const channel = client.channels.cache.get(data.channel_id);
+  const guild = client.guilds.cache.get(data.guild_id);
+  if (!channel) return;
+
+  const inviteData = Object.assign(data, { channel, guild });
+  const invite = guild.invites._add(inviteData);
+
+  /**
+   * Emitted when an invite is created.
+   * <info>This event requires the {@link PermissionFlagsBits.ManageChannels} permission for the channel.</info>
+   *
+   * @event Client#inviteCreate
+   * @param {GuildInvite} invite The invite that was created
+   */
+  client.emit(Events.InviteCreate, invite);
+};

package/src/client/websocket/handlers/INVITE_DELETE.ts

@@ -0,0 +1,23 @@
+
+import { GuildInvite  } from '../../../structures/GuildInvite.js';
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  const channel = client.channels.cache.get(data.channel_id);
+  const guild = client.guilds.cache.get(data.guild_id);
+  if (!channel) return;
+
+  const inviteData = Object.assign(data, { channel, guild });
+  const invite = new GuildInvite(client, inviteData);
+
+  guild.invites.cache.delete(invite.code);
+
+  /**
+   * Emitted when an invite is deleted.
+   * <info>This event requires the {@link PermissionFlagsBits.ManageChannels} permission for the channel.</info>
+   *
+   * @event Client#inviteDelete
+   * @param {GuildInvite} invite The invite that was deleted
+   */
+  client.emit(Events.InviteDelete, invite);
+};

package/src/client/websocket/handlers/MESSAGE_CREATE.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, packet) => {
+  client.actions.MessageCreate.handle(packet.d);
+};

package/src/client/websocket/handlers/MESSAGE_DELETE.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, packet) => {
+  client.actions.MessageDelete.handle(packet.d);
+};

package/src/client/websocket/handlers/MESSAGE_DELETE_BULK.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, packet) => {
+  client.actions.MessageDeleteBulk.handle(packet.d);
+};

package/src/client/websocket/handlers/MESSAGE_POLL_VOTE_ADD.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, packet) => {
+  client.actions.MessagePollVoteAdd.handle(packet.d);
+};

package/src/client/websocket/handlers/MESSAGE_POLL_VOTE_REMOVE.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, packet) => {
+  client.actions.MessagePollVoteRemove.handle(packet.d);
+};

package/src/client/websocket/handlers/MESSAGE_REACTION_ADD.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, packet) => {
+  client.actions.MessageReactionAdd.handle(packet.d);
+};

package/src/client/websocket/handlers/MESSAGE_REACTION_REMOVE.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, packet) => {
+  client.actions.MessageReactionRemove.handle(packet.d);
+};

package/src/client/websocket/handlers/MESSAGE_REACTION_REMOVE_ALL.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, packet) => {
+  client.actions.MessageReactionRemoveAll.handle(packet.d);
+};

package/src/client/websocket/handlers/MESSAGE_REACTION_REMOVE_EMOJI.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, packet) => {
+  client.actions.MessageReactionRemoveEmoji.handle(packet.d);
+};

package/src/client/websocket/handlers/MESSAGE_UPDATE.ts

@@ -0,0 +1,16 @@
+
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, packet) => {
+  const { old, updated } = client.actions.MessageUpdate.handle(packet.d);
+  if (old && updated) {
+    /**
+     * Emitted whenever a message is updated - e.g. embed or content change.
+     *
+     * @event Client#messageUpdate
+     * @param {Message} oldMessage The message before the update
+     * @param {Message} newMessage The message after the update
+     */
+    client.emit(Events.MessageUpdate, old, updated);
+  }
+};

package/src/client/websocket/handlers/PRESENCE_UPDATE.ts

@@ -0,0 +1,42 @@
+
+import { Events  } from '../../../util/Events.js';
+import { Partials  } from '../../../util/Partials.js';
+
+module.exports = (client, { d: data }) => {
+  let user = client.users.cache.get(data.user.id);
+  if (!user && ('username' in data.user || client.options.partials.includes(Partials.User))) {
+    user = client.users._add(data.user);
+  }
+
+  if (!user) return;
+
+  if (data.user.username && !user._equals(data.user)) client.actions.UserUpdate.handle(data.user);
+
+  const guild = client.guilds.cache.get(data.guild_id);
+  if (!guild) return;
+
+  const oldPresence = guild.presences.cache.get(user.id)?._clone() ?? null;
+
+  let member = guild.members.cache.get(user.id);
+  if (!member && data.status !== 'offline') {
+    member = guild.members._add({
+      user,
+      deaf: false,
+      mute: false,
+    });
+
+    client.emit(Events.GuildMemberAvailable, member);
+  }
+
+  const newPresence = guild.presences._add(Object.assign(data, { guild }));
+  if (client.listenerCount(Events.PresenceUpdate) > 0 && !newPresence.equals(oldPresence)) {
+    /**
+     * Emitted whenever a guild member's presence (e.g. status, activity) is changed.
+     *
+     * @event Client#presenceUpdate
+     * @param {?Presence} oldPresence The presence before the update, if one at all
+     * @param {Presence} newPresence The presence after the update
+     */
+    client.emit(Events.PresenceUpdate, oldPresence, newPresence);
+  }
+};

package/src/client/websocket/handlers/RATE_LIMITED.ts

@@ -0,0 +1,23 @@
+
+import process from 'node:process';
+import { GatewayOpcodes  } from 'discord-api-types/v10';
+
+const emittedFor = new Set();
+
+module.exports = (client, { d: data }) => {
+  switch (data.opcode) {
+    case GatewayOpcodes.RequestGuildMembers: {
+      break;
+    }
+
+    default: {
+      if (!emittedFor.has(data.opcode)) {
+        process.emitWarning(
+          `Hit a gateway rate limit on opcode ${data.opcode} (${GatewayOpcodes[data.opcode]}). If the discord.js version you're using is up-to-date, please open an issue on GitHub.`,
+        );
+
+        emittedFor.add(data.opcode);
+      }
+    }
+  }
+};

package/src/client/websocket/handlers/READY.ts

@@ -0,0 +1,29 @@
+
+import { ClientApplication  } from '../../../structures/ClientApplication.js';
+import { Status  } from '../../../util/Status.js';
+
+let ClientUser;
+
+module.exports = (client, { d: data }, shardId) => {
+  if (client.user) {
+    client.user._patch(data.user);
+  } else {
+    ClientUser ??= require('../../../structures/ClientUser.js').ClientUser;
+    client.user = new ClientUser(client, data.user);
+    client.users.cache.set(client.user.id, client.user);
+  }
+
+  for (const guild of data.guilds) {
+    client.expectedGuilds.add(guild.id);
+    guild.shardId = shardId;
+    client.guilds._add(guild);
+  }
+
+  if (client.application) {
+    client.application._patch(data.application);
+  } else {
+    client.application = new ClientApplication(client, data.application);
+  }
+
+  client.status = Status.WaitingForGuilds;
+};

package/src/client/websocket/handlers/SOUNDBOARD_SOUNDS.ts

@@ -0,0 +1,24 @@
+
+import { Collection  } from '@ovencord/collection';
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+
+  if (!guild) return;
+
+  const soundboardSounds = new Collection();
+
+  for (const soundboardSound of data.soundboard_sounds) {
+    soundboardSounds.set(soundboardSound.sound_id, guild.soundboardSounds._add(soundboardSound));
+  }
+
+  /**
+   * Emitted whenever soundboard sounds are received (all soundboard sounds come from the same guild).
+   *
+   * @event Client#soundboardSounds
+   * @param {Collection<Snowflake, SoundboardSound>} soundboardSounds The sounds received
+   * @param {Guild} guild The guild that the soundboard sounds are from
+   */
+  client.emit(Events.SoundboardSounds, soundboardSounds, guild);
+};

package/src/client/websocket/handlers/STAGE_INSTANCE_CREATE.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, packet) => {
+  client.actions.StageInstanceCreate.handle(packet.d);
+};

package/src/client/websocket/handlers/STAGE_INSTANCE_DELETE.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, packet) => {
+  client.actions.StageInstanceDelete.handle(packet.d);
+};

package/src/client/websocket/handlers/STAGE_INSTANCE_UPDATE.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, packet) => {
+  client.actions.StageInstanceUpdate.handle(packet.d);
+};

package/src/client/websocket/handlers/SUBSCRIPTION_CREATE.ts

@@ -0,0 +1,14 @@
+
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  const subscription = client.application.subscriptions._add(data);
+
+  /**
+   * Emitted whenever a subscription is created.
+   *
+   * @event Client#subscriptionCreate
+   * @param {Subscription} subscription The subscription that was created
+   */
+  client.emit(Events.SubscriptionCreate, subscription);
+};

package/src/client/websocket/handlers/SUBSCRIPTION_DELETE.ts

@@ -0,0 +1,16 @@
+
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  const subscription = client.application.subscriptions._add(data, false);
+
+  client.application.subscriptions.cache.delete(subscription.id);
+
+  /**
+   * Emitted whenever a subscription is deleted.
+   *
+   * @event Client#subscriptionDelete
+   * @param {Subscription} subscription The subscription that was deleted
+   */
+  client.emit(Events.SubscriptionDelete, subscription);
+};

package/src/client/websocket/handlers/SUBSCRIPTION_UPDATE.ts

@@ -0,0 +1,16 @@
+
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  const oldSubscription = client.application.subscriptions.cache.get(data.id)?._clone() ?? null;
+  const newSubscription = client.application.subscriptions._add(data);
+
+  /**
+   * Emitted whenever a subscription is updated - i.e. when a user's subscription renews.
+   *
+   * @event Client#subscriptionUpdate
+   * @param {?Subscription} oldSubscription The subscription before the update
+   * @param {Subscription} newSubscription The subscription after the update
+   */
+  client.emit(Events.SubscriptionUpdate, oldSubscription, newSubscription);
+};

package/src/client/websocket/handlers/THREAD_CREATE.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, packet) => {
+  client.actions.ThreadCreate.handle(packet.d);
+};

package/src/client/websocket/handlers/THREAD_DELETE.ts

@@ -0,0 +1,17 @@
+
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  const thread = client.channels.cache.get(data.id);
+  if (!thread) return;
+
+  client.channels._remove(thread.id);
+
+  /**
+   * Emitted whenever a thread is deleted.
+   *
+   * @event Client#threadDelete
+   * @param {ThreadChannel} thread The thread that was deleted
+   */
+  client.emit(Events.ThreadDelete, thread);
+};

package/src/client/websocket/handlers/THREAD_LIST_SYNC.ts

@@ -0,0 +1,50 @@
+import { Collection  } from '@ovencord/collection';
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  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.cache.get(id);
+      if (channel) removeStaleThreads(client, channel);
+    }
+  } else {
+    for (const channel of guild.channels.cache.values()) {
+      removeStaleThreads(client, 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 announcement channel that contains threads
+   *
+   * @event Client#threadListSync
+   * @param {Collection<Snowflake, ThreadChannel>} threads The threads that were synced
+   * @param {Guild} guild The guild that the threads were synced in
+   */
+  client.emit(Events.ThreadListSync, syncedThreads, guild);
+};
+
+export function removeStaleThreads(client, channel) {
+  if (!channel.threads) return;
+
+  for (const thread of channel.threads.cache.values()) {
+    if (!thread.archived) {
+      client.channels._remove(thread.id);
+    }
+  }
+}

package/src/client/websocket/handlers/THREAD_MEMBERS_UPDATE.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, packet) => {
+  client.actions.ThreadMembersUpdate.handle(packet.d);
+};

package/src/client/websocket/handlers/THREAD_MEMBER_UPDATE.ts

@@ -0,0 +1,25 @@
+
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  // Discord sends the thread id as id in this object
+  const thread = client.channels.cache.get(data.id);
+  if (!thread) return;
+
+  const member = thread.members.cache.get(data.user_id);
+  if (!member) {
+    thread.members._add(data);
+    return;
+  }
+
+  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.ThreadMemberUpdate, old, member);
+};

package/src/client/websocket/handlers/THREAD_UPDATE.ts

@@ -0,0 +1,16 @@
+
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, packet) => {
+  const { old, updated } = client.actions.ChannelUpdate.handle(packet.d);
+  if (old && updated) {
+    /**
+     * Emitted whenever a thread is updated - e.g. name change, archive state change, locked state change.
+     *
+     * @event Client#threadUpdate
+     * @param {ThreadChannel} oldThread The thread before the update
+     * @param {ThreadChannel} newThread The thread after the update
+     */
+    client.emit(Events.ThreadUpdate, old, updated);
+  }
+};

package/src/client/websocket/handlers/TYPING_START.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, packet) => {
+  client.actions.TypingStart.handle(packet.d);
+};