@ovencord/discord.js 14.16.7 → 14.16.9

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

@@ -0,0 +1,23 @@
+
+import { GuildInvite  } from '../../../structures/GuildInvite.js';
+import { Events  } from '../../../util/Events.js';
+
+export default (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 @@
+
+export default (client, packet) => {
+  client.actions.MessageCreate.handle(packet.d);
+};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,4 @@
+
+export default (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';
+
+export default (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';
+
+export default (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();
+
+export default (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,30 @@
+import { ClientUser } from '../../../structures/ClientUser.js';
+
+import { ClientApplication  } from '../../../structures/ClientApplication.js';
+import { Status  } from '../../../util/Status.js';
+
+
+
+export default (client, { d: data }, shardId) => {
+  if (client.user) {
+    client.user._patch(data.user);
+  } else {
+    
+    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';
+
+export default (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 @@
+
+export default (client, packet) => {
+  client.actions.StageInstanceCreate.handle(packet.d);
+};

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

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

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

@@ -0,0 +1,4 @@
+
+export default (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';
+
+export default (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';
+
+export default (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';
+
+export default (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 @@
+
+export default (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';
+
+export default (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,51 @@
+
+import { Collection  } from '@ovencord/collection';
+import { Events  } from '../../../util/Events.js';
+
+export default (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);
+};
+
+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 @@
+
+export default (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';
+
+export default (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';
+
+export default (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 @@
+
+export default (client, packet) => {
+  client.actions.TypingStart.handle(packet.d);
+};

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

@@ -0,0 +1,4 @@
+
+export default (client, packet) => {
+  client.actions.UserUpdate.handle(packet.d);
+};

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

@@ -0,0 +1,16 @@
+
+import { VoiceChannelEffect  } from '../../../structures/VoiceChannelEffect.js';
+import { Events  } from '../../../util/Events.js';
+
+export default (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+  if (!guild) return;
+
+  /**
+   * Emitted when someone sends an effect, such as an emoji reaction, in a voice channel the client is connected to.
+   *
+   * @event Client#voiceChannelEffectSend
+   * @param {VoiceChannelEffect} voiceChannelEffect The sent voice channel effect
+   */
+  client.emit(Events.VoiceChannelEffectSend, new VoiceChannelEffect(data, guild));
+};

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

@@ -0,0 +1,5 @@
+
+export default (client, packet) => {
+  client.emit('debug', `[VOICE] received voice server: ${JSON.stringify(packet)}`);
+  client.voice.onVoiceServer(packet.d);
+};

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

@@ -0,0 +1,37 @@
+
+import { VoiceState  } from '../../../structures/VoiceState.js';
+import { Events  } from '../../../util/Events.js';
+
+export default (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+  if (!guild) return;
+
+  // 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.VoiceStateUpdate, oldState, newState);
+};

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

@@ -0,0 +1,16 @@
+
+import { Events  } from '../../../util/Events.js';
+
+export default (client, { d: data }) => {
+  const channel = client.channels.cache.get(data.channel_id);
+  if (!channel) return;
+
+  /**
+   * Emitted whenever a channel has its webhooks changed.
+   *
+   * @event Client#webhooksUpdate
+   * @param {TextChannel|AnnouncementChannel|VoiceChannel|StageChannel|ForumChannel|MediaChannel} channel
+   * The channel that had a webhook update
+   */
+  client.emit(Events.WebhooksUpdate, channel);
+};