@ovencord/discord.js 14.16.3

package/src/structures/ModalComponentResolver.ts

@@ -0,0 +1,237 @@
+import { Collection  } from '@ovencord/collection';
+import { ComponentType  } from 'discord-api-types/v10';
+import { DiscordjsTypeError, ErrorCodes  } from '../errors/index.js';
+
+/**
+ * @typedef {Object} ModalSelectedMentionables
+ * @property {Collection<Snowflake, User>} users The selected users
+ * @property {Collection<Snowflake, GuildMember | APIGuildMember>} members The selected members
+ * @property {Collection<Snowflake, Role | APIRole>} roles The selected roles
+ */
+
+/**
+ * A resolver for modal submit components
+ */
+export class ModalComponentResolver {
+  public client: any;
+  public data: any;
+  public hoistedComponents: any;
+  constructor(client, components, resolved) {
+    /**
+     * The client that instantiated this.
+     *
+     * @name ModalComponentResolver#client
+     * @type {Client}
+     * @readonly
+     */
+    Object.defineProperty(this, 'client', { value: client });
+
+    /**
+     * The interaction resolved data
+     *
+     * @name ModalComponentResolver#resolved
+     * @type {?Readonly<BaseInteractionResolvedData>}
+     */
+    Object.defineProperty(this, 'resolved', { value: resolved ? Object.freeze(resolved) : null });
+
+    /**
+     * The components within the modal
+     *
+     * @type {Array<ActionRowModalData|LabelModalData|TextDisplayModalData>}
+     */
+    this.data = components;
+
+    /**
+     * The bottom-level components of the interaction
+     *
+     * @type {Collection<string, ModalData>}
+     */
+    this.hoistedComponents = components.reduce((accumulator, next) => {
+      // For legacy support of action rows
+      if ('components' in next) {
+        for (const component of next.components) accumulator.set(component.customId, component);
+      }
+
+      // For label components
+      if ('component' in next) {
+        accumulator.set(next.component.customId, next.component);
+      }
+
+      return accumulator;
+    }, new Collection());
+  }
+
+  /**
+   * Gets a component by custom id.
+   *
+   * @property {string} customId The custom id of the component.
+   * @returns {ModalData}
+   */
+  getComponent(customId) {
+    const component = this.hoistedComponents.get(customId);
+
+    if (!component) throw new DiscordjsTypeError(ErrorCodes.ModalSubmitInteractionComponentNotFound, customId);
+
+    return component;
+  }
+
+  /**
+   * Gets a component by custom id and property and checks its type.
+   *
+   * @param {string} customId The custom id of the component.
+   * @param {ComponentType[]} allowedTypes The allowed types of the component.
+   * @param {string[]} properties The properties to check for for `required`.
+   * @param {boolean} required Whether to throw an error if the component value(s) are not found.
+   * @returns {ModalData} The option, if found.
+   * @private
+   */
+  _getTypedComponent(customId, allowedTypes, properties, required) {
+    const component = this.getComponent(customId);
+    if (!allowedTypes.includes(component.type)) {
+      throw new DiscordjsTypeError(
+        ErrorCodes.ModalSubmitInteractionComponentType,
+        customId,
+        component.type,
+        allowedTypes.join(', '),
+      );
+    } else if (required && properties.every(prop => component[prop] === null || component[prop] === undefined)) {
+      throw new DiscordjsTypeError(ErrorCodes.ModalSubmitInteractionComponentEmpty, customId, component.type);
+    }
+
+    return component;
+  }
+
+  /**
+   * Gets the value of a text input component
+   *
+   * @param {string} customId The custom id of the text input component
+   * @returns {string}
+   */
+  getTextInputValue(customId) {
+    return this._getTypedComponent(customId, [ComponentType.TextInput]).value;
+  }
+
+  /**
+   * Gets the values of a string select component
+   *
+   * @param {string} customId The custom id of the string select component
+   * @returns {string[]}
+   */
+  getStringSelectValues(customId) {
+    return this._getTypedComponent(customId, [ComponentType.StringSelect]).values;
+  }
+
+  /**
+   * Gets users component
+   *
+   * @param {string} customId The custom id of the component
+   * @param {boolean} [required=false] Whether to throw an error if the component value is not found or empty
+   * @returns {?Collection<Snowflake, User>} The selected users, or null if none were selected and not required
+   */
+  getSelectedUsers(customId, required = false) {
+    const component = this._getTypedComponent(
+      customId,
+      [ComponentType.UserSelect, ComponentType.MentionableSelect],
+      ['users'],
+      required,
+    );
+    return component.users ?? null;
+  }
+
+  /**
+   * Gets roles component
+   *
+   * @param {string} customId The custom id of the component
+   * @param {boolean} [required=false] Whether to throw an error if the component value is not found or empty
+   * @returns {?Collection<Snowflake, Role|APIRole>} The selected roles, or null if none were selected and not required
+   */
+  getSelectedRoles(customId, required = false) {
+    const component = this._getTypedComponent(
+      customId,
+      [ComponentType.RoleSelect, ComponentType.MentionableSelect],
+      ['roles'],
+      required,
+    );
+    return component.roles ?? null;
+  }
+
+  /**
+   * Gets channels component
+   *
+   * @param {string} customId The custom id of the component
+   * @param {boolean} [required=false] Whether to throw an error if the component value is not found or empty
+   * @param {ChannelType[]} [channelTypes=[]] The allowed types of channels. If empty, all channel types are allowed.
+   * @returns {?Collection<Snowflake, GuildChannel|ThreadChannel|APIChannel>} The selected channels, or null if none were selected and not required
+   */
+  getSelectedChannels(customId, required = false, channelTypes = []) {
+    const component = this._getTypedComponent(customId, [ComponentType.ChannelSelect], ['channels'], required);
+    const channels = component.channels;
+    if (channels && channelTypes.length > 0) {
+      for (const channel of channels.values()) {
+        if (!channelTypes.includes(channel.type)) {
+          throw new DiscordjsTypeError(
+            ErrorCodes.ModalSubmitInteractionComponentInvalidChannelType,
+            customId,
+            channel.type,
+            channelTypes.join(', '),
+          );
+        }
+      }
+    }
+
+    return channels ?? null;
+  }
+
+  /**
+   * Gets members component
+   *
+   * @param {string} customId The custom id of the component
+   * @returns {?Collection<Snowflake, GuildMember|APIGuildMember>} The selected members, or null if none were selected or the users were not present in the guild
+   */
+  getSelectedMembers(customId) {
+    const component = this._getTypedComponent(
+      customId,
+      [ComponentType.UserSelect, ComponentType.MentionableSelect],
+      ['members'],
+      false,
+    );
+    return component.members ?? null;
+  }
+
+  /**
+   * Gets mentionables component
+   *
+   * @param {string} customId The custom id of the component
+   * @param {boolean} [required=false] Whether to throw an error if the component value is not found or empty
+   * @returns {?ModalSelectedMentionables} The selected mentionables, or null if none were selected and not required
+   */
+  getSelectedMentionables(customId, required = false) {
+    const component = this._getTypedComponent(
+      customId,
+      [ComponentType.MentionableSelect],
+      ['users', 'members', 'roles'],
+      required,
+    );
+
+    if (component.users || component.members || component.roles) {
+      return {
+        users: component.users ?? new Collection(),
+        members: component.members ?? new Collection(),
+        roles: component.roles ?? new Collection(),
+      };
+    }
+
+    return null;
+  }
+
+  /**
+   * Gets file upload component
+   *
+   * @param {string} customId The custom id of the component
+   * @param {boolean} [required=false] Whether to throw an error if the component value is not found or empty
+   * @returns {?Collection<Snowflake, Attachment>} The uploaded files, or null if none were uploaded and not required
+   */
+  getUploadedFiles(customId, required = false) {
+    return this._getTypedComponent(customId, [ComponentType.FileUpload], ['attachments'], required).attachments ?? null;
+  }
+}

package/src/structures/ModalSubmitInteraction.ts

@@ -0,0 +1,260 @@
+import { Collection  } from '@ovencord/collection';
+import { lazy  } from '@ovencord/util';
+import { transformResolved  } from '../util/Util.js';
+import { BaseInteraction  } from './BaseInteraction.js';
+import { InteractionWebhook  } from './InteractionWebhook.js';
+import { ModalComponentResolver  } from './ModalComponentResolver.js';
+import { InteractionResponses  } from './interfaces/InteractionResponses.js';
+
+const getMessage = lazy(() => require('./Message.js').Message);
+const getAttachment = lazy(() => require('./Attachment.js').Attachment);
+
+/**
+ * @typedef {Object} BaseModalData
+ * @property {ComponentType} type The component type of the component
+ * @property {number} id The id of the component
+ */
+
+/**
+ * @typedef {BaseModalData} SelectMenuModalData
+ * @property {string} customId The custom id of the component
+ * @property {string[]} values The values of the component
+ * @property {Collection<Snowflake, GuildMember|APIGuildMember>} [members] The resolved members
+ * @property {Collection<Snowflake, User|APIUser>} [users] The resolved users
+ * @property {Collection<Snowflake, Role|APIRole>} [roles] The resolved roles
+ * @property {Collection<Snowflake, BaseChannel|APIChannel>} [channels] The resolved channels
+ */
+
+/**
+ * @typedef {BaseModalData} FileUploadModalData
+ * @property {string} customId The custom id of the file upload
+ * @property {Snowflake[]} values The values of the file upload
+ * @property {Collection<Snowflake, Attachment>} [attachments] The resolved attachments
+ */
+
+/**
+ * @typedef {BaseModalData} TextInputModalData
+ * @property {string} customId The custom id of the component
+ * @property {string} value The value of the component
+ */
+
+/**
+ * @typedef {BaseModalData} TextDisplayModalData
+ */
+
+/**
+ * @typedef {SelectMenuModalData|TextInputModalData|FileUploadModalData} ModalData
+ */
+
+/**
+ * @typedef {BaseModalData} LabelModalData
+ * @property {ModalData} component The component within the label
+ */
+
+/**
+ * @typedef {BaseModalData} ActionRowModalData
+ * @property {TextInputModalData[]} components The components of this action row
+ */
+
+/**
+ * Represents a modal interaction
+ *
+ * @extends {BaseInteraction}
+ * @implements {InteractionResponses}
+ */
+export class ModalSubmitInteraction extends BaseInteraction {
+  public client: any;
+  public customId: any;
+  public message: any;
+  public components: any;
+  public deferred: any;
+  public replied: any;
+  public ephemeral: any;
+  public webhook: any;
+  constructor(client, data) {
+    super(client, data);
+    /**
+     * The custom id of the modal.
+     *
+     * @type {string}
+     */
+    this.customId = data.data.custom_id;
+
+    if ('message' in data) {
+      /**
+       * The message associated with this interaction
+       *
+       * @type {?Message}
+       */
+      this.message = this.channel?.messages._add(data.message) ?? new (getMessage())(this.client, data.message);
+    } else {
+      this.message = null;
+    }
+
+    /**
+     * The components within the modal
+     *
+     * @type {ModalComponentResolver}
+     */
+    this.components = new ModalComponentResolver(
+      this.client,
+      data.data.components?.map(component => this.transformComponent(component, data.data.resolved)),
+      transformResolved({ client: this.client, guild: this.guild, channel: this.channel }, data.data.resolved),
+    );
+
+    /**
+     * Whether the reply to this interaction has been deferred
+     *
+     * @type {boolean}
+     */
+    this.deferred = false;
+
+    /**
+     * Whether this interaction has already been replied to
+     *
+     * @type {boolean}
+     */
+    this.replied = false;
+
+    /**
+     * Whether the reply to this interaction is ephemeral
+     *
+     * @type {?boolean}
+     */
+    this.ephemeral = null;
+
+    /**
+     * An associated interaction webhook, can be used to further interact with this interaction
+     *
+     * @type {InteractionWebhook}
+     */
+    this.webhook = new InteractionWebhook(this.client, this.applicationId, this.token);
+  }
+
+  /**
+   * Transforms component data to discord.js-compatible data
+   *
+   * @param {*} rawComponent The data to transform
+   * @param {APIInteractionDataResolved} resolved The resolved data for the interaction
+   * @returns {ModalData[]}
+   * @private
+   */
+  transformComponent(rawComponent, resolved) {
+    if ('components' in rawComponent) {
+      return {
+        type: rawComponent.type,
+        id: rawComponent.id,
+        components: rawComponent.components.map(component => this.transformComponent(component, resolved)),
+      };
+    }
+
+    if ('component' in rawComponent) {
+      return {
+        type: rawComponent.type,
+        id: rawComponent.id,
+        component: this.transformComponent(rawComponent.component, resolved),
+      };
+    }
+
+    const data = {
+      type: rawComponent.type,
+      id: rawComponent.id,
+    };
+
+    // Text display components do not have custom ids.
+    if ('custom_id' in rawComponent) data.customId = rawComponent.custom_id;
+
+    if ('value' in rawComponent) data.value = rawComponent.value;
+
+    if (rawComponent.values) {
+      data.values = rawComponent.values;
+      if (resolved) {
+        const { members, users, channels, roles, attachments } = resolved;
+        const valueSet = new Set(rawComponent.values);
+
+        if (users) {
+          data.users = new Collection();
+
+          for (const [id, user] of Object.entries(users)) {
+            if (valueSet.has(id)) {
+              data.users.set(id, this.client.users._add(user));
+            }
+          }
+        }
+
+        if (channels) {
+          data.channels = new Collection();
+
+          for (const [id, apiChannel] of Object.entries(channels)) {
+            if (valueSet.has(id)) {
+              data.channels.set(id, this.client.channels._add(apiChannel, this.guild) ?? apiChannel);
+            }
+          }
+        }
+
+        if (members) {
+          data.members = new Collection();
+
+          for (const [id, member] of Object.entries(members)) {
+            if (valueSet.has(id)) {
+              const user = users?.[id];
+              data.members.set(id, this.guild?.members._add({ user, ...member }) ?? member);
+            }
+          }
+        }
+
+        if (roles) {
+          data.roles = new Collection();
+
+          for (const [id, role] of Object.entries(roles)) {
+            if (valueSet.has(id)) {
+              data.roles.set(id, this.guild?.roles._add(role) ?? role);
+            }
+          }
+        }
+
+        if (attachments) {
+          data.attachments = new Collection();
+          for (const [id, attachment] of Object.entries(attachments)) {
+            if (valueSet.has(id)) {
+              data.attachments.set(id, new (getAttachment())(attachment));
+            }
+          }
+        }
+      }
+    }
+
+    return data;
+  }
+
+  /**
+   * Whether this is from a {@link MessageComponentInteraction}.
+   *
+   * @returns {boolean}
+   */
+  isFromMessage() {
+    return Boolean(this.message);
+  }
+
+  // These are here only for documentation purposes - they are implemented by InteractionResponses
+
+  deferReply() {}
+
+  reply() {}
+
+  fetchReply() {}
+
+  editReply() {}
+
+  deleteReply() {}
+
+  followUp() {}
+
+  deferUpdate() {}
+
+  update() {}
+
+  launchActivity() {}
+}
+
+InteractionResponses.applyToClass(ModalSubmitInteraction, 'showModal');

package/src/structures/OAuth2Guild.ts

@@ -0,0 +1,30 @@
+import { PermissionsBitField  } from '../util/PermissionsBitField.js';
+import { BaseGuild  } from './BaseGuild.js';
+
+/**
+ * A partial guild received when using {@link GuildManager#fetch} to fetch multiple guilds.
+ *
+ * @extends {BaseGuild}
+ */
+export class OAuth2Guild extends BaseGuild {
+  public client: any;
+  public owner: any;
+  public permissions: any;
+  constructor(client, data) {
+    super(client, data);
+
+    /**
+     * Whether the client user is the owner of the guild
+     *
+     * @type {boolean}
+     */
+    this.owner = data.owner;
+
+    /**
+     * The permissions that the client user has in this guild
+     *
+     * @type {Readonly<PermissionsBitField>}
+     */
+    this.permissions = new PermissionsBitField(BigInt(data.permissions)).freeze();
+  }
+}

package/src/structures/PartialGroupDMChannel.ts

@@ -0,0 +1,151 @@
+import { DiscordjsError, ErrorCodes  } from '../errors/index.js';
+import { PartialGroupDMMessageManager  } from '../managers/PartialGroupDMMessageManager.js';
+import { BaseChannel  } from './BaseChannel.js';
+import { TextBasedChannel  } from './interfaces/TextBasedChannel.js';
+
+/**
+ * Represents a Partial Group DM Channel on Discord.
+ *
+ * @extends {BaseChannel}
+ * @implements {TextBasedChannel}
+ */
+export class PartialGroupDMChannel extends BaseChannel {
+  public client: any;
+  public flags: any;
+  public name: any;
+  public icon: any;
+  public recipients: any;
+  public messages: any;
+  public ownerId: any;
+  public lastMessageId: any;
+  public lastPinTimestamp: any;
+  constructor(client, data) {
+    super(client, data);
+
+    // No flags are present when fetching partial group DM channels.
+    this.flags = null;
+
+    /**
+     * The name of this Group DM Channel
+     *
+     * @type {?string}
+     */
+    this.name = data.name;
+
+    /**
+     * The hash of the channel icon
+     *
+     * @type {?string}
+     */
+    this.icon = data.icon ?? null;
+
+    /**
+     * Recipient data received in a {@link PartialGroupDMChannel}.
+     *
+     * @typedef {Object} PartialRecipient
+     * @property {string} username The username of the recipient
+     */
+
+    /**
+     * The recipients of this Group DM Channel.
+     *
+     * @type {PartialRecipient[]}
+     */
+    this.recipients = data.recipients ?? [];
+
+    /**
+     * A manager of the messages belonging to this channel
+     *
+     * @type {PartialGroupDMMessageManager}
+     */
+    this.messages = new PartialGroupDMMessageManager(this);
+
+    if ('owner_id' in data) {
+      /**
+       * The user id of the owner of this Group DM Channel
+       *
+       * @type {?Snowflake}
+       */
+      this.ownerId = data.owner_id;
+    } else {
+      this.ownerId ??= null;
+    }
+
+    if ('last_message_id' in data) {
+      /**
+       * The channel's last message id, if one was sent
+       *
+       * @type {?Snowflake}
+       */
+      this.lastMessageId = data.last_message_id;
+    } else {
+      this.lastMessageId ??= null;
+    }
+
+    if ('last_pin_timestamp' in data) {
+      /**
+       * The timestamp when the last pinned message was pinned, if there was one
+       *
+       * @type {?number}
+       */
+      this.lastPinTimestamp = data.last_pin_timestamp ? Date.parse(data.last_pin_timestamp) : null;
+    } else {
+      this.lastPinTimestamp ??= null;
+    }
+  }
+
+  /**
+   * The URL to this channel's icon.
+   *
+   * @param {ImageURLOptions} [options={}] Options for the image URL
+   * @returns {?string}
+   */
+  iconURL(options = {}) {
+    return this.icon && this.client.rest.cdn.channelIcon(this.id, this.icon, options);
+  }
+
+  /**
+   * Fetches the owner of this Group DM Channel.
+   *
+   * @param {BaseFetchOptions} [options] The options for fetching the user
+   * @returns {Promise<User>}
+   */
+  async fetchOwner(options) {
+    if (!this.ownerId) {
+      throw new DiscordjsError(ErrorCodes.FetchOwnerId, 'group DM');
+    }
+
+    return this.client.users.fetch(this.ownerId, options);
+  }
+
+  async delete() {
+    throw new DiscordjsError(ErrorCodes.DeleteGroupDMChannel);
+  }
+
+  async fetch() {
+    throw new DiscordjsError(ErrorCodes.FetchGroupDMChannel);
+  }
+
+  // These are here only for documentation purposes - they are implemented by TextBasedChannel
+
+  /* eslint-disable getter-return */
+  get lastMessage() {}
+
+  get lastPinAt() {}
+
+  createMessageComponentCollector() {}
+
+  awaitMessageComponent() {}
+}
+
+TextBasedChannel.applyToClass(PartialGroupDMChannel, [
+  'bulkDelete',
+  'send',
+  'sendTyping',
+  'createMessageCollector',
+  'awaitMessages',
+  'fetchWebhooks',
+  'createWebhook',
+  'setRateLimitPerUser',
+  'setNSFW',
+]);