djs-selfbot-v13 3.1.7 → 3.2.2

package/src/structures/MessagePayload.js

@@ -3,7 +3,7 @@
 const { Buffer } = require('node:buffer');
 const BaseMessageComponent = require('./BaseMessageComponent');
 const MessageEmbed = require('./MessageEmbed');
-const WebEmbed = require('./WebEmbed');
+const MessagePoll = require('./MessagePoll');
 const { RangeError } = require('../errors');
 const ActivityFlags = require('../util/ActivityFlags');
 const DataResolver = require('../util/DataResolver');
@@ -42,7 +42,6 @@ class MessagePayload {
      * @property {Buffer|string|Stream} attachment The original attachment that generated this file
      * @property {string} name The name of this file
      * @property {Buffer|Stream} file The file to be sent to the API
-     * @extends {APIAttachment}
      */
 
     /**
@@ -52,15 +51,6 @@ class MessagePayload {
     this.files = null;
   }
 
-  /**
-   * Whether or not using new API to upload files
-   * @type {boolean}
-   * @readonly
-   */
-  get usingNewAttachmentAPI() {
-    return Boolean(this.options?.usingNewAttachmentAPI);
-  }
-
   /**
    * Whether or not the target is a {@link Webhook} or a {@link WebhookClient}
    * @type {boolean}
@@ -133,12 +123,12 @@ class MessagePayload {
    * Resolves data.
    * @returns {MessagePayload}
    */
-  async resolveData() {
+  resolveData() {
     if (this.data) return this;
     const isInteraction = this.isInteraction;
     const isWebhook = this.isWebhook;
 
-    let content = this.makeContent();
+    const content = this.makeContent();
     const tts = Boolean(this.options.tts);
 
     let nonce;
@@ -208,37 +198,6 @@ class MessagePayload {
       this.options.attachments = attachments;
     }
 
-    if (this.options.embeds) {
-      if (!Array.isArray(this.options.embeds)) {
-        this.options.embeds = [this.options.embeds];
-      }
-
-      const webembeds = this.options.embeds.filter(e => e instanceof WebEmbed);
-      this.options.embeds = this.options.embeds.filter(e => !(e instanceof WebEmbed));
-
-      if (webembeds.length > 0) {
-        if (!content) content = '';
-        // Add hidden embed link
-        content += `\n${WebEmbed.hiddenEmbed} \n`;
-        if (webembeds.length > 1) {
-          console.warn('[WARN] Multiple webembeds are not supported, this will be ignored.');
-        }
-        // Const embed = webembeds[0];
-        for (const webE of webembeds) {
-          const data = await webE.toMessage();
-          content += `\n${data}`;
-        }
-      }
-      // Check content
-      if (typeof content == 'string' && content.length > 2000) {
-        console.warn('[WARN] Content is longer than 2000 characters.');
-      }
-      if (typeof content == 'string' && content.length > 4000) {
-        // Max length if user has nitro boost
-        throw new RangeError('MESSAGE_EMBED_LINK_LENGTH');
-      }
-    }
-
     // Activity
     let activity;
     if (
@@ -247,7 +206,7 @@ class MessagePayload {
       this.options.activity.type
     ) {
       const type = ActivityFlags.resolve(this.options.activity.type);
-      const sessionId = this.target.client.session_id;
+      const sessionId = this.target.client.sessionId;
       const partyId = this.options.activity.partyId;
       activity = {
         type,
@@ -272,6 +231,7 @@ class MessagePayload {
       attachments: this.options.attachments,
       sticker_ids: this.options.stickers?.map(sticker => sticker.id ?? sticker),
       thread_name: threadName,
+      poll: this.options.poll instanceof MessagePoll ? this.options.poll.toJSON() : this.options.poll,
     };
     return this;
   }
@@ -348,7 +308,7 @@ module.exports = MessagePayload;
 
 /**
  * A target for a message.
- * @typedef {TextBasedChannels|DMChannel|User|GuildMember|Webhook|WebhookClient|Interaction|InteractionWebhook|
+ * @typedef {TextBasedChannels|User|GuildMember|Webhook|WebhookClient|Interaction|InteractionWebhook|
  * Message|MessageManager} MessageTarget
  */
 

package/src/structures/MessagePoll.js

@@ -0,0 +1,238 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const { MessagePollLayoutTypes } = require('../util/Constants');
+const Util = require('../util/Util');
+
+/**
+ * Represents the poll object has a lot of levels and nested structures. It was also designed to support future extensibility, so some fields may appear to be more complex than necessary.
+ */
+class MessagePoll {
+  /**
+   * @param {Object} data Message poll to clone or raw data
+   */
+  constructor(data = {}) {
+    this._patch(data);
+  }
+
+  _patch(data = {}) {
+    if (data?.constructor?.name == 'MessagePoll') data = data.toJSON();
+    /**
+     * The poll media object is a common object that backs both the question and answers. For now, `question` only supports `text`, while `answers` can have an optional `emoji`.
+     * @see {@link https://docs.discord.sex/resources/message#poll-media-structure}
+     * @typedef {Object} MessagePollMedia
+     * @property {?string} text The text of the field (max 300 characters for question, 55 characters for answer)
+     * @property {?RawEmoji} emoji The emoji of the field
+     */
+
+    if ('question' in data) {
+      /**
+       * The question of the poll
+       * @type {?MessagePollMedia}
+       */
+      this.question = this._resolvePollMedia(data.question);
+    } else {
+      this.question ??= null;
+    }
+
+    if (data.answers?.length) {
+      /**
+       * The answers available in the poll
+       * @type {Collection<number, MessagePollMedia>}
+       */
+      this.answers = new Collection();
+
+      data.answers.forEach((obj, index) => {
+        this.answers.set(obj?.answer_id || index + 1, this._resolvePollMedia(obj.poll_media));
+      });
+    } else {
+      this.answers ??= new Collection();
+    }
+
+    if ('layout_type' in data) {
+      /**
+       * The layout type of the poll
+       * @type {?MessagePollLayoutTypes}
+       */
+      this.layoutType = MessagePollLayoutTypes[data.layout_type];
+    } else {
+      this.layoutType ??= MessagePollLayoutTypes[1]; // Default type
+    }
+
+    if ('allow_multiselect' in data) {
+      /**
+       * Whether a user can select multiple answers
+       * @type {boolean}
+       */
+      this.allowMultiSelect = !!data.allow_multiselect;
+    } else {
+      this.allowMultiSelect ??= false;
+    }
+
+    if ('expiry' in data) {
+      /**
+       * When the poll ends
+       * @type {?Date}
+       */
+      this.expiry = new Date(data.expiry);
+    } else {
+      this.expiry ??= null;
+    }
+
+    if ('duration' in data) {
+      /**
+       * Number of hours the poll should be open for (max 32 days, default 1)
+       * @type {?Number}
+       */
+      this.duration = data.duration;
+    } else {
+      this.duration ??= null;
+    }
+
+    if ('results' in data) {
+      /**
+       * Poll Results Structure
+       * @see {@link https://docs.discord.sex/resources/message#poll-results-structure}
+       * @typedef {Object} MessagePollResult
+       * @property {boolean} isFinalized Whether the votes have been precisely counted
+       * @property {Collection<number, MessagePollResultAnswerCount>} answerCounts The counts for each answer
+       */
+      /**
+       * Poll Answer Count Structure
+       * @see {@link https://docs.discord.sex/resources/message#poll-answer-count-structure}
+       * @typedef {Object} MessagePollResultAnswerCount
+       * @property {MessagePollMedia} answer answer
+       * @property {number} count The number of votes for this answer
+       * @property {boolean} selfVoted Whether the current user voted for this answer
+       */
+      /**
+       * In a nutshell, this contains the number of votes for each answer.
+       * The `results` field may be not present in certain responses where, as an implementation detail,
+       * Discord does not fetch the poll results in the backend.
+       * This should be treated as "unknown results", as opposed to "no results".
+       * You can keep using the results if you have previously received them through other means.
+       * Due to the intricacies of counting at scale, while a poll is in progress the results may not
+       * be perfectly accurate. They usually are accurate, and shouldn't deviate significantly — it's
+       * just difficult to make guarantees. To compensate for this, after a poll is finished there is
+       * a background job which performs a final, accurate tally of votes. This tally concludes once
+       * `is_finalized` is `true`. Polls that have ended will also always contain results.
+       * If `answer_counts` does not contain an entry for a particular answer, then there are no votes
+       * for that answer.
+       * @type {?MessagePollResult}
+       */
+      this.results = {
+        isFinalized: data.results.is_finalized,
+        answerCounts: new Collection(),
+      };
+      data.results.answer_counts.forEach(obj => {
+        this.results.answerCounts.set(obj.id, {
+          count: obj.count,
+          selfVoted: obj.me_voted,
+          answer: this.answers.get(obj.id),
+        });
+      });
+    } else {
+      this.results ??= null;
+    }
+  }
+
+  _resolvePollMedia(obj) {
+    return {
+      text: obj.text,
+      emoji: Util.resolvePartialEmoji(obj.emoji),
+    };
+  }
+
+  /**
+   * Convert to JSON
+   * @returns {Object}
+   */
+  toJSON() {
+    const data = {
+      question: {
+        text: this.question.text,
+        emoji: this.question.emoji,
+      },
+      expiry: this.expiry?.toISOString(),
+      allow_multiselect: this.allowMultiSelect,
+      layout_type: typeof this.layoutType == 'number' ? this.layoutType : MessagePollLayoutTypes[this.layoutType],
+      answers: Array.from(this.answers.entries()).map(([id, data]) => ({
+        answer_id: id,
+        poll_media: {
+          text: data.text,
+          emoji: data.emoji,
+        },
+      })),
+      duration: this.duration ?? 1,
+    };
+    if (this.results) {
+      data.results = {
+        is_finalized: this.results.isFinalized,
+        answer_counts: Array.from(this.results.answerCounts.entries()).map(([id, data]) => ({
+          id: id,
+          count: data.count,
+          me_voted: data.selfVoted,
+        })),
+      };
+    }
+    return data;
+  }
+
+  /**
+   * Set question
+   * @param {string} text question
+   * @returns {MessagePoll}
+   */
+  setQuestion(text) {
+    this.question = {
+      text,
+    };
+    return this;
+  }
+
+  /**
+   * Set answers
+   * @param {MessagePollMedia[]} answers answers
+   * @returns {MessagePoll}
+   */
+  setAnswers(answers) {
+    this.answers.clear();
+    answers.forEach((obj, index) => {
+      this.answers.set(index + 1, this._resolvePollMedia(obj));
+    });
+    return this;
+  }
+
+  /**
+   * Add answer
+   * @param {MessagePollMedia} answer answer
+   * @returns {MessagePoll}
+   */
+  addAnswer(answer) {
+    this.answers.set(this.answers.size + 1, answer);
+    return this;
+  }
+
+  /**
+   * Set allow multi select
+   * @param {boolean} state state
+   * @returns {MessagePoll}
+   */
+  setAllowMultiSelect(state) {
+    this.allowMultiSelect = state;
+    return this;
+  }
+
+  /**
+   * Set duration
+   * @param {number} duration duration (hours)
+   * @returns {MessagePoll}
+   */
+  setDuration(duration) {
+    // [1, 4, 8, 24, 72, 168, 336];
+    this.duration = duration;
+    return this;
+  }
+}
+
+module.exports = MessagePoll;

package/src/structures/MessageReaction.js

@@ -31,7 +31,7 @@ class MessageReaction {
     this.me = data.me || data.me_burst;
 
     /**
-     * Super reaction
+     * Is super reaction
      * @type {boolean}
      */
     this.isBurst = Boolean(data.me_burst || data.burst);

package/src/structures/MessageSelectMenu.js

@@ -1,16 +1,7 @@
 'use strict';
 
-const { setTimeout } = require('node:timers');
 const BaseMessageComponent = require('./BaseMessageComponent');
-const {
-  ChannelTypes,
-  MessageComponentTypes,
-  SelectMenuComponentTypes,
-  InteractionTypes,
-} = require('../util/Constants');
-const SnowflakeUtil = require('../util/SnowflakeUtil');
-const { lazy } = require('../util/Util');
-const Message = lazy(() => require('./Message').Message);
+const { ChannelTypes, MessageComponentTypes } = require('../util/Constants');
 const Util = require('../util/Util');
 
 /**
@@ -103,130 +94,6 @@ class MessageSelectMenu extends BaseMessageComponent {
       ) ?? [];
   }
 
-  /**
-   * Adds the channel types to the select menu
-   * @param {...ChannelType[]} channelTypes Added channel types
-   * @returns {MessageSelectMenu}
-   */
-  addChannelTypes(...channelTypes) {
-    if (!channelTypes.every(channelType => ChannelTypes[channelType])) {
-      throw new TypeError('INVALID_TYPE', 'channelTypes', 'Rest<ChannelTypes[]>');
-    }
-    this.channelTypes.push(
-      ...channelTypes.map(channelType => (typeof channelType === 'string' ? channelType : ChannelTypes[channelType])),
-    );
-    return this;
-  }
-
-  /**
-   * Sets the channel types of the select menu
-   * @param {...ChannelType[]} channelTypes An array of new channel types
-   * @returns {MessageSelectMenu}
-   */
-  setChannelTypes(...channelTypes) {
-    if (!channelTypes.every(channelType => ChannelTypes[channelType])) {
-      throw new TypeError('INVALID_TYPE', 'channelTypes', 'Rest<ChannelTypes[]>');
-    }
-    this.channelTypes = channelTypes.map(channelType =>
-      typeof channelType === 'string' ? channelType : ChannelTypes[channelType],
-    );
-    return this;
-  }
-
-  /**
-   * Sets the custom id of this select menu
-   * @param {string} customId A unique string to be sent in the interaction when clicked
-   * @returns {MessageSelectMenu}
-   */
-  setCustomId(customId) {
-    this.customId = Util.verifyString(customId, RangeError, 'SELECT_MENU_CUSTOM_ID');
-    return this;
-  }
-
-  /**
-   * Sets the interactive status of the select menu
-   * @param {boolean} [disabled=true] Whether this select menu should be disabled
-   * @returns {MessageSelectMenu}
-   */
-  setDisabled(disabled = true) {
-    this.disabled = disabled;
-    return this;
-  }
-
-  /**
-   * Sets the maximum number of selections allowed for this select menu
-   * @param {number} maxValues Number of selections to be allowed
-   * @returns {MessageSelectMenu}
-   */
-  setMaxValues(maxValues) {
-    this.maxValues = maxValues;
-    return this;
-  }
-
-  /**
-   * Sets the minimum number of selections required for this select menu
-   * <info>This will default the maxValues to the number of options, unless manually set</info>
-   * @param {number} minValues Number of selections to be required
-   * @returns {MessageSelectMenu}
-   */
-  setMinValues(minValues) {
-    this.minValues = minValues;
-    return this;
-  }
-
-  /**
-   * Sets the placeholder of this select menu
-   * @param {string} placeholder Custom placeholder text to display when nothing is selected
-   * @returns {MessageSelectMenu}
-   */
-  setPlaceholder(placeholder) {
-    this.placeholder = Util.verifyString(placeholder, RangeError, 'SELECT_MENU_PLACEHOLDER');
-    return this;
-  }
-
-  /**
-   * Sets the type of the select menu
-   * @param {SelectMenuComponentType} type Type of the select menu
-   * @returns {MessageSelectMenu}
-   */
-  setType(type) {
-    if (!SelectMenuComponentTypes[type]) throw new TypeError('INVALID_TYPE', 'type', 'SelectMenuComponentType');
-    this.type = BaseMessageComponent.resolveType(type);
-    return this;
-  }
-
-  /**
-   * Adds options to the select menu.
-   * @param {...MessageSelectOptionData|MessageSelectOptionData[]} options The options to add
-   * @returns {MessageSelectMenu}
-   */
-  addOptions(...options) {
-    this.options.push(...this.constructor.normalizeOptions(options));
-    return this;
-  }
-
-  /**
-   * Sets the options of the select menu.
-   * @param {...MessageSelectOptionData|MessageSelectOptionData[]} options The options to set
-   * @returns {MessageSelectMenu}
-   */
-  setOptions(...options) {
-    this.spliceOptions(0, this.options.length, options);
-    return this;
-  }
-
-  /**
-   * Removes, replaces, and inserts options in the select menu.
-   * @param {number} index The index to start at
-   * @param {number} deleteCount The number of options to remove
-   * @param {...MessageSelectOptionData|MessageSelectOptionData[]} [options] The replacing option objects
-   * @returns {MessageSelectMenu}
-   */
-  spliceOptions(index, deleteCount, ...options) {
-    this.options.splice(index, deleteCount, ...this.constructor.normalizeOptions(...options));
-    return this;
-  }
-
   /**
    * Transforms the select menu into a plain object
    * @returns {APIMessageSelectMenu} The raw data of this select menu
@@ -268,124 +135,6 @@ class MessageSelectMenu extends BaseMessageComponent {
   static normalizeOptions(...options) {
     return options.flat(Infinity).map(option => this.normalizeOption(option));
   }
-
-  // Add
-  /**
-   * Mesage select menu
-   * @param {Message} message The message this select menu is for
-   * @param {Array<any>} values The values of the select menu
-   * @returns {Promise<InteractionResponse>}
-   */
-  async select(message, values) {
-    if (!(message instanceof Message())) throw new Error('[UNKNOWN_MESSAGE] Please pass a valid Message');
-    if (!Array.isArray(values)) throw new TypeError('[INVALID_VALUES] Please pass an array of values');
-    if (!this.customId || this.disabled) {
-      throw new Error('[INVALID_MENU] Menu does not contain Id or has been disabled');
-    } // Disabled or null customID
-    if (values.length < this.minValues) {
-      throw new RangeError(`[SELECT_MENU_MIN_VALUES] The minimum number of values is ${this.minValues}`);
-    }
-    if (values.length > this.maxValues) {
-      throw new RangeError(`[SELECT_MENU_MAX_VALUES] The maximum number of values is ${this.maxValues}`);
-    }
-    const parseValues = value => {
-      switch (this.type) {
-        case 'SELECT_MENU':
-        case 'STRING_SELECT': {
-          if (typeof value !== 'string') throw new TypeError('[INVALID_VALUE] Please pass a string value');
-          const value_ = this.options.find(obj => obj.value === value || obj.label === value);
-          if (!value_) throw new Error('[INVALID_VALUE] Please pass a valid value');
-          return value_.value;
-        }
-        case 'USER_SELECT': {
-          const userId = this.client.users.resolveId(value);
-          if (!userId) throw new Error('[INVALID_VALUE] Please pass a valid user');
-          return userId;
-        }
-        case 'ROLE_SELECT': {
-          const roleId = this.client.roles.resolveId(value);
-          if (!roleId) throw new Error('[INVALID_VALUE] Please pass a valid role');
-          return roleId;
-        }
-        case 'MENTIONABLE_SELECT': {
-          const mentionableId = this.client.users.resolveId(value) || this.client.roles.resolveId(value);
-          if (!mentionableId) throw new Error('[INVALID_VALUE] Please pass a valid mentionable');
-          return mentionableId;
-        }
-        case 'CHANNEL_SELECT': {
-          const channel = this.client.channels.resolve(value);
-          if (!channel) throw new Error('[INVALID_VALUE] Please pass a valid channel');
-          if (!this.channelTypes.includes(channel.type)) {
-            throw new Error(
-              `[INVALID_VALUE] Please pass a valid channel type (Got: ${channel.type}, allow: ${this.channelTypes.join(
-                ', ',
-              )})`,
-            );
-          }
-          return channel.id;
-        }
-        default: {
-          throw new Error(`[INVALID_TYPE] Please pass a valid select menu type (Got ${this.type})`);
-        }
-      }
-    };
-
-    const nonce = SnowflakeUtil.generate();
-    const data = {
-      type: InteractionTypes.MESSAGE_COMPONENT,
-      guild_id: message.guild?.id ?? null,
-      channel_id: message.channel.id,
-      message_id: message.id,
-      application_id: message.applicationId ?? message.author.id,
-      session_id: message.client.session_id,
-      message_flags: message.flags.bitfield,
-      data: {
-        component_type: MessageComponentTypes[this.type],
-        custom_id: this.customId,
-        type: MessageComponentTypes[this.type],
-        values: values?.length ? values.map(parseValues) : [],
-      },
-      nonce,
-    };
-
-    await message.client.api.interactions.post({
-      data,
-    });
-    message.client._interactionCache.set(nonce, {
-      channelId: message.channelId,
-      guildId: message.guildId,
-      metadata: data,
-    });
-    return new Promise((resolve, reject) => {
-      const handler = data => {
-        timeout.refresh();
-        if (data.metadata?.nonce !== nonce) return;
-        clearTimeout(timeout);
-        message.client.removeListener('interactionResponse', handler);
-        message.client.decrementMaxListeners();
-        if (data.status) {
-          resolve(data.metadata);
-        } else {
-          reject(
-            new Error('INTERACTION_ERROR', {
-              cause: data,
-            }),
-          );
-        }
-      };
-      const timeout = setTimeout(() => {
-        message.client.removeListener('interactionResponse', handler);
-        message.client.decrementMaxListeners();
-        reject(
-          new Error('INTERACTION_TIMEOUT', {
-            cause: data,
-          }),
-        );
-      }, message.client.options.interactionTimeout).unref();
-      message.client.incrementMaxListeners();
-      message.client.on('interactionResponse', handler);
-    });
-  }
 }
 
 module.exports = MessageSelectMenu;