@ovencord/discord.js 14.16.3

package/src/structures/CommandInteractionOptionResolver.ts

@@ -0,0 +1,336 @@
+import { ApplicationCommandOptionType  } from 'discord-api-types/v10';
+import { DiscordjsTypeError, ErrorCodes  } from '../errors/index.js';
+
+/**
+ * A resolver for command interaction options.
+ */
+export class CommandInteractionOptionResolver {
+  public client: any;
+  public _group: any;
+  public _subcommand: any;
+  public _hoistedOptions: any;
+  constructor(client, options, resolved) {
+    /**
+     * The client that instantiated this.
+     *
+     * @name CommandInteractionOptionResolver#client
+     * @type {Client}
+     * @readonly
+     */
+    Object.defineProperty(this, 'client', { value: client });
+
+    /**
+     * The name of the subcommand group.
+     *
+     * @type {?string}
+     * @private
+     */
+    this._group = null;
+
+    /**
+     * The name of the subcommand.
+     *
+     * @type {?string}
+     * @private
+     */
+    this._subcommand = null;
+
+    /**
+     * The bottom-level options for the interaction.
+     * If there is a subcommand (or subcommand and group), this is the options for the subcommand.
+     *
+     * @type {CommandInteractionOption[]}
+     * @private
+     */
+    this._hoistedOptions = options;
+
+    // Hoist subcommand group if present
+    if (this._hoistedOptions[0]?.type === ApplicationCommandOptionType.SubcommandGroup) {
+      this._group = this._hoistedOptions[0].name;
+      this._hoistedOptions = this._hoistedOptions[0].options ?? [];
+    }
+
+    // Hoist subcommand if present
+    if (this._hoistedOptions[0]?.type === ApplicationCommandOptionType.Subcommand) {
+      this._subcommand = this._hoistedOptions[0].name;
+      this._hoistedOptions = this._hoistedOptions[0].options ?? [];
+    }
+
+    /**
+     * The interaction options array.
+     *
+     * @name CommandInteractionOptionResolver#data
+     * @type {ReadonlyArray<CommandInteractionOption>}
+     * @readonly
+     */
+    Object.defineProperty(this, 'data', { value: Object.freeze([...options]) });
+
+    /**
+     * The interaction resolved data
+     *
+     * @name CommandInteractionOptionResolver#resolved
+     * @type {?Readonly<CommandInteractionResolvedData>}
+     */
+    Object.defineProperty(this, 'resolved', { value: resolved ? Object.freeze(resolved) : null });
+  }
+
+  /**
+   * Gets an option by its name.
+   *
+   * @param {string} name The name of the option.
+   * @param {boolean} [required=false] Whether to throw an error if the option is not found.
+   * @returns {?CommandInteractionOption} The option, if found.
+   */
+  get(name, required = false) {
+    const option = this._hoistedOptions.find(opt => opt.name === name);
+    if (!option) {
+      if (required) {
+        throw new DiscordjsTypeError(ErrorCodes.CommandInteractionOptionNotFound, name);
+      }
+
+      return null;
+    }
+
+    return option;
+  }
+
+  /**
+   * Gets an option by name and property and checks its type.
+   *
+   * @param {string} name The name of the option.
+   * @param {ApplicationCommandOptionType[]} allowedTypes The allowed types of the option.
+   * @param {string[]} properties The properties to check for for `required`.
+   * @param {boolean} required Whether to throw an error if the option is not found.
+   * @returns {?CommandInteractionOption} The option, if found.
+   * @private
+   */
+  _getTypedOption(name, allowedTypes, properties, required) {
+    const option = this.get(name, required);
+    if (!option) {
+      return null;
+    } else if (!allowedTypes.includes(option.type)) {
+      throw new DiscordjsTypeError(ErrorCodes.CommandInteractionOptionType, name, option.type, allowedTypes.join(', '));
+    } else if (required && properties.every(prop => option[prop] === null || option[prop] === undefined)) {
+      throw new DiscordjsTypeError(ErrorCodes.CommandInteractionOptionEmpty, name, option.type);
+    }
+
+    return option;
+  }
+
+  /**
+   * Gets the selected subcommand.
+   *
+   * @param {boolean} [required=true] Whether to throw an error if there is no subcommand.
+   * @returns {?string} The name of the selected subcommand, or null if not set and not required.
+   */
+  getSubcommand(required = true) {
+    if (required && !this._subcommand) {
+      throw new DiscordjsTypeError(ErrorCodes.CommandInteractionOptionNoSubcommand);
+    }
+
+    return this._subcommand;
+  }
+
+  /**
+   * Gets the selected subcommand group.
+   *
+   * @param {boolean} [required=false] Whether to throw an error if there is no subcommand group.
+   * @returns {?string} The name of the selected subcommand group, or null if not set and not required.
+   */
+  getSubcommandGroup(required = false) {
+    if (required && !this._group) {
+      throw new DiscordjsTypeError(ErrorCodes.CommandInteractionOptionNoSubcommandGroup);
+    }
+
+    return this._group;
+  }
+
+  /**
+   * Gets a boolean option.
+   *
+   * @param {string} name The name of the option.
+   * @param {boolean} [required=false] Whether to throw an error if the option is not found.
+   * @returns {?boolean} The value of the option, or null if not set and not required.
+   */
+  getBoolean(name, required = false) {
+    const option = this._getTypedOption(name, [ApplicationCommandOptionType.Boolean], ['value'], required);
+    return option?.value ?? null;
+  }
+
+  /**
+   * Gets a channel option.
+   *
+   * @param {string} name The name of the option.
+   * @param {boolean} [required=false] Whether to throw an error if the option is not found.
+   * @param {ChannelType[]} [channelTypes=[]] The allowed types of channels. If empty, all channel types are allowed.
+   * @returns {?(GuildChannel|ThreadChannel|APIChannel)}
+   * The value of the option, or null if not set and not required.
+   */
+  getChannel(name, required = false, channelTypes = []) {
+    const option = this._getTypedOption(name, [ApplicationCommandOptionType.Channel], ['channel'], required);
+    const channel = option?.channel ?? null;
+
+    if (channel && channelTypes.length > 0 && !channelTypes.includes(channel.type)) {
+      throw new DiscordjsTypeError(
+        ErrorCodes.CommandInteractionOptionInvalidChannelType,
+        name,
+        channel.type,
+        channelTypes.join(', '),
+      );
+    }
+
+    return channel;
+  }
+
+  /**
+   * Gets a string option.
+   *
+   * @param {string} name The name of the option.
+   * @param {boolean} [required=false] Whether to throw an error if the option is not found.
+   * @returns {?string} The value of the option, or null if not set and not required.
+   */
+  getString(name, required = false) {
+    const option = this._getTypedOption(name, [ApplicationCommandOptionType.String], ['value'], required);
+    return option?.value ?? null;
+  }
+
+  /**
+   * Gets an integer option.
+   *
+   * @param {string} name The name of the option.
+   * @param {boolean} [required=false] Whether to throw an error if the option is not found.
+   * @returns {?number} The value of the option, or null if not set and not required.
+   */
+  getInteger(name, required = false) {
+    const option = this._getTypedOption(name, [ApplicationCommandOptionType.Integer], ['value'], required);
+    return option?.value ?? null;
+  }
+
+  /**
+   * Gets a number option.
+   *
+   * @param {string} name The name of the option.
+   * @param {boolean} [required=false] Whether to throw an error if the option is not found.
+   * @returns {?number} The value of the option, or null if not set and not required.
+   */
+  getNumber(name, required = false) {
+    const option = this._getTypedOption(name, [ApplicationCommandOptionType.Number], ['value'], required);
+    return option?.value ?? null;
+  }
+
+  /**
+   * Gets a user option.
+   *
+   * @param {string} name The name of the option.
+   * @param {boolean} [required=false] Whether to throw an error if the option is not found.
+   * @returns {?User} The value of the option, or null if not set and not required.
+   */
+  getUser(name, required = false) {
+    const option = this._getTypedOption(
+      name,
+      [ApplicationCommandOptionType.User, ApplicationCommandOptionType.Mentionable],
+      ['user'],
+      required,
+    );
+    return option?.user ?? null;
+  }
+
+  /**
+   * Gets a member option.
+   *
+   * @param {string} name The name of the option.
+   * @returns {?(GuildMember|APIGuildMember)}
+   * The value of the option, or null if the user is not present in the guild or the option is not set.
+   */
+  getMember(name) {
+    const option = this._getTypedOption(
+      name,
+      [ApplicationCommandOptionType.User, ApplicationCommandOptionType.Mentionable],
+      ['member'],
+      false,
+    );
+    return option?.member ?? null;
+  }
+
+  /**
+   * Gets a role option.
+   *
+   * @param {string} name The name of the option.
+   * @param {boolean} [required=false] Whether to throw an error if the option is not found.
+   * @returns {?(Role|APIRole)} The value of the option, or null if not set and not required.
+   */
+  getRole(name, required = false) {
+    const option = this._getTypedOption(
+      name,
+      [ApplicationCommandOptionType.Role, ApplicationCommandOptionType.Mentionable],
+      ['role'],
+      required,
+    );
+    return option?.role ?? null;
+  }
+
+  /**
+   * Gets an attachment option.
+   *
+   * @param {string} name The name of the option.
+   * @param {boolean} [required=false] Whether to throw an error if the option is not found.
+   * @returns {?Attachment} The value of the option, or null if not set and not required.
+   */
+  getAttachment(name, required = false) {
+    const option = this._getTypedOption(name, [ApplicationCommandOptionType.Attachment], ['attachment'], required);
+    return option?.attachment ?? null;
+  }
+
+  /**
+   * Gets a mentionable option.
+   *
+   * @param {string} name The name of the option.
+   * @param {boolean} [required=false] Whether to throw an error if the option is not found.
+   * @returns {?(User|GuildMember|APIGuildMember|Role|APIRole)}
+   * The value of the option, or null if not set and not required.
+   */
+  getMentionable(name, required = false) {
+    const option = this._getTypedOption(
+      name,
+      [ApplicationCommandOptionType.Mentionable],
+      ['user', 'member', 'role'],
+      required,
+    );
+    return option?.member ?? option?.user ?? option?.role ?? null;
+  }
+
+  /**
+   * Gets a message option.
+   *
+   * @param {string} name The name of the option.
+   * @param {boolean} [required=false] Whether to throw an error if the option is not found.
+   * @returns {?Message}
+   * The value of the option, or null if not set and not required.
+   */
+  getMessage(name, required = false) {
+    const option = this._getTypedOption(name, ['_MESSAGE'], ['message'], required);
+    return option?.message ?? null;
+  }
+
+  /**
+   * The full autocomplete option object.
+   *
+   * @typedef {Object} AutocompleteFocusedOption
+   * @property {string} name The name of the option
+   * @property {ApplicationCommandOptionType} type The type of the application command option
+   * @property {string} value The value of the option
+   * @property {boolean} focused Whether this option is currently in focus for autocomplete
+   */
+
+  /**
+   * Gets the focused option.
+   *
+   * @returns {AutocompleteFocusedOption}
+   * The whole object of the option that is focused
+   */
+  getFocused() {
+    const focusedOption = this._hoistedOptions.find(option => option.focused);
+    if (!focusedOption) throw new DiscordjsTypeError(ErrorCodes.AutocompleteInteractionOptionNoFocusedOption);
+    return focusedOption;
+  }
+}

package/src/structures/Component.ts

@@ -0,0 +1,59 @@
+import isEqual from 'fast-deep-equal';
+
+/**
+ * Represents a component
+ */
+export class Component {
+  public data: any;
+  constructor(data) {
+    /**
+     * The API data associated with this component
+     *
+     * @type {APIMessageComponent}
+     */
+    this.data = data;
+  }
+
+  /**
+   * The id of this component
+   *
+   * @type {number}
+   * @readonly
+   */
+  get id() {
+    return this.data.id;
+  }
+
+  /**
+   * The type of the component
+   *
+   * @type {ComponentType}
+   * @readonly
+   */
+  get type() {
+    return this.data.type;
+  }
+
+  /**
+   * Whether or not the given components are equal
+   *
+   * @param {Component|APIMessageComponent} other The component to compare against
+   * @returns {boolean}
+   */
+  equals(other) {
+    if (other instanceof Component) {
+      return isEqual(other.data, this.data);
+    }
+
+    return isEqual(other, this.data);
+  }
+
+  /**
+   * Returns the API-compatible JSON for this component
+   *
+   * @returns {APIMessageComponent}
+   */
+  toJSON() {
+    return { ...this.data };
+  }
+}

package/src/structures/ContainerComponent.ts

@@ -0,0 +1,63 @@
+import { createComponent  } from '../util/Components.js';
+import { Component  } from './Component.js';
+
+/**
+ * Represents a container component
+ *
+ * @extends {Component}
+ */
+export class ContainerComponent extends Component {
+  public components: any;
+  constructor({ components, ...data }) {
+    super(data);
+
+    /**
+     * The components in this container
+     *
+     * @type {Component[]}
+     * @readonly
+     */
+    this.components = components.map(component => createComponent(component));
+  }
+
+  /**
+   * The accent color of this container
+   *
+   * @type {?number}
+   * @readonly
+   */
+  get accentColor() {
+    return this.data.accent_color ?? null;
+  }
+
+  /**
+   * The hex accent color of this container
+   *
+   * @type {?string}
+   * @readonly
+   */
+  get hexAccentColor() {
+    return typeof this.data.accent_color === 'number'
+      ? `#${this.data.accent_color.toString(16).padStart(6, '0')}`
+      : (this.data.accent_color ?? null);
+  }
+
+  /**
+   * Whether this container is spoilered
+   *
+   * @type {boolean}
+   * @readonly
+   */
+  get spoiler() {
+    return this.data.spoiler ?? false;
+  }
+
+  /**
+   * Returns the API-compatible JSON for this component
+   *
+   * @returns {APIContainerComponent}
+   */
+  toJSON() {
+    return { ...this.data, components: this.components.map(component => component.toJSON()) };
+  }
+}

package/src/structures/ContextMenuCommandInteraction.ts

@@ -0,0 +1,68 @@
+import { lazy  } from '@ovencord/util';
+import { ApplicationCommandOptionType  } from 'discord-api-types/v10';
+import { transformResolved  } from '../util/Util.js';
+import { CommandInteraction  } from './CommandInteraction.js';
+import { CommandInteractionOptionResolver  } from './CommandInteractionOptionResolver.js';
+
+const getMessage = lazy(() => require('./Message.js').Message);
+
+/**
+ * Represents a context menu interaction.
+ *
+ * @extends {CommandInteraction}
+ */
+export class ContextMenuCommandInteraction extends CommandInteraction {
+  public client: any;
+  public options: any;
+  public targetId: any;
+  constructor(client, data) {
+    super(client, data);
+    /**
+     * The target of the interaction, parsed into options
+     *
+     * @type {CommandInteractionOptionResolver}
+     */
+    this.options = new CommandInteractionOptionResolver(
+      this.client,
+      this.resolveContextMenuOptions(data.data),
+      transformResolved({ client: this.client, guild: this.guild, channel: this.channel }, data.data.resolved),
+    );
+
+    /**
+     * The id of the target of this interaction
+     *
+     * @type {Snowflake}
+     */
+    this.targetId = data.data.target_id;
+  }
+
+  /**
+   * Resolves and transforms options received from the API for a context menu interaction.
+   *
+   * @param {APIApplicationCommandInteractionData} data The interaction data
+   * @returns {CommandInteractionOption[]}
+   * @private
+   */
+  resolveContextMenuOptions({ target_id, resolved }) {
+    const result = [];
+
+    if (resolved.users?.[target_id]) {
+      result.push(
+        this.transformOption({ name: 'user', type: ApplicationCommandOptionType.User, value: target_id }, resolved),
+      );
+    }
+
+    if (resolved.messages?.[target_id]) {
+      result.push({
+        name: 'message',
+        type: '_MESSAGE',
+        value: target_id,
+        message:
+          this.channel?.messages._add(resolved.messages[target_id]) ??
+          new (getMessage())(this.client, resolved.messages[target_id]),
+      });
+    }
+
+    return result;
+  }
+}

package/src/structures/DMChannel.ts

@@ -0,0 +1,148 @@
+import { userMention  } from '@ovencord/formatters';
+import { ChannelType  } from 'discord-api-types/v10';
+import { DMMessageManager  } from '../managers/DMMessageManager.js';
+import { Partials  } from '../util/Partials.js';
+import { BaseChannel  } from './BaseChannel.js';
+import { TextBasedChannel  } from './interfaces/TextBasedChannel.js';
+
+/**
+ * Represents a direct message channel between two users.
+ *
+ * @extends {BaseChannel}
+ * @implements {TextBasedChannel}
+ */
+export class DMChannel extends BaseChannel {
+  public client: any;
+  public type: any;
+  public messages: any;
+  public recipientId: any;
+  public lastMessageId: any;
+  public lastPinTimestamp: any;
+  constructor(client, data) {
+    super(client, data);
+
+    // Override the channel type so partials have a known type
+    this.type = ChannelType.DM;
+
+    /**
+     * A manager of the messages belonging to this channel
+     *
+     * @type {DMMessageManager}
+     */
+    this.messages = new DMMessageManager(this);
+  }
+
+  _patch(data) {
+    super._patch(data);
+
+    if (data.recipients) {
+      const recipient = data.recipients[0];
+
+      /**
+       * The recipient's id
+       *
+       * @type {Snowflake}
+       */
+      this.recipientId = recipient.id;
+
+      if ('username' in recipient || this.client.options.partials.includes(Partials.User)) {
+        this.client.users._add(recipient);
+      }
+    }
+
+    if ('last_message_id' in data) {
+      /**
+       * The channel's last message id, if one was sent
+       *
+       * @type {?Snowflake}
+       */
+      this.lastMessageId = data.last_message_id;
+    }
+
+    if ('last_pin_timestamp' in data) {
+      /**
+       * The timestamp when the last pinned message was pinned, if there was one
+       *
+       * @type {?number}
+       */
+      this.lastPinTimestamp = Date.parse(data.last_pin_timestamp);
+    } else {
+      this.lastPinTimestamp ??= null;
+    }
+  }
+
+  /**
+   * Whether this DMChannel is a partial
+   *
+   * @type {boolean}
+   * @readonly
+   */
+  get partial() {
+    return this.lastMessageId === undefined;
+  }
+
+  /**
+   * The recipient on the other end of the DM
+   *
+   * @type {?User}
+   * @readonly
+   */
+  get recipient() {
+    return this.client.users.resolve(this.recipientId);
+  }
+
+  /**
+   * Fetch this DMChannel.
+   *
+   * @param {boolean} [force=true] Whether to skip the cache check and request the API
+   * @returns {Promise<DMChannel>}
+   */
+  async fetch(force = true) {
+    return this.client.users.createDM(this.recipientId, { force });
+  }
+
+  /**
+   * When concatenated with a string, this automatically returns the recipient's mention instead of the
+   * DMChannel object.
+   *
+   * @returns {string}
+   * @example
+   * // Logs: Hello from <@123456789012345678>!
+   * console.log(`Hello from ${channel}!`);
+   */
+  toString() {
+    return userMention(this.recipientId);
+  }
+
+  // These are here only for documentation purposes - they are implemented by TextBasedChannel
+
+  /* eslint-disable getter-return */
+  get lastMessage() {}
+
+  get lastPinAt() {}
+
+  send() {}
+
+  sendTyping() {}
+
+  createMessageCollector() {}
+
+  awaitMessages() {}
+
+  createMessageComponentCollector() {}
+
+  awaitMessageComponent() {}
+  // Doesn't work on DM channels; bulkDelete() {}
+  // Doesn't work on DM channels; fetchWebhooks() {}
+  // Doesn't work on DM channels; createWebhook() {}
+  // Doesn't work on DM channels; setRateLimitPerUser() {}
+  // Doesn't work on DM channels; setNSFW() {}
+}
+
+TextBasedChannel.applyToClass(DMChannel, [
+  'bulkDelete',
+  'fetchWebhooks',
+  'createWebhook',
+  'setRateLimitPerUser',
+  'setNSFW',
+]);

package/src/structures/DirectoryChannel.ts

@@ -0,0 +1,40 @@
+import { BaseChannel  } from './BaseChannel.js';
+
+/**
+ * Represents a channel that displays a directory of guilds.
+ *
+ * @extends {BaseChannel}
+ */
+export class DirectoryChannel extends BaseChannel {
+  public client: any;
+  public guild: any;
+  public guildId: any;
+  public name: any;
+  constructor(guild, data, client) {
+    super(client, data);
+
+    /**
+     * The guild the channel is in
+     *
+     * @type {InviteGuild}
+     */
+    this.guild = guild;
+
+    /**
+     * The id of the guild the channel is in
+     *
+     * @type {Snowflake}
+     */
+    this.guildId = guild.id;
+  }
+
+  _patch(data) {
+    super._patch(data);
+    /**
+     * The channel's name
+     *
+     * @type {string}
+     */
+    this.name = data.name;
+  }
+}