@ovencord/discord.js 14.16.3

package/src/structures/InteractionCallbackResponse.ts

@@ -0,0 +1,35 @@
+import { InteractionCallback  } from './InteractionCallback.js';
+import { InteractionCallbackResource  } from './InteractionCallbackResource.js';
+
+/**
+ * Represents an interaction's response
+ */
+export class InteractionCallbackResponse {
+  public client: any;
+  public interaction: any;
+  public resource: any;
+  constructor(client, data) {
+    /**
+     * The client that instantiated this
+     *
+     * @name InteractionCallbackResponse#client
+     * @type {Client}
+     * @readonly
+     */
+    Object.defineProperty(this, 'client', { value: client });
+
+    /**
+     * The interaction object associated with the interaction callback response
+     *
+     * @type {InteractionCallback}
+     */
+    this.interaction = new InteractionCallback(client, data.interaction);
+
+    /**
+     * The resource that was created by the interaction response
+     *
+     * @type {?InteractionCallbackResource}
+     */
+    this.resource = data.resource ? new InteractionCallbackResource(client, data.resource) : null;
+  }
+}

package/src/structures/InteractionCollector.ts

@@ -0,0 +1,260 @@
+import { Collection  } from '@ovencord/collection';
+import { Events  } from '../util/Events.js';
+import { Collector  } from './interfaces/Collector.js';
+
+/**
+ * @typedef {CollectorOptions} InteractionCollectorOptions
+ * @property {TextBasedChannelsResolvable} [channel] The channel to listen to interactions from
+ * @property {ComponentType} [componentType] The type of component to listen for
+ * @property {GuildResolvable} [guild] The guild to listen to interactions from
+ * @property {InteractionType} [interactionType] The type of interaction to listen for
+ * @property {number} [max] The maximum total amount of interactions to collect
+ * @property {number} [maxComponents] The maximum number of components to collect
+ * @property {number} [maxUsers] The maximum number of users to interact
+ * @property {Message|APIMessage} [message] The message to listen to interactions from
+ */
+
+/**
+ * Collects interactions.
+ * Will automatically stop if the message ({@link Client#event:messageDelete messageDelete} or
+ * {@link Client#event:messageDeleteBulk messageDeleteBulk}),
+ * channel ({@link Client#event:channelDelete channelDelete}), or
+ * guild ({@link Client#event:guildDelete guildDelete}) is deleted.
+ * <info>Interaction collectors that do not specify `time` or `idle` may be prone to always running.
+ * Ensure your interaction collectors end via either of these options or manual cancellation.</info>
+ *
+ * @extends {Collector}
+ */
+export class InteractionCollector extends Collector {
+  public client: any;
+  public messageId: any;
+  public channelId: any;
+  public guildId: any;
+  public interactionType: any;
+  public componentType: any;
+  public users: any;
+  public total: any;
+  /**
+   * @param {Client} client The client on which to collect interactions
+   * @param {InteractionCollectorOptions} [options={}] The options to apply to this collector
+   */
+  constructor(client, options = {}) {
+    super(client, options);
+
+    /**
+     * The message from which to collect interactions, if provided
+     *
+     * @type {?Snowflake}
+     */
+    this.messageId = options.message?.id ?? null;
+
+    /**
+     * The channel from which to collect interactions, if provided
+     *
+     * @type {?Snowflake}
+     */
+    this.channelId =
+      options.message?.channelId ?? options.message?.channel_id ?? this.client.channels.resolveId(options.channel);
+
+    /**
+     * The guild from which to collect interactions, if provided
+     *
+     * @type {?Snowflake}
+     */
+    this.guildId =
+      options.message?.guildId ??
+      options.message?.guild_id ??
+      this.client.guilds.resolveId(options.channel?.guild) ??
+      this.client.guilds.resolveId(options.guild);
+
+    /**
+     * The type of interaction to collect
+     *
+     * @type {?InteractionType}
+     */
+    this.interactionType = options.interactionType ?? null;
+
+    /**
+     * The type of component to collect
+     *
+     * @type {?ComponentType}
+     */
+    this.componentType = options.componentType ?? null;
+
+    /**
+     * The users that have interacted with this collector
+     *
+     * @type {Collection<Snowflake, User>}
+     */
+    this.users = new Collection();
+
+    /**
+     * The total number of interactions collected
+     *
+     * @type {number}
+     */
+    this.total = 0;
+
+    this.client.incrementMaxListeners();
+
+    const bulkDeleteListener = messages => {
+      if (messages.has(this.messageId)) this.stop('messageDelete');
+    };
+
+    if (this.messageId) {
+      this._handleMessageDeletion = this._handleMessageDeletion.bind(this);
+      this.client.on(Events.MessageDelete, this._handleMessageDeletion);
+      this.client.on(Events.MessageBulkDelete, bulkDeleteListener);
+    }
+
+    if (this.channelId) {
+      this._handleChannelDeletion = this._handleChannelDeletion.bind(this);
+      this._handleThreadDeletion = this._handleThreadDeletion.bind(this);
+      this.client.on(Events.ChannelDelete, this._handleChannelDeletion);
+      this.client.on(Events.ThreadDelete, this._handleThreadDeletion);
+    }
+
+    if (this.guildId) {
+      this._handleGuildDeletion = this._handleGuildDeletion.bind(this);
+      this.client.on(Events.GuildDelete, this._handleGuildDeletion);
+    }
+
+    this.client.on(Events.InteractionCreate, this.handleCollect);
+
+    this.once('end', () => {
+      this.client.removeListener(Events.InteractionCreate, this.handleCollect);
+      this.client.removeListener(Events.MessageDelete, this._handleMessageDeletion);
+      this.client.removeListener(Events.MessageBulkDelete, bulkDeleteListener);
+      this.client.removeListener(Events.ChannelDelete, this._handleChannelDeletion);
+      this.client.removeListener(Events.ThreadDelete, this._handleThreadDeletion);
+      this.client.removeListener(Events.GuildDelete, this._handleGuildDeletion);
+      this.client.decrementMaxListeners();
+    });
+
+    this.on('collect', interaction => {
+      this.total++;
+      this.users.set(interaction.user.id, interaction.user);
+    });
+  }
+
+  /**
+   * Handles an incoming interaction for possible collection.
+   *
+   * @param {BaseInteraction} interaction The interaction to possibly collect
+   * @returns {?Snowflake}
+   * @private
+   */
+  collect(interaction) {
+    /**
+     * Emitted whenever an interaction is collected.
+     *
+     * @event InteractionCollector#collect
+     * @param {BaseInteraction} interaction The interaction that was collected
+     */
+
+    if (this.interactionType && interaction.type !== this.interactionType) return null;
+    if (this.componentType && interaction.componentType !== this.componentType) return null;
+    if (this.messageId && interaction.message?.id !== this.messageId) return null;
+    if (this.channelId && interaction.channelId !== this.channelId) return null;
+    if (this.guildId && interaction.guildId !== this.guildId) return null;
+
+    return interaction.id;
+  }
+
+  /**
+   * Handles an interaction for possible disposal.
+   *
+   * @param {BaseInteraction} interaction The interaction that could be disposed of
+   * @returns {?Snowflake}
+   */
+  dispose(interaction) {
+    /**
+     * Emitted whenever an interaction is disposed of.
+     *
+     * @event InteractionCollector#dispose
+     * @param {BaseInteraction} interaction The interaction that was disposed of
+     */
+    if (this.type && interaction.type !== this.type) return null;
+    if (this.componentType && interaction.componentType !== this.componentType) return null;
+    if (this.messageId && interaction.message?.id !== this.messageId) return null;
+    if (this.channelId && interaction.channelId !== this.channelId) return null;
+    if (this.guildId && interaction.guildId !== this.guildId) return null;
+
+    return interaction.id;
+  }
+
+  /**
+   * Empties this interaction collector.
+   */
+  empty() {
+    this.total = 0;
+    this.collected.clear();
+    this.users.clear();
+    this.checkEnd();
+  }
+
+  /**
+   * The reason this collector has ended with, or null if it hasn't ended yet
+   *
+   * @type {?string}
+   * @readonly
+   */
+  get endReason() {
+    if (this.options.max && this.total >= this.options.max) return 'limit';
+    if (this.options.maxComponents && this.collected.size >= this.options.maxComponents) return 'componentLimit';
+    if (this.options.maxUsers && this.users.size >= this.options.maxUsers) return 'userLimit';
+    return super.endReason;
+  }
+
+  /**
+   * Handles checking if the message has been deleted, and if so, stops the collector with the reason 'messageDelete'.
+   *
+   * @private
+   * @param {Message} message The message that was deleted
+   * @returns {void}
+   */
+  _handleMessageDeletion(message) {
+    if (message.id === this.messageId) {
+      this.stop('messageDelete');
+    }
+  }
+
+  /**
+   * Handles checking if the channel has been deleted, and if so, stops the collector with the reason 'channelDelete'.
+   *
+   * @private
+   * @param {GuildChannel} channel The channel that was deleted
+   * @returns {void}
+   */
+  _handleChannelDeletion(channel) {
+    if (channel.id === this.channelId || channel.threads?.cache.has(this.channelId)) {
+      this.stop('channelDelete');
+    }
+  }
+
+  /**
+   * Handles checking if the thread has been deleted, and if so, stops the collector with the reason 'threadDelete'.
+   *
+   * @private
+   * @param {ThreadChannel} thread The thread that was deleted
+   * @returns {void}
+   */
+  _handleThreadDeletion(thread) {
+    if (thread.id === this.channelId) {
+      this.stop('threadDelete');
+    }
+  }
+
+  /**
+   * Handles checking if the guild has been deleted, and if so, stops the collector with the reason 'guildDelete'.
+   *
+   * @private
+   * @param {Guild} guild The guild that was deleted
+   * @returns {void}
+   */
+  _handleGuildDeletion(guild) {
+    if (guild.id === this.guildId) {
+      this.stop('guildDelete');
+    }
+  }
+}

package/src/structures/InteractionWebhook.ts

@@ -0,0 +1,65 @@
+import { Webhook  } from './Webhook.js';
+
+/**
+ * Represents a webhook for an Interaction
+ *
+ * @implements {Webhook}
+ */
+export class InteractionWebhook {
+  public client: any;
+  public id: any;
+  /**
+   * @param {Client} client The instantiating client
+   * @param {Snowflake} id The application's id
+   * @param {string} token The interaction's token
+   */
+  constructor(client, id, token) {
+    /**
+     * The client that instantiated the interaction webhook
+     *
+     * @name InteractionWebhook#client
+     * @type {Client}
+     * @readonly
+     */
+    Object.defineProperty(this, 'client', { value: client });
+    this.id = id;
+    Object.defineProperty(this, 'token', { value: token, writable: true, configurable: true });
+  }
+
+  // These are here only for documentation purposes - they are implemented by Webhook
+
+  /**
+   * Sends a message with this webhook.
+   *
+   * @param {string|MessagePayload|InteractionReplyOptions} options The content for the reply
+   * @returns {Promise<Message>}
+   */
+
+  async send() {}
+
+  /**
+   * Gets a message that was sent by this webhook.
+   *
+   * @param {Snowflake|'@original'} message The id of the message to fetch
+   * @returns {Promise<Message>} Returns the message sent by this webhook
+   */
+
+  async fetchMessage() {}
+
+  /**
+   * Edits a message that was sent by this webhook.
+   *
+   * @param {MessageResolvable|'@original'} message The message to edit
+   * @param {string|MessagePayload|WebhookMessageEditOptions} options The options to provide
+   * @returns {Promise<Message>} Returns the message edited by this webhook
+   */
+
+  async editMessage() {}
+
+  deleteMessage() {}
+
+  // eslint-disable-next-line getter-return
+  get url() {}
+}
+
+Webhook.applyToClass(InteractionWebhook, ['sendSlackMessage', 'edit', 'delete', 'createdTimestamp', 'createdAt']);

package/src/structures/InviteGuild.ts

@@ -0,0 +1,22 @@
+import { AnonymousGuild  } from './AnonymousGuild.js';
+import { WelcomeScreen  } from './WelcomeScreen.js';
+
+/**
+ * Represents a guild received from an invite, includes welcome screen data if available.
+ *
+ * @extends {AnonymousGuild}
+ */
+export class InviteGuild extends AnonymousGuild {
+  public client: any;
+  public welcomeScreen: any;
+  constructor(client, data) {
+    super(client, data);
+
+    /**
+     * The welcome screen for this invite guild
+     *
+     * @type {?WelcomeScreen}
+     */
+    this.welcomeScreen = data.welcome_screen === undefined ? null : new WelcomeScreen(this, data.welcome_screen);
+  }
+}

package/src/structures/LabelComponent.ts

@@ -0,0 +1,51 @@
+import { createComponent  } from '../util/Components.js';
+import { Component  } from './Component.js';
+
+/**
+ * Represents a label component
+ *
+ * @extends {Component}
+ */
+export class LabelComponent extends Component {
+  public component: any;
+  constructor({ component, ...data }) {
+    super(data);
+
+    /**
+     * The component in this label
+     *
+     * @type {Component}
+     * @readonly
+     */
+    this.component = createComponent(component);
+  }
+
+  /**
+   * The label of the component
+   *
+   * @type {string}
+   * @readonly
+   */
+  get label() {
+    return this.data.label;
+  }
+
+  /**
+   * The description of this component
+   *
+   * @type {?string}
+   * @readonly
+   */
+  get description() {
+    return this.data.description ?? null;
+  }
+
+  /**
+   * Returns the API-compatible JSON for this component
+   *
+   * @returns {APILabelComponent}
+   */
+  toJSON() {
+    return { ...this.data, component: this.component.toJSON() };
+  }
+}

package/src/structures/MediaChannel.ts

@@ -0,0 +1,8 @@
+import { ThreadOnlyChannel  } from './ThreadOnlyChannel.js';
+
+/**
+ * Represents a media channel.
+ *
+ * @extends {ThreadOnlyChannel}
+ */
+export class MediaChannel extends ThreadOnlyChannel {}

package/src/structures/MediaGalleryComponent.ts

@@ -0,0 +1,31 @@
+import { Component  } from './Component.js';
+import { MediaGalleryItem  } from './MediaGalleryItem.js';
+
+/**
+ * Represents a media gallery component
+ *
+ * @extends {Component}
+ */
+export class MediaGalleryComponent extends Component {
+  public items: any;
+  constructor({ items, ...data }) {
+    super(data);
+
+    /**
+     * The items in this media gallery
+     *
+     * @type {MediaGalleryItem[]}
+     * @readonly
+     */
+    this.items = items.map(item => new MediaGalleryItem(item));
+  }
+
+  /**
+   * Returns the API-compatible JSON for this component
+   *
+   * @returns {APIMediaGalleryComponent}
+   */
+  toJSON() {
+    return { ...this.data, items: this.items.map(item => item.toJSON()) };
+  }
+}

package/src/structures/MediaGalleryItem.ts

@@ -0,0 +1,54 @@
+import { UnfurledMediaItem  } from './UnfurledMediaItem.js';
+
+/**
+ * Represents an item in a media gallery
+ */
+export class MediaGalleryItem {
+  public data: any;
+  public media: any;
+  constructor({ media, ...data }) {
+    /**
+     * The API data associated with this component
+     *
+     * @type {APIMediaGalleryItem}
+     */
+    this.data = data;
+
+    /**
+     * The media associated with this media gallery item
+     *
+     * @type {UnfurledMediaItem}
+     * @readonly
+     */
+    this.media = new UnfurledMediaItem(media);
+  }
+
+  /**
+   * The description of this media gallery item
+   *
+   * @type {?string}
+   * @readonly
+   */
+  get description() {
+    return this.data.description ?? null;
+  }
+
+  /**
+   * Whether this media gallery item is spoilered
+   *
+   * @type {boolean}
+   * @readonly
+   */
+  get spoiler() {
+    return this.data.spoiler ?? false;
+  }
+
+  /**
+   * Returns the API-compatible JSON for this component
+   *
+   * @returns {APIMediaGalleryItem}
+   */
+  toJSON() {
+    return { ...this.data, media: this.media.toJSON() };
+  }
+}

package/src/structures/MentionableSelectMenuComponent.ts

@@ -0,0 +1,8 @@
+import { BaseSelectMenuComponent  } from './BaseSelectMenuComponent.js';
+
+/**
+ * Represents a mentionable select menu component
+ *
+ * @extends {BaseSelectMenuComponent}
+ */
+export class MentionableSelectMenuComponent extends BaseSelectMenuComponent {}

package/src/structures/MentionableSelectMenuInteraction.ts

@@ -0,0 +1,76 @@
+import { Collection  } from '@ovencord/collection';
+import { Events  } from '../util/Events.js';
+import { MessageComponentInteraction  } from './MessageComponentInteraction.js';
+
+/**
+ * Represents a {@link ComponentType.MentionableSelect} select menu interaction.
+ *
+ * @extends {MessageComponentInteraction}
+ */
+export class MentionableSelectMenuInteraction extends MessageComponentInteraction {
+  public client: any;
+  public users: any;
+  public members: any;
+  public roles: any;
+  constructor(client, data) {
+    super(client, data);
+    const { resolved, values } = data.data;
+    const { members, users, roles } = resolved ?? {};
+
+    /**
+     * An array of the selected user and role ids
+     *
+     * @type {Snowflake[]}
+     */
+    this.values = values ?? [];
+
+    /**
+     * Collection of the selected users
+     *
+     * @type {Collection<Snowflake, User>}
+     */
+    this.users = new Collection();
+
+    /**
+     * Collection of the selected users
+     *
+     * @type {Collection<Snowflake, GuildMember|APIGuildMember>}
+     */
+    this.members = new Collection();
+
+    /**
+     * Collection of the selected roles
+     *
+     * @type {Collection<Snowflake, Role|APIRole>}
+     */
+    this.roles = new Collection();
+
+    if (members) {
+      for (const [id, member] of Object.entries(members)) {
+        const user = users[id];
+        if (!user) {
+          this.client.emit(
+            Events.Debug,
+            `[MentionableSelectMenuInteraction] Received a member without a user, skipping ${id}`,
+          );
+
+          continue;
+        }
+
+        this.members.set(id, this.guild?.members._add({ user, ...member }) ?? { user, ...member });
+      }
+    }
+
+    if (users) {
+      for (const user of Object.values(users)) {
+        this.users.set(user.id, this.client.users._add(user));
+      }
+    }
+
+    if (roles) {
+      for (const role of Object.values(roles)) {
+        this.roles.set(role.id, this.guild?.roles._add(role) ?? role);
+      }
+    }
+  }
+}