@ovencord/discord.js 14.16.3

package/src/structures/ClientUser.ts

@@ -0,0 +1,219 @@
+import { Routes  } from 'discord-api-types/v10';
+import { resolveImage  } from '../util/DataResolver.js';
+import { User  } from './User.js';
+
+/**
+ * Represents the logged in client's Discord user.
+ *
+ * @extends {User}
+ */
+export class ClientUser extends User {
+  public verified: any;
+  public mfaEnabled: any;
+  _patch(data) {
+    super._patch(data);
+
+    if ('verified' in data) {
+      /**
+       * Whether or not this account has been verified
+       *
+       * @type {boolean}
+       */
+      this.verified = data.verified;
+    }
+
+    if ('mfa_enabled' in data) {
+      /**
+       * If the bot's {@link ClientApplication#owner Owner} has MFA enabled on their account
+       *
+       * @type {?boolean}
+       */
+      this.mfaEnabled = typeof data.mfa_enabled === 'boolean' ? data.mfa_enabled : null;
+    } else {
+      this.mfaEnabled ??= null;
+    }
+
+    if ('token' in data) this.client.token = data.token;
+  }
+
+  /**
+   * Represents the client user's presence
+   *
+   * @type {ClientPresence}
+   * @readonly
+   */
+  get presence() {
+    return this.client.presence;
+  }
+
+  /**
+   * Data used to edit the logged in client
+   *
+   * @typedef {Object} ClientUserEditOptions
+   * @property {string} [username] The new username
+   * @property {?(BufferResolvable|Base64Resolvable)} [avatar] The new avatar
+   * @property {?(BufferResolvable|Base64Resolvable)} [banner] The new banner
+   */
+
+  /**
+   * Edits the logged in client.
+   *
+   * @param {ClientUserEditOptions} options The options to provide
+   * @returns {Promise<ClientUser>}
+   */
+  async edit({ username, avatar, banner }) {
+    const data = await this.client.rest.patch(Routes.user(), {
+      body: {
+        username,
+        avatar: avatar && (await resolveImage(avatar)),
+        banner: banner && (await resolveImage(banner)),
+      },
+    });
+
+    const { updated } = this.client.actions.UserUpdate.handle(data);
+    return updated ?? this;
+  }
+
+  /**
+   * Sets the username of the logged in client.
+   * <info>Changing usernames in Discord is heavily rate limited, with only 2 requests
+   * every hour. Use this sparingly!</info>
+   *
+   * @param {string} username The new username
+   * @returns {Promise<ClientUser>}
+   * @example
+   * // Set username
+   * client.user.setUsername('discordjs')
+   *   .then(user => console.log(`My new username is ${user.username}`))
+   *   .catch(console.error);
+   */
+  async setUsername(username) {
+    return this.edit({ username });
+  }
+
+  /**
+   * Sets the avatar of the logged in client.
+   *
+   * @param {?(BufferResolvable|Base64Resolvable)} avatar The new avatar
+   * @returns {Promise<ClientUser>}
+   * @example
+   * // Set avatar
+   * client.user.setAvatar('./avatar.png')
+   *   .then(user => console.log(`New avatar set!`))
+   *   .catch(console.error);
+   */
+  async setAvatar(avatar) {
+    return this.edit({ avatar });
+  }
+
+  /**
+   * Sets the banner of the logged in client.
+   *
+   * @param {?(BufferResolvable|Base64Resolvable)} banner The new banner
+   * @returns {Promise<ClientUser>}
+   * @example
+   * // Set banner
+   * client.user.setBanner('./banner.png')
+   *   .then(user => console.log(`New banner set!`))
+   *   .catch(console.error);
+   */
+  async setBanner(banner) {
+    return this.edit({ banner });
+  }
+
+  /**
+   * Options for setting activities
+   *
+   * @typedef {Object} ActivitiesOptions
+   * @property {string} name Name of the activity
+   * @property {string} [state] State of the activity
+   * @property {ActivityType} [type] Type of the activity
+   * @property {string} [url] Twitch / YouTube stream URL
+   */
+
+  /**
+   * Data resembling a raw Discord presence.
+   *
+   * @typedef {Object} PresenceData
+   * @property {PresenceStatusData} [status] Status of the user
+   * @property {boolean} [afk] Whether the user is AFK
+   * @property {ActivitiesOptions[]} [activities] Activity the user is playing
+   * @property {number|number[]} [shardId] Shard id(s) to have the activity set on
+   */
+
+  /**
+   * Sets the full presence of the client user.
+   *
+   * @param {PresenceData} data Data for the presence
+   * @returns {Promise<ClientPresence>}
+   * @example
+   * // Set the client user's presence
+   * client.user.setPresence({ activities: [{ name: 'with discord.js' }], status: 'idle' });
+   */
+  async setPresence(data) {
+    return this.client.presence.set(data);
+  }
+
+  /**
+   * A user's status. Must be one of:
+   * - `online`
+   * - `idle`
+   * - `invisible`
+   * - `dnd` (do not disturb)
+   *
+   * @typedef {string} PresenceStatusData
+   */
+
+  /**
+   * Sets the status of the client user.
+   *
+   * @param {PresenceStatusData} status Status to change to
+   * @param {number|number[]} [shardId] Shard id(s) to have the activity set on
+   * @returns {Promise<ClientPresence>}
+   * @example
+   * // Set the client user's status
+   * client.user.setStatus('idle');
+   */
+  async setStatus(status, shardId) {
+    return this.setPresence({ status, shardId });
+  }
+
+  /**
+   * Options for setting an activity.
+   *
+   * @typedef {Object} ActivityOptions
+   * @property {string} name Name of the activity
+   * @property {string} [state] State of the activity
+   * @property {string} [url] Twitch / YouTube stream URL
+   * @property {ActivityType} [type] Type of the activity
+   * @property {number|number[]} [shardId] Shard Id(s) to have the activity set on
+   */
+
+  /**
+   * Sets the activity the client user is playing.
+   *
+   * @param {string|ActivityOptions} name Activity being played, or options for setting the activity
+   * @param {ActivityOptions} [options] Options for setting the activity
+   * @returns {Promise<ClientPresence>}
+   * @example
+   * // Set the client user's activity
+   * client.user.setActivity('discord.js', { type: ActivityType.Watching });
+   */
+  async setActivity(name, options = {}) {
+    if (!name) return this.setPresence({ activities: [], shardId: options.shardId });
+
+    const activity = { ...options, ...(typeof name === 'object' ? name : { name }) };
+    return this.setPresence({ activities: [activity], shardId: activity.shardId });
+  }
+
+  /**
+   * Sets/removes the AFK flag for the client user.
+   *
+   * @param {boolean} [afk=true] Whether or not the user is AFK
+   * @param {number|number[]} [shardId] Shard Id(s) to have the AFK flag set on
+   * @returns {Promise<ClientPresence>}
+   */
+  async setAFK(afk = true, shardId = undefined) {
+    return this.setPresence({ afk, shardId });
+  }
+}

package/src/structures/CommandInteraction.ts

@@ -0,0 +1,193 @@
+import { Attachment  } from './Attachment.js';
+import { BaseInteraction  } from './BaseInteraction.js';
+import { InteractionWebhook  } from './InteractionWebhook.js';
+import { InteractionResponses  } from './interfaces/InteractionResponses.js';
+
+/**
+ * Represents a command interaction.
+ *
+ * @extends {BaseInteraction}
+ * @implements {InteractionResponses}
+ * @abstract
+ */
+export class CommandInteraction extends BaseInteraction {
+  public client: any;
+  public commandId: any;
+  public commandName: any;
+  public commandType: any;
+  public commandGuildId: any;
+  public deferred: any;
+  public replied: any;
+  public ephemeral: any;
+  public webhook: any;
+  constructor(client, data) {
+    super(client, data);
+
+    /**
+     * The id of the channel this interaction was sent in
+     *
+     * @type {Snowflake}
+     * @name CommandInteraction#channelId
+     */
+
+    /**
+     * The invoked application command's id
+     *
+     * @type {Snowflake}
+     */
+    this.commandId = data.data.id;
+
+    /**
+     * The invoked application command's name
+     *
+     * @type {string}
+     */
+    this.commandName = data.data.name;
+
+    /**
+     * The invoked application command's type
+     *
+     * @type {ApplicationCommandType}
+     */
+    this.commandType = data.data.type;
+
+    /**
+     * The id of the guild the invoked application command is registered to
+     *
+     * @type {?Snowflake}
+     */
+    this.commandGuildId = data.data.guild_id ?? null;
+
+    /**
+     * 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);
+  }
+
+  /**
+   * The invoked application command, if it was fetched before
+   *
+   * @type {?ApplicationCommand}
+   */
+  get command() {
+    const id = this.commandId;
+    return this.guild?.commands.cache.get(id) ?? this.client.application.commands.cache.get(id) ?? null;
+  }
+
+  /**
+   * @typedef {Object} BaseInteractionResolvedData
+   * @property {Collection<Snowflake, User>} [users] The resolved users
+   * @property {Collection<Snowflake, GuildMember|APIGuildMember>} [members] The resolved guild members
+   * @property {Collection<Snowflake, Role|APIRole>} [roles] The resolved roles
+   * @property {Collection<Snowflake, BaseChannel|APIChannel>} [channels] The resolved channels
+   * @property {Collection<Snowflake, Attachment>} [attachments] The resolved attachments
+   */
+
+  /**
+   * Represents the resolved data of a received command interaction.
+   *
+   * @typedef {BaseInteractionResolvedData} CommandInteractionResolvedData
+   * @property {Collection<Snowflake, Message|APIMessage>} [messages] The resolved messages
+   */
+
+  /**
+   * Represents an option of a received command interaction.
+   *
+   * @typedef {Object} CommandInteractionOption
+   * @property {string} name The name of the option
+   * @property {ApplicationCommandOptionType} type The type of the option
+   * @property {boolean} [autocomplete] Whether the autocomplete interaction is enabled for a
+   * {@link ApplicationCommandOptionType.String}, {@link ApplicationCommandOptionType.Integer} or
+   * {@link ApplicationCommandOptionType.Number} option
+   * @property {string|number|boolean} [value] The value of the option
+   * @property {CommandInteractionOption[]} [options] Additional options if this option is a
+   * subcommand (group)
+   * @property {User} [user] The resolved user
+   * @property {GuildMember|APIGuildMember} [member] The resolved member
+   * @property {GuildChannel|ThreadChannel|APIChannel} [channel] The resolved channel
+   * @property {Role|APIRole} [role] The resolved role
+   * @property {Attachment} [attachment] The resolved attachment
+   */
+
+  /**
+   * Transforms an option received from the API.
+   *
+   * @param {APIApplicationCommandOption} option The received option
+   * @param {APIInteractionDataResolved} resolved The resolved interaction data
+   * @returns {CommandInteractionOption}
+   * @private
+   */
+  transformOption(option, resolved) {
+    const result = {
+      name: option.name,
+      type: option.type,
+    };
+
+    if ('value' in option) result.value = option.value;
+    if ('options' in option) result.options = option.options.map(opt => this.transformOption(opt, resolved));
+
+    if (resolved) {
+      const user = resolved.users?.[option.value];
+      if (user) result.user = this.client.users._add(user);
+
+      const member = resolved.members?.[option.value];
+      if (member) result.member = this.guild?.members._add({ user, ...member }) ?? member;
+
+      const channel = resolved.channels?.[option.value];
+      if (channel) result.channel = this.client.channels._add(channel, this.guild) ?? channel;
+
+      const role = resolved.roles?.[option.value];
+      if (role) result.role = this.guild?.roles._add(role) ?? role;
+
+      const attachment = resolved.attachments?.[option.value];
+      if (attachment) result.attachment = new Attachment(attachment);
+    }
+
+    return result;
+  }
+
+  // These are here only for documentation purposes - they are implemented by InteractionResponses
+
+  deferReply() {}
+
+  reply() {}
+
+  fetchReply() {}
+
+  editReply() {}
+
+  deleteReply() {}
+
+  followUp() {}
+
+  launchActivity() {}
+
+  showModal() {}
+
+  awaitModalSubmit() {}
+}
+
+InteractionResponses.applyToClass(CommandInteraction, ['deferUpdate', 'update']);