@ovencord/discord.js 14.16.3

package/src/structures/MessagePayload.ts

@@ -0,0 +1,325 @@
+import { Buffer  } from 'node:buffer';
+import { isJSONEncodable, lazy  } from '@ovencord/util';
+import { DiscordSnowflake  } from '@sapphire/snowflake';
+import { DiscordjsError, DiscordjsRangeError, ErrorCodes  } from '../errors/index.js';
+import { resolveFile  } from '../util/DataResolver.js';
+import { MessageFlagsBitField  } from '../util/MessageFlagsBitField.js';
+import { findName, verifyString, resolvePartialEmoji  } from '../util/Util.js';
+
+// Fixes circular dependencies.
+const getWebhook = lazy(() => require('./Webhook.js').Webhook);
+const getUser = lazy(() => require('./User.js').User);
+const getGuildMember = lazy(() => require('./GuildMember.js').GuildMember);
+const getMessage = lazy(() => require('./Message.js').Message);
+const getMessageManager = lazy(() => require('../managers/MessageManager.js').MessageManager);
+
+/**
+ * Represents a message to be sent to the API.
+ */
+export class MessagePayload {
+  public target: any;
+  public options: any;
+  public body: any;
+  public files: any;
+  /**
+   * @param {MessageTarget} target The target for this message to be sent to
+   * @param {MessagePayloadOption} options The payload of this message
+   */
+  constructor(target, options) {
+    /**
+     * The target for this message to be sent to
+     *
+     * @type {MessageTarget}
+     */
+    this.target = target;
+
+    /**
+     * The payload of this message.
+     *
+     * @type {MessagePayloadOption}
+     */
+    this.options = options;
+
+    /**
+     * Body sendable to the API
+     *
+     * @type {?APIMessage}
+     */
+    this.body = null;
+
+    /**
+     * Files sendable to the API
+     *
+     * @type {?RawFile[]}
+     */
+    this.files = null;
+  }
+
+  /**
+   * Whether or not the target is a {@link Webhook}
+   *
+   * @type {boolean}
+   * @readonly
+   */
+  get isWebhook() {
+    return this.target instanceof getWebhook();
+  }
+
+  /**
+   * Whether or not the target is a {@link User}
+   *
+   * @type {boolean}
+   * @readonly
+   */
+  get isUser() {
+    return this.target instanceof getUser() || this.target instanceof getGuildMember();
+  }
+
+  /**
+   * Whether or not the target is a {@link Message}
+   *
+   * @type {boolean}
+   * @readonly
+   */
+  get isMessage() {
+    return this.target instanceof getMessage();
+  }
+
+  /**
+   * Whether or not the target is a {@link MessageManager}
+   *
+   * @type {boolean}
+   * @readonly
+   */
+  get isMessageManager() {
+    return this.target instanceof getMessageManager();
+  }
+
+  /**
+   * Makes the content of this message.
+   *
+   * @returns {?string}
+   */
+  makeContent() {
+    let content;
+    if (this.options.content === null) {
+      content = '';
+    } else if (this.options.content !== undefined) {
+      content = verifyString(this.options.content, DiscordjsRangeError, ErrorCodes.MessageContentType, true);
+    }
+
+    return content;
+  }
+
+  /**
+   * Resolves the body.
+   *
+   * @returns {MessagePayload}
+   */
+  resolveBody() {
+    if (this.body) return this;
+    const isWebhook = this.isWebhook;
+
+    const content = this.makeContent();
+    const tts = Boolean(this.options.tts);
+
+    let nonce;
+    if (this.options.nonce !== undefined) {
+      nonce = this.options.nonce;
+      if (typeof nonce === 'number' ? !Number.isInteger(nonce) : typeof nonce !== 'string') {
+        throw new DiscordjsRangeError(ErrorCodes.MessageNonceType);
+      }
+    }
+
+    let enforce_nonce = Boolean(this.options.enforceNonce);
+
+    // If `nonce` isn't provided, generate one & set `enforceNonce`
+    // Unless `enforceNonce` is explicitly set to `false`(not just falsy)
+    if (nonce === undefined) {
+      if (this.options.enforceNonce !== false && this.target.client.options.enforceNonce) {
+        nonce = DiscordSnowflake.generate().toString();
+        enforce_nonce = true;
+      } else if (enforce_nonce) {
+        throw new DiscordjsError(ErrorCodes.MessageNonceRequired);
+      }
+    }
+
+    const components = this.options.components?.map(component =>
+      isJSONEncodable(component) ? component.toJSON() : this.target.client.options.jsonTransformer(component),
+    );
+
+    let username;
+    let avatarURL;
+    let threadName;
+    let appliedTags;
+    if (isWebhook) {
+      username = this.options.username ?? this.target.name;
+      if (this.options.avatarURL) avatarURL = this.options.avatarURL;
+      if (this.options.threadName) threadName = this.options.threadName;
+      if (this.options.appliedTags) appliedTags = this.options.appliedTags;
+    }
+
+    let flags;
+    if (
+      // eslint-disable-next-line eqeqeq
+      this.options.flags != null
+    ) {
+      flags = new MessageFlagsBitField(this.options.flags).bitfield;
+    }
+
+    let allowedMentions =
+      this.options.allowedMentions === undefined
+        ? this.target.client.options.allowedMentions
+        : this.options.allowedMentions;
+
+    if (allowedMentions?.repliedUser !== undefined) {
+      allowedMentions = { ...allowedMentions, replied_user: allowedMentions.repliedUser };
+      delete allowedMentions.repliedUser;
+    }
+
+    let message_reference;
+    if (this.options.messageReference) {
+      const reference = this.options.messageReference;
+
+      if (reference.messageId) {
+        message_reference = {
+          message_id: reference.messageId,
+          channel_id: reference.channelId,
+          guild_id: reference.guildId,
+          type: reference.type,
+          fail_if_not_exists: reference.failIfNotExists ?? this.target.client.options.failIfNotExists,
+        };
+      }
+    }
+
+    const attachments = this.options.files?.map((file, index) => ({
+      id: index.toString(),
+      description: file.description,
+      title: file.title,
+      waveform: file.waveform,
+      duration_secs: file.duration,
+    }));
+
+    // Only passable during edits
+    if (Array.isArray(this.options.attachments)) {
+      attachments.push(
+        // Note how we don't check for file body encodable, since we aren't expecting file data here
+        ...this.options.attachments.map(attachment => (isJSONEncodable(attachment) ? attachment.toJSON() : attachment)),
+      );
+    }
+
+    let poll;
+    if (this.options.poll) {
+      poll = isJSONEncodable(this.options.poll)
+        ? this.options.poll.toJSON()
+        : {
+            question: {
+              text: this.options.poll.question.text,
+            },
+            answers: this.options.poll.answers.map(answer => ({
+              poll_media: { text: answer.text, emoji: resolvePartialEmoji(answer.emoji) },
+            })),
+            duration: this.options.poll.duration,
+            allow_multiselect: this.options.poll.allowMultiselect,
+            layout_type: this.options.poll.layoutType,
+          };
+    }
+
+    this.body = {
+      content,
+      tts,
+      nonce,
+      enforce_nonce,
+      embeds: this.options.embeds?.map(embed =>
+        isJSONEncodable(embed) ? embed.toJSON() : this.target.client.options.jsonTransformer(embed),
+      ),
+      components,
+      username,
+      avatar_url: avatarURL,
+      allowed_mentions:
+        this.isMessage && message_reference === undefined && this.target.author.id !== this.target.client.user.id
+          ? undefined
+          : allowedMentions,
+      flags,
+      message_reference,
+      attachments,
+      sticker_ids: this.options.stickers?.map(sticker => sticker.id ?? sticker),
+      thread_name: threadName,
+      applied_tags: appliedTags,
+      poll,
+    };
+    return this;
+  }
+
+  /**
+   * Resolves files.
+   *
+   * @returns {Promise<MessagePayload>}
+   */
+  async resolveFiles() {
+    if (this.files) return this;
+
+    this.files = await Promise.all(this.options.files?.map(file => this.constructor.resolveFile(file)) ?? []);
+    return this;
+  }
+
+  /**
+   * Resolves a single file into an object sendable to the API.
+   *
+   * @param {AttachmentPayload|BufferResolvable|Stream} fileLike Something that could be resolved to a file
+   * @returns {Promise<RawFile>}
+   */
+  static async resolveFile(fileLike) {
+    let attachment;
+    let name;
+
+    const ownAttachment =
+      typeof fileLike === 'string' || fileLike instanceof Buffer || typeof fileLike.pipe === 'function';
+    if (ownAttachment) {
+      attachment = fileLike;
+      name = findName(attachment);
+    } else {
+      attachment = fileLike.attachment;
+      name = fileLike.name ?? findName(attachment);
+    }
+
+    const { data, contentType } = await resolveFile(attachment);
+    return { data, name, contentType };
+  }
+
+  /**
+   * Creates a {@link MessagePayload} from user-level arguments.
+   *
+   * @param {MessageTarget} target Target to send to
+   * @param {string|MessagePayloadOption} options Options or content to use
+   * @param {MessagePayloadOption} [extra={}] Extra options to add onto specified options
+   * @returns {MessagePayload}
+   */
+  static create(target, options, extra = {}) {
+    return new this(
+      target,
+      typeof options !== 'object' || options === null ? { content: options, ...extra } : { ...options, ...extra },
+    );
+  }
+}
+
+
+
+/**
+ * A target for a message.
+ *
+ * @typedef {TextBasedChannels|ChannelManager|Webhook|BaseInteraction|InteractionWebhook|
+ * Message|MessageManager} MessageTarget
+ */
+
+/**
+ * A possible payload option.
+ *
+ * @typedef {MessageCreateOptions|MessageEditOptions|WebhookMessageCreateOptions|WebhookMessageEditOptions|
+ * InteractionReplyOptions|InteractionUpdateOptions} MessagePayloadOption
+ */
+
+/**
+ * @external RawFile
+ * @see {@link https://discord.js.org/docs/packages/rest/stable/RawFile:Interface}
+ */

package/src/structures/MessageReaction.ts

@@ -0,0 +1,219 @@
+import { Routes  } from 'discord-api-types/v10';
+import { ReactionUserManager  } from '../managers/ReactionUserManager.js';
+import { flatten, resolveGuildEmoji  } from '../util/Util.js';
+import { ApplicationEmoji  } from './ApplicationEmoji.js';
+import { GuildEmoji  } from './GuildEmoji.js';
+import { ReactionEmoji  } from './ReactionEmoji.js';
+
+/**
+ * Represents a reaction to a message.
+ */
+export class MessageReaction {
+  public client: any;
+  public message: any;
+  public me: any;
+  public meBurst: any;
+  public users: any;
+  public _emoji: any;
+  public burstColors: any;
+  public countDetails: any;
+  public count: any;
+  constructor(client, data, message) {
+    /**
+     * The client that instantiated this message reaction
+     *
+     * @name MessageReaction#client
+     * @type {Client}
+     * @readonly
+     */
+    Object.defineProperty(this, 'client', { value: client });
+
+    /**
+     * The message that this reaction refers to
+     *
+     * @type {Message}
+     */
+    this.message = message;
+
+    /**
+     * Whether the client has given this reaction
+     *
+     * @type {boolean}
+     */
+    this.me = data.me;
+
+    /**
+     * Whether the client has super-reacted using this emoji
+     *
+     * @type {boolean}
+     */
+    this.meBurst = Boolean(data.me_burst);
+
+    /**
+     * A manager of the users that have given this reaction
+     *
+     * @type {ReactionUserManager}
+     */
+    this.users = new ReactionUserManager(this, this.me ? [client.user] : []);
+
+    this._emoji = new ReactionEmoji(this, data.emoji);
+
+    this.burstColors = null;
+
+    this._patch(data);
+  }
+
+  _patch(data) {
+    if (data.burst_colors) {
+      /**
+       * Hexadecimal colors used for this super reaction
+       *
+       * @type {?string[]}
+       */
+      this.burstColors = data.burst_colors;
+    }
+
+    if ('count' in data) {
+      /**
+       * The number of people that have given the same reaction
+       *
+       * @type {?number}
+       */
+      this.count ??= data.count;
+    }
+
+    if ('count_details' in data) {
+      /**
+       * The reaction count details object contains information about super and normal reaction counts.
+       *
+       * @typedef {Object} ReactionCountDetailsData
+       * @property {number} burst Count of super reactions
+       * @property {number} normal Count of normal reactions
+       */
+
+      /**
+       * The reaction count details object contains information about super and normal reaction counts.
+       *
+       * @type {ReactionCountDetailsData}
+       */
+      this.countDetails = {
+        burst: data.count_details.burst,
+        normal: data.count_details.normal,
+      };
+    } else {
+      this.countDetails ??= { burst: 0, normal: 0 };
+    }
+  }
+
+  /**
+   * Makes the client user react with this reaction
+   *
+   * @returns {Promise<MessageReaction>}
+   */
+  async react() {
+    return this.message.react(this.emoji);
+  }
+
+  /**
+   * Removes all users from this reaction.
+   *
+   * @returns {Promise<MessageReaction>}
+   */
+  async remove() {
+    await this.client.rest.delete(
+      Routes.channelMessageReaction(this.message.channelId, this.message.id, this._emoji.identifier),
+    );
+    return this;
+  }
+
+  /**
+   * The emoji of this reaction. Either a {@link GuildEmoji} object for known custom emojis,
+   * {@link ApplicationEmoji} for application emojis, or a {@link ReactionEmoji} object
+   * which has fewer properties. Whatever the prototype of the emoji, it will still have
+   * `name`, `id`, `identifier` and `toString()`
+   *
+   * @type {GuildEmoji|ReactionEmoji|ApplicationEmoji}
+   * @readonly
+   */
+  get emoji() {
+    if (this._emoji instanceof GuildEmoji) return this._emoji;
+    if (this._emoji instanceof ApplicationEmoji) return this._emoji;
+    // Check to see if the emoji has become known to the client
+    if (this._emoji.id) {
+      const applicationEmojis = this.message.client.application.emojis.cache;
+      if (applicationEmojis.has(this._emoji.id)) {
+        const innerEmoji = applicationEmojis.get(this._emoji.id);
+        this._emoji = innerEmoji;
+        return innerEmoji;
+      }
+    }
+
+    const emoji = resolveGuildEmoji(this.client, this._emoji.id);
+    return emoji ?? this._emoji;
+  }
+
+  /**
+   * Whether or not this reaction is a partial
+   *
+   * @type {boolean}
+   * @readonly
+   */
+  get partial() {
+    return this.count === null;
+  }
+
+  /**
+   * Fetch this reaction.
+   *
+   * @returns {Promise<MessageReaction>}
+   */
+  async fetch() {
+    const message = await this.message.fetch();
+    const existing = message.reactions.cache.get(this.emoji.id ?? this.emoji.name);
+    // The reaction won't get set when it has been completely removed
+    this._patch(existing ?? { count: 0 });
+    return this;
+  }
+
+  toJSON() {
+    return flatten(this, { emoji: 'emojiId', message: 'messageId' });
+  }
+
+  valueOf() {
+    return this._emoji.id ?? this._emoji.name;
+  }
+
+  _add(user, burst) {
+    if (this.partial) return;
+    this.users.cache.set(user.id, user);
+    if (!this.me || user.id !== this.message.client.user.id || this.count === 0) {
+      this.count++;
+      if (burst) this.countDetails.burst++;
+      else this.countDetails.normal++;
+    }
+
+    if (user.id === this.message.client.user.id) {
+      if (burst) this.meBurst = true;
+      else this.me = true;
+    }
+  }
+
+  _remove(user, burst) {
+    if (this.partial) return;
+    this.users.cache.delete(user.id);
+    if (!this.me || user.id !== this.message.client.user.id) {
+      this.count--;
+      if (burst) this.countDetails.burst--;
+      else this.countDetails.normal--;
+    }
+
+    if (user.id === this.message.client.user.id) {
+      if (burst) this.meBurst = false;
+      else this.me = false;
+    }
+
+    if (this.count <= 0 && this.users.cache.size === 0) {
+      this.message.reactions.cache.delete(this.emoji.id ?? this.emoji.name);
+    }
+  }
+}