@ovencord/discord.js 14.16.3

package/src/client/actions/StageInstanceCreate.ts

@@ -0,0 +1,25 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class StageInstanceCreateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = this.getChannel({ id: data.channel_id, guild_id: data.guild_id });
+
+    if (channel) {
+      const stageInstance = channel.guild.stageInstances._add(data);
+
+      /**
+       * Emitted whenever a stage instance is created.
+       *
+       * @event Client#stageInstanceCreate
+       * @param {StageInstance} stageInstance The created stage instance
+       */
+      client.emit(Events.StageInstanceCreate, stageInstance);
+
+      return { stageInstance };
+    }
+
+    return {};
+  }
+}

package/src/client/actions/StageInstanceDelete.ts

@@ -0,0 +1,28 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class StageInstanceDeleteAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = this.getChannel({ id: data.channel_id, guild_id: data.guild_id });
+
+    if (channel) {
+      const stageInstance = channel.guild.stageInstances._add(data);
+      if (stageInstance) {
+        channel.guild.stageInstances.cache.delete(stageInstance.id);
+
+        /**
+         * Emitted whenever a stage instance is deleted.
+         *
+         * @event Client#stageInstanceDelete
+         * @param {StageInstance} stageInstance The deleted stage instance
+         */
+        client.emit(Events.StageInstanceDelete, stageInstance);
+
+        return { stageInstance };
+      }
+    }
+
+    return {};
+  }
+}

package/src/client/actions/StageInstanceUpdate.ts

@@ -0,0 +1,27 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class StageInstanceUpdateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = this.getChannel({ id: data.channel_id, guild_id: data.guild_id });
+
+    if (channel) {
+      const oldStageInstance = channel.guild.stageInstances.cache.get(data.id)?._clone() ?? null;
+      const newStageInstance = channel.guild.stageInstances._add(data);
+
+      /**
+       * Emitted whenever a stage instance gets updated - e.g. change in topic or privacy level
+       *
+       * @event Client#stageInstanceUpdate
+       * @param {?StageInstance} oldStageInstance The stage instance before the update
+       * @param {StageInstance} newStageInstance The stage instance after the update
+       */
+      client.emit(Events.StageInstanceUpdate, oldStageInstance, newStageInstance);
+
+      return { oldStageInstance, newStageInstance };
+    }
+
+    return {};
+  }
+}

package/src/client/actions/ThreadCreate.ts

@@ -0,0 +1,22 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class ThreadCreateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const existing = client.channels.cache.has(data.id);
+    const thread = client.channels._add(data);
+    if (!existing && thread) {
+      /**
+       * Emitted whenever a thread is created or when the client user is added to a thread.
+       *
+       * @event Client#threadCreate
+       * @param {ThreadChannel} thread The thread that was created
+       * @param {boolean} newlyCreated Whether the thread was newly created
+       */
+      client.emit(Events.ThreadCreate, thread, data.newly_created ?? false);
+    }
+
+    return { thread };
+  }
+}

package/src/client/actions/ThreadMembersUpdate.ts

@@ -0,0 +1,45 @@
+import { Collection  } from '@ovencord/collection';
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class ThreadMembersUpdateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const thread = client.channels.cache.get(data.id);
+    if (thread) {
+      thread.memberCount = data.member_count;
+      const addedMembers = new Collection();
+      const removedMembers = new Collection();
+
+      data.added_members?.reduce(
+        (_addedMembers, addedMember) => _addedMembers.set(addedMember.user_id, thread.members._add(addedMember)),
+        addedMembers,
+      );
+
+      data.removed_member_ids?.reduce((removedMembersIds, removedMembersId) => {
+        const threadMember = this.getThreadMember(removedMembersId, thread.members);
+        if (threadMember) removedMembersIds.set(threadMember.id, threadMember);
+        thread.members.cache.delete(removedMembersId);
+        return removedMembersIds;
+      }, removedMembers);
+
+      if (addedMembers.size === 0 && removedMembers.size === 0) {
+        // Uncached thread member(s) left.
+        return {};
+      }
+
+      /**
+       * Emitted whenever members are added or removed from a thread.
+       * <info>This event requires the {@link GatewayIntentBits.GuildMembers} privileged gateway intent.</info>
+       *
+       * @event Client#threadMembersUpdate
+       * @param {Collection<Snowflake, ThreadMember>} addedMembers The members that were added
+       * @param {Collection<Snowflake, ThreadMember>} removedMembers The members that were removed
+       * @param {ThreadChannel} thread The thread where members got updated
+       */
+      client.emit(Events.ThreadMembersUpdate, addedMembers, removedMembers, thread);
+    }
+
+    return {};
+  }
+}

package/src/client/actions/TypingStart.ts

@@ -0,0 +1,26 @@
+import { Typing  } from '../../structures/Typing.js';
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class TypingStartAction 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.isTextBased()) {
+      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.TypingStart, new Typing(channel, user, data));
+    }
+  }
+}

package/src/client/actions/UserUpdate.ts

@@ -0,0 +1,33 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export 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 {@link Events.UserUpdate},
+       * {@link Events.GuildMemberUpdate}, and {@link Events.PresenceUpdate}.
+       *
+       * @event Client#userUpdate
+       * @param {User} oldUser The user before the update
+       * @param {User} newUser The user after the update
+       */
+      client.emit(Events.UserUpdate, oldUser, newUser);
+      return {
+        old: oldUser,
+        updated: newUser,
+      };
+    }
+
+    return {
+      old: null,
+      updated: null,
+    };
+  }
+}

package/src/client/voice/ClientVoiceManager.ts

@@ -0,0 +1,46 @@
+import { WebSocketShardEvents, CloseCodes  } from '@ovencord/ws';
+
+/**
+ * Manages voice connections for the client
+ */
+export class ClientVoiceManager {
+  public client: any;
+  public adapters: any;
+  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 `@ovencord/voice`.
+     *
+     * @type {Map<Snowflake, Object>}
+     */
+    this.adapters = new Map();
+
+    client.ws.on(WebSocketShardEvents.Closed, (code, shardId) => {
+      if (code === CloseCodes.Normal) {
+        for (const [guildId, adapter] of this.adapters.entries()) {
+          if (client.guilds.cache.get(guildId)?.shardId === shardId) {
+            adapter.destroy();
+          }
+        }
+      }
+    });
+  }
+
+  onVoiceServer(payload) {
+    this.adapters.get(payload.guild_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);
+    }
+  }
+}

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

@@ -0,0 +1,19 @@
+
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  /**
+   * Emitted whenever permissions for an application command in a guild were updated.
+   * <warn>This includes permission updates for other applications in addition to the logged in client,
+   * check `data.applicationId` to verify which application the update is for</warn>
+   *
+   * @event Client#applicationCommandPermissionsUpdate
+   * @param {ApplicationCommandPermissionsUpdateData} data The updated permissions
+   */
+  client.emit(Events.ApplicationCommandPermissionsUpdate, {
+    permissions: data.permissions,
+    id: data.id,
+    guildId: data.guild_id,
+    applicationId: data.application_id,
+  });
+};

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

@@ -0,0 +1,17 @@
+
+import { AutoModerationActionExecution  } from '../../../structures/AutoModerationActionExecution.js';
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+  if (!guild) return;
+
+  /**
+   * Emitted whenever an auto moderation rule is triggered.
+   * <info>This event requires the {@link PermissionFlagsBits.ManageGuild} permission.</info>
+   *
+   * @event Client#autoModerationActionExecution
+   * @param {AutoModerationActionExecution} autoModerationActionExecution The data of the execution
+   */
+  client.emit(Events.AutoModerationActionExecution, new AutoModerationActionExecution(data, guild));
+};

package/src/client/websocket/handlers/AUTO_MODERATION_RULE_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 autoModerationRule = guild.autoModerationRules._add(data);
+
+  /**
+   * Emitted whenever an auto moderation rule is created.
+   * <info>This event requires the {@link PermissionFlagsBits.ManageGuild} permission.</info>
+   *
+   * @event Client#autoModerationRuleCreate
+   * @param {AutoModerationRule} autoModerationRule The created auto moderation rule
+   */
+  client.emit(Events.AutoModerationRuleCreate, autoModerationRule);
+};

package/src/client/websocket/handlers/AUTO_MODERATION_RULE_DELETE.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 autoModerationRule = guild.autoModerationRules.cache.get(data.id);
+  if (!autoModerationRule) return;
+
+  guild.autoModerationRules.cache.delete(autoModerationRule.id);
+
+  /**
+   * Emitted whenever an auto moderation rule is deleted.
+   * <info>This event requires the {@link PermissionFlagsBits.ManageGuild} permission.</info>
+   *
+   * @event Client#autoModerationRuleDelete
+   * @param {AutoModerationRule} autoModerationRule The deleted auto moderation rule
+   */
+  client.emit(Events.AutoModerationRuleDelete, autoModerationRule);
+};

package/src/client/websocket/handlers/AUTO_MODERATION_RULE_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 oldAutoModerationRule = guild.autoModerationRules.cache.get(data.id)?._clone() ?? null;
+  const newAutoModerationRule = guild.autoModerationRules._add(data);
+
+  /**
+   * Emitted whenever an auto moderation rule gets updated.
+   * <info>This event requires the {@link PermissionFlagsBits.ManageGuild} permission.</info>
+   *
+   * @event Client#autoModerationRuleUpdate
+   * @param {?AutoModerationRule} oldAutoModerationRule The auto moderation rule before the update
+   * @param {AutoModerationRule} newAutoModerationRule The auto moderation rule after the update
+   */
+  client.emit(Events.AutoModerationRuleUpdate, oldAutoModerationRule, newAutoModerationRule);
+};

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

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

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

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

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

@@ -0,0 +1,22 @@
+
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  const channel = client.channels.cache.get(data.channel_id);
+  const time = data.last_pin_timestamp ? Date.parse(data.last_pin_timestamp) : null;
+
+  if (channel) {
+    // Discord sends null for last_pin_timestamp if the last pinned message was removed
+    channel.lastPinTimestamp = time;
+
+    /**
+     * Emitted whenever the pins of a channel are updated. Due to the nature of the WebSocket event,
+     * not much information can be provided easily here - you need to manually check the pins yourself.
+     *
+     * @event Client#channelPinsUpdate
+     * @param {TextBasedChannels} channel The channel that the pins update occurred in
+     * @param {Date} time The time of the pins update
+     */
+    client.emit(Events.ChannelPinsUpdate, channel, time);
+  }
+};

package/src/client/websocket/handlers/CHANNEL_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 channel is updated - e.g. name change, topic change, channel type change.
+     *
+     * @event Client#channelUpdate
+     * @param {DMChannel|GuildChannel} oldChannel The channel before the update
+     * @param {DMChannel|GuildChannel} newChannel The channel after the update
+     */
+    client.emit(Events.ChannelUpdate, old, updated);
+  }
+};

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

@@ -0,0 +1,14 @@
+
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  const entitlement = client.application.entitlements._add(data);
+
+  /**
+   * Emitted whenever an entitlement is created.
+   *
+   * @event Client#entitlementCreate
+   * @param {Entitlement} entitlement The entitlement that was created
+   */
+  client.emit(Events.EntitlementCreate, entitlement);
+};

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

@@ -0,0 +1,18 @@
+
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  const entitlement = client.application.entitlements._add(data, false);
+
+  client.application.entitlements.cache.delete(entitlement.id);
+
+  /**
+   * Emitted whenever an entitlement is deleted.
+   * <warn>Entitlements are not deleted when they expire.
+   * This is only triggered when Discord issues a refund or deletes the entitlement manually.</warn>
+   *
+   * @event Client#entitlementDelete
+   * @param {Entitlement} entitlement The entitlement that was deleted
+   */
+  client.emit(Events.EntitlementDelete, entitlement);
+};

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

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

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

@@ -0,0 +1,19 @@
+
+import { GuildAuditLogsEntry  } from '../../../structures/GuildAuditLogsEntry.js';
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+  if (!guild) return;
+
+  const auditLogEntry = new GuildAuditLogsEntry(guild, data);
+
+  /**
+   * Emitted whenever a guild audit log entry is created.
+   *
+   * @event Client#guildAuditLogEntryCreate
+   * @param {GuildAuditLogsEntry} auditLogEntry The entry that was created
+   * @param {Guild} guild The guild where the entry was created
+   */
+  client.emit(Events.GuildAuditLogEntryCreate, auditLogEntry, guild);
+};

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

@@ -0,0 +1,15 @@
+
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+  if (!guild) return;
+
+  /**
+   * Emitted whenever a member is banned from a guild.
+   *
+   * @event Client#guildBanAdd
+   * @param {GuildBan} ban The ban that occurred
+   */
+  client.emit(Events.GuildBanAdd, guild.bans._add(data));
+};

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

@@ -0,0 +1,20 @@
+
+import { GuildBan  } from '../../../structures/GuildBan.js';
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+  if (!guild) return;
+
+  const ban = guild.bans.cache.get(data.user.id) ?? new GuildBan(client, data, guild);
+
+  guild.bans.cache.delete(ban.user.id);
+
+  /**
+   * Emitted whenever a member is unbanned from a guild.
+   *
+   * @event Client#guildBanRemove
+   * @param {GuildBan} ban The ban that was removed
+   */
+  client.emit(Events.GuildBanRemove, ban);
+};

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

@@ -0,0 +1,34 @@
+
+import { Events  } from '../../../util/Events.js';
+import { Status  } from '../../../util/Status.js';
+
+module.exports = (client, { d: data }, shardId) => {
+  let guild = client.guilds.cache.get(data.id);
+  if (guild) {
+    if (!guild.available && !data.unavailable) {
+      // A newly available guild
+      guild._patch(data);
+
+      /**
+       * Emitted whenever a guild becomes available.
+       *
+       * @event Client#guildAvailable
+       * @param {Guild} guild The guild that became available
+       */
+      client.emit(Events.GuildAvailable, guild);
+    }
+  } else {
+    // A new guild
+    data.shardId = shardId;
+    guild = client.guilds._add(data);
+    if (client.status === Status.Ready) {
+      /**
+       * Emitted whenever the client joins a guild.
+       *
+       * @event Client#guildCreate
+       * @param {Guild} guild The created guild
+       */
+      client.emit(Events.GuildCreate, guild);
+    }
+  }
+};

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

@@ -0,0 +1,36 @@
+
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.id);
+  if (!guild) return;
+
+  if (data.unavailable) {
+    guild.available = false;
+
+    /**
+     * Emitted whenever a guild becomes unavailable, likely due to a server outage.
+     *
+     * @event Client#guildUnavailable
+     * @param {Guild} guild The guild that has become unavailable
+     */
+    client.emit(Events.GuildUnavailable, guild);
+
+    // Stops the GuildDelete packet thinking a guild was actually deleted,
+    // handles emitting of event itself
+    return;
+  }
+
+  for (const channel of guild.channels.cache.values()) client.channels._remove(channel.id);
+  client.voice.adapters.get(data.id)?.destroy();
+
+  client.guilds.cache.delete(guild.id);
+
+  /**
+   * Emitted whenever a guild kicks the client or the guild is deleted/left.
+   *
+   * @event Client#guildDelete
+   * @param {Guild} guild The guild that was deleted
+   */
+  client.emit(Events.GuildDelete, guild);
+};

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

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

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

@@ -0,0 +1,15 @@
+
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+  if (!guild) return;
+
+  /**
+   * Emitted whenever a guild integration is updated
+   *
+   * @event Client#guildIntegrationsUpdate
+   * @param {Guild} guild The guild whose integrations were updated
+   */
+  client.emit(Events.GuildIntegrationsUpdate, guild);
+};

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

@@ -0,0 +1,40 @@
+
+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 members = new Collection();
+
+  for (const member of data.members) members.set(member.user.id, guild.members._add(member));
+  if (data.presences) {
+    for (const presence of data.presences) guild.presences._add(Object.assign(presence, { guild }));
+  }
+
+  /**
+   * Represents the properties of a guild members chunk
+   *
+   * @typedef {Object} GuildMembersChunk
+   * @property {number} index Index of the received chunk
+   * @property {number} count Number of chunks the client should receive
+   * @property {Array<*>} notFound An array of whatever could not be found
+   * when using {@link GatewayOpcodes.RequestGuildMembers}
+   * @property {?string} nonce Nonce for this chunk
+   */
+
+  /**
+   * Emitted whenever a chunk of guild members is received (all members come from the same guild).
+   *
+   * @event Client#guildMembersChunk
+   * @param {Collection<Snowflake, GuildMember>} members The members in the chunk
+   * @param {Guild} guild The guild related to the member chunk
+   * @param {GuildMembersChunk} chunk Properties of the received chunk
+   */
+  client.emit(Events.GuildMembersChunk, members, guild, {
+    index: data.chunk_index,
+    count: data.chunk_count,
+    notFound: data.not_found,
+    nonce: data.nonce,
+  });
+};