@ovencord/discord.js 14.16.7 → 14.16.9

package/package.json

@@ -1,7 +1,7 @@
 {
 	"$schema": "https://json.schemastore.org/package.json",
 	"name": "@ovencord/discord.js",
-	"version": "14.16.7",
+	"version": "14.16.9",
 	"description": "A powerful library for interacting with the Discord API",
 	"scripts": {
 		"test": "bun test",

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

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

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

@@ -0,0 +1,4 @@
+
+export default (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';
+
+export default (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';
+
+export default (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';
+
+export default (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';
+
+export default (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';
+
+export default (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';
+
+export default (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';
+
+export default (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';
+
+export default (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';
+
+export default (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';
+
+export default (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 @@
+
+export default (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';
+
+export default (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';
+
+export default (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,
+  });
+};

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

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

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

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

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

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

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

@@ -0,0 +1,4 @@
+
+export default (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';
+
+export default (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';
+
+export default (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 @@
+
+export default (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';
+
+export default (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 @@
+
+export default (client, packet) => {
+  client.actions.GuildScheduledEventUserAdd.handle(packet.d);
+};

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

@@ -0,0 +1,4 @@
+
+export default (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';
+
+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 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';
+
+export default (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 @@
+
+export default (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';
+
+export default (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 @@
+
+export default (client, packet) => {
+  client.actions.GuildStickersUpdate.handle(packet.d);
+};

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

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

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

@@ -0,0 +1,4 @@
+
+export default (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';
+
+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 = 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);
+};