@velliajs/discord 1.0.0

package/src/structures/ButtonComponent.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const Component = require('./Component');
+
+/**
+ * Represents a button component
+ * @extends {Component}
+ */
+class ButtonComponent extends Component {
+  /**
+   * The style of this button
+   * @type {ButtonStyle}
+   * @readonly
+   */
+  get style() {
+    return this.data.style;
+  }
+
+  /**
+   * The label of this button
+   * @type {?string}
+   * @readonly
+   */
+  get label() {
+    return this.data.label ?? null;
+  }
+
+  /**
+   * The emoji used in this button
+   * @type {?APIMessageComponentEmoji}
+   * @readonly
+   */
+  get emoji() {
+    return this.data.emoji ?? null;
+  }
+
+  /**
+   * Whether this button is disabled
+   * @type {boolean}
+   * @readonly
+   */
+  get disabled() {
+    return this.data.disabled ?? false;
+  }
+
+  /**
+   * The custom id of this button (only defined on non-link buttons)
+   * @type {?string}
+   * @readonly
+   */
+  get customId() {
+    return this.data.custom_id ?? null;
+  }
+
+  /**
+   * The URL of this button (only defined on link buttons)
+   * @type {?string}
+   * @readonly
+   */
+  get url() {
+    return this.data.url ?? null;
+  }
+}
+
+module.exports = ButtonComponent;

package/src/structures/ButtonInteraction.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const MessageComponentInteraction = require('./MessageComponentInteraction');
+
+/**
+ * Represents a button interaction.
+ * @extends {MessageComponentInteraction}
+ */
+class ButtonInteraction extends MessageComponentInteraction {}
+
+module.exports = ButtonInteraction;

package/src/structures/CategoryChannel.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const GuildChannel = require('./GuildChannel');
+const CategoryChannelChildManager = require('../managers/CategoryChannelChildManager');
+
+/**
+ * Represents a guild category channel on Discord.
+ * @extends {GuildChannel}
+ */
+class CategoryChannel extends GuildChannel {
+  /**
+   * The id of the parent of this channel.
+   * @name CategoryChannel#parentId
+   * @type {null}
+   */
+
+  /**
+   * The parent of this channel.
+   * @name CategoryChannel#parent
+   * @type {null}
+   * @readonly
+   */
+
+  /**
+   * Sets the category parent of this channel.
+   * <warn>It is not possible to set the parent of a CategoryChannel.</warn>
+   * @method setParent
+   * @memberof CategoryChannel
+   * @instance
+   * @param {?CategoryChannelResolvable} channel The channel to set as parent
+   * @param {SetParentOptions} [options={}] The options for setting the parent
+   * @returns {Promise<GuildChannel>}
+   */
+
+  /**
+   * A manager of the channels belonging to this category
+   * @type {CategoryChannelChildManager}
+   * @readonly
+   */
+  get children() {
+    return new CategoryChannelChildManager(this);
+  }
+}
+
+module.exports = CategoryChannel;

package/src/structures/ChannelSelectMenuBuilder.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const { ChannelSelectMenuBuilder: BuildersChannelSelectMenu } = require('@discordjs/builders');
+const { isJSONEncodable } = require('@discordjs/util');
+const { toSnakeCase } = require('../util/Transformers');
+
+/**
+ * Class used to build select menu components to be sent through the API
+ * @extends {BuildersChannelSelectMenu}
+ */
+class ChannelSelectMenuBuilder extends BuildersChannelSelectMenu {
+  constructor(data = {}) {
+    super(toSnakeCase(data));
+  }
+
+  /**
+   * Creates a new select menu builder from JSON data
+   * @param {ChannelSelectMenuBuilder|ChannelSelectMenuComponent|APIChannelSelectComponent} other The other data
+   * @returns {ChannelSelectMenuBuilder}
+   */
+  static from(other) {
+    return new this(isJSONEncodable(other) ? other.toJSON() : other);
+  }
+}
+
+module.exports = ChannelSelectMenuBuilder;
+
+/**
+ * @external BuildersChannelSelectMenu
+ * @see {@link https://discord.js.org/docs/packages/builders/stable/ChannelSelectMenuBuilder:Class}
+ */

package/src/structures/ChannelSelectMenuComponent.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const BaseSelectMenuComponent = require('./BaseSelectMenuComponent');
+
+/**
+ * Represents a channel select menu component
+ * @extends {BaseSelectMenuComponent}
+ */
+class ChannelSelectMenuComponent extends BaseSelectMenuComponent {
+  /**
+   * The options in this select menu
+   * @type {?(ChannelType[])}
+   * @readonly
+   */
+  get channelTypes() {
+    return this.data.channel_types ?? null;
+  }
+}
+
+module.exports = ChannelSelectMenuComponent;

package/src/structures/ChannelSelectMenuInteraction.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const MessageComponentInteraction = require('./MessageComponentInteraction');
+
+/**
+ * Represents a {@link ComponentType.ChannelSelect} select menu interaction.
+ * @extends {MessageComponentInteraction}
+ */
+class ChannelSelectMenuInteraction extends MessageComponentInteraction {
+  constructor(client, data) {
+    super(client, data);
+    const { resolved, values } = data.data;
+
+    /**
+     * An array of the selected channel ids
+     * @type {Snowflake[]}
+     */
+    this.values = values ?? [];
+
+    /**
+     * Collection of the selected channels
+     * @type {Collection<Snowflake, Channel|APIChannel>}
+     */
+    this.channels = new Collection();
+
+    for (const channel of Object.values(resolved?.channels ?? {})) {
+      this.channels.set(channel.id, this.client.channels._add(channel, this.guild) ?? channel);
+    }
+  }
+}
+
+module.exports = ChannelSelectMenuInteraction;

package/src/structures/ChatInputCommandInteraction.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const CommandInteraction = require('./CommandInteraction');
+const CommandInteractionOptionResolver = require('./CommandInteractionOptionResolver');
+
+/**
+ * Represents a command interaction.
+ * @extends {CommandInteraction}
+ */
+class ChatInputCommandInteraction extends CommandInteraction {
+  constructor(client, data) {
+    super(client, data);
+
+    /**
+     * The options passed to the command.
+     * @type {CommandInteractionOptionResolver}
+     */
+    this.options = new CommandInteractionOptionResolver(
+      this.client,
+      data.data.options?.map(option => this.transformOption(option, data.data.resolved)) ?? [],
+      this.transformResolved(data.data.resolved ?? {}),
+    );
+  }
+
+  /**
+   * Returns a string representation of the command interaction.
+   * This can then be copied by a user and executed again in a new command while keeping the option order.
+   * @returns {string}
+   */
+  toString() {
+    const properties = [
+      this.commandName,
+      this.options._group,
+      this.options._subcommand,
+      ...this.options._hoistedOptions.map(o => `${o.name}:${o.value}`),
+    ];
+    return `/${properties.filter(Boolean).join(' ')}`;
+  }
+}
+
+module.exports = ChatInputCommandInteraction;

package/src/structures/ClientApplication.js

@@ -0,0 +1,193 @@
+'use strict';
+
+const { Routes } = require('discord-api-types/v10');
+const { ApplicationRoleConnectionMetadata } = require('./ApplicationRoleConnectionMetadata');
+const Team = require('./Team');
+const Application = require('./interfaces/Application');
+const ApplicationCommandManager = require('../managers/ApplicationCommandManager');
+const ApplicationFlagsBitField = require('../util/ApplicationFlagsBitField');
+const PermissionsBitField = require('../util/PermissionsBitField');
+
+/**
+ * @typedef {Object} ClientApplicationInstallParams
+ * @property {OAuth2Scopes[]} scopes The scopes to add the application to the server with
+ * @property {Readonly<PermissionsBitField>} permissions The permissions this bot will request upon joining
+ */
+
+/**
+ * Represents a Client OAuth2 Application.
+ * @extends {Application}
+ */
+class ClientApplication extends Application {
+  constructor(client, data) {
+    super(client, data);
+
+    /**
+     * The application command manager for this application
+     * @type {ApplicationCommandManager}
+     */
+    this.commands = new ApplicationCommandManager(this.client);
+  }
+
+  _patch(data) {
+    super._patch(data);
+
+    /**
+     * The tags this application has (max of 5)
+     * @type {string[]}
+     */
+    this.tags = data.tags ?? [];
+
+    if ('install_params' in data) {
+      /**
+       * Settings for this application's default in-app authorization
+       * @type {?ClientApplicationInstallParams}
+       */
+      this.installParams = {
+        scopes: data.install_params.scopes,
+        permissions: new PermissionsBitField(data.install_params.permissions).freeze(),
+      };
+    } else {
+      this.installParams ??= null;
+    }
+
+    if ('custom_install_url' in data) {
+      /**
+       * This application's custom installation URL
+       * @type {?string}
+       */
+      this.customInstallURL = data.custom_install_url;
+    } else {
+      this.customInstallURL = null;
+    }
+
+    if ('flags' in data) {
+      /**
+       * The flags this application has
+       * @type {ApplicationFlagsBitField}
+       */
+      this.flags = new ApplicationFlagsBitField(data.flags).freeze();
+    }
+
+    if ('cover_image' in data) {
+      /**
+       * The hash of the application's cover image
+       * @type {?string}
+       */
+      this.cover = data.cover_image;
+    } else {
+      this.cover ??= null;
+    }
+
+    if ('rpc_origins' in data) {
+      /**
+       * The application's RPC origins, if enabled
+       * @type {string[]}
+       */
+      this.rpcOrigins = data.rpc_origins;
+    } else {
+      this.rpcOrigins ??= [];
+    }
+
+    if ('bot_require_code_grant' in data) {
+      /**
+       * If this application's bot requires a code grant when using the OAuth2 flow
+       * @type {?boolean}
+       */
+      this.botRequireCodeGrant = data.bot_require_code_grant;
+    } else {
+      this.botRequireCodeGrant ??= null;
+    }
+
+    if ('bot_public' in data) {
+      /**
+       * If this application's bot is public
+       * @type {?boolean}
+       */
+      this.botPublic = data.bot_public;
+    } else {
+      this.botPublic ??= null;
+    }
+
+    if ('role_connections_verification_url' in data) {
+      /**
+       * This application's role connection verification entry point URL
+       * @type {?string}
+       */
+      this.roleConnectionsVerificationURL = data.role_connections_verification_url;
+    } else {
+      this.roleConnectionsVerificationURL ??= null;
+    }
+
+    /**
+     * The owner of this OAuth application
+     * @type {?(User|Team)}
+     */
+    this.owner = data.team
+      ? new Team(this.client, data.team)
+      : data.owner
+      ? this.client.users._add(data.owner)
+      : this.owner ?? null;
+  }
+
+  /**
+   * Whether this application is partial
+   * @type {boolean}
+   * @readonly
+   */
+  get partial() {
+    return !this.name;
+  }
+
+  /**
+   * Obtains this application from Discord.
+   * @returns {Promise<ClientApplication>}
+   */
+  async fetch() {
+    const app = await this.client.rest.get(Routes.oauth2CurrentApplication());
+    this._patch(app);
+    return this;
+  }
+
+  /**
+   * Gets this application's role connection metadata records
+   * @returns {Promise<ApplicationRoleConnectionMetadata[]>}
+   */
+  async fetchRoleConnectionMetadataRecords() {
+    const metadata = await this.client.rest.get(Routes.applicationRoleConnectionMetadata(this.client.user.id));
+    return metadata.map(data => new ApplicationRoleConnectionMetadata(data));
+  }
+
+  /**
+   * Data for creating or editing an application role connection metadata.
+   * @typedef {Object} ApplicationRoleConnectionMetadataEditOptions
+   * @property {string} name The name of the metadata field
+   * @property {?Object<Locale, string>} [nameLocalizations] The name localizations for the metadata field
+   * @property {string} description The description of the metadata field
+   * @property {?Object<Locale, string>} [descriptionLocalizations] The description localizations for the metadata field
+   * @property {string} key The dictionary key of the metadata field
+   * @property {ApplicationRoleConnectionMetadataType} type The type of the metadata field
+   */
+
+  /**
+   * Updates this application's role connection metadata records
+   * @param {ApplicationRoleConnectionMetadataEditOptions[]} records The new role connection metadata records
+   * @returns {Promise<ApplicationRoleConnectionMetadata[]>}
+   */
+  async editRoleConnectionMetadataRecords(records) {
+    const newRecords = await this.client.rest.put(Routes.applicationRoleConnectionMetadata(this.client.user.id), {
+      body: records.map(record => ({
+        type: record.type,
+        key: record.key,
+        name: record.name,
+        name_localizations: record.nameLocalizations,
+        description: record.description,
+        description_localizations: record.descriptionLocalizations,
+      })),
+    });
+
+    return newRecords.map(data => new ApplicationRoleConnectionMetadata(data));
+  }
+}
+
+module.exports = ClientApplication;

package/src/structures/ClientPresence.js

@@ -0,0 +1,82 @@
+'use strict';
+
+const { GatewayOpcodes } = require('discord-api-types/v10');
+const { Presence } = require('./Presence');
+const { DiscordjsTypeError, ErrorCodes } = require('../errors');
+
+/**
+ * Represents the client's presence.
+ * @extends {Presence}
+ */
+class ClientPresence extends Presence {
+  constructor(client, data = {}) {
+    super(client, Object.assign(data, { status: data.status ?? 'online', user: { id: null } }));
+  }
+
+  /**
+   * Sets the client's presence
+   * @param {PresenceData} presence The data to set the presence to
+   * @returns {ClientPresence}
+   */
+  set(presence) {
+    const packet = this._parse(presence);
+    this._patch(packet);
+    if (presence.shardId === undefined) {
+      this.client.ws.broadcast({ op: GatewayOpcodes.PresenceUpdate, d: packet });
+    } else if (Array.isArray(presence.shardId)) {
+      for (const shardId of presence.shardId) {
+        this.client.ws.shards.get(shardId).send({ op: GatewayOpcodes.PresenceUpdate, d: packet });
+      }
+    } else {
+      this.client.ws.shards.get(presence.shardId).send({ op: GatewayOpcodes.PresenceUpdate, d: packet });
+    }
+    return this;
+  }
+
+  /**
+   * Parses presence data into a packet ready to be sent to Discord
+   * @param {PresenceData} presence The data to parse
+   * @returns {APIPresence}
+   * @private
+   */
+  _parse({ status, since, afk, activities }) {
+    const data = {
+      activities: [],
+      afk: typeof afk === 'boolean' ? afk : false,
+      since: typeof since === 'number' && !Number.isNaN(since) ? since : null,
+      status: status ?? this.status,
+    };
+    if (activities?.length) {
+      for (const [i, activity] of activities.entries()) {
+        if (typeof activity.name !== 'string') {
+          throw new DiscordjsTypeError(ErrorCodes.InvalidType, `activities[${i}].name`, 'string');
+        }
+        activity.type ??= 0;
+
+        data.activities.push({
+          type: activity.type,
+          name: activity.name,
+          url: activity.url,
+        });
+      }
+    } else if (!activities && (status || afk || since) && this.activities.length) {
+      data.activities.push(
+        ...this.activities.map(a => ({
+          name: a.name,
+          type: a.type,
+          url: a.url ?? undefined,
+        })),
+      );
+    }
+
+    return data;
+  }
+}
+
+module.exports = ClientPresence;
+
+/* eslint-disable max-len */
+/**
+ * @external APIPresence
+ * @see {@link https://discord.com/developers/docs/rich-presence/how-to#updating-presence-update-presence-payload-fields}
+ */