djs-selfbot-v13 3.1.6 → 3.1.7

package/src/structures/MessagePayload.js

@@ -3,6 +3,7 @@
 const { Buffer } = require('node:buffer');
 const BaseMessageComponent = require('./BaseMessageComponent');
 const MessageEmbed = require('./MessageEmbed');
+const WebEmbed = require('./WebEmbed');
 const { RangeError } = require('../errors');
 const ActivityFlags = require('../util/ActivityFlags');
 const DataResolver = require('../util/DataResolver');
@@ -41,6 +42,7 @@ 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}
      */
 
     /**
@@ -50,6 +52,15 @@ 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}
@@ -122,12 +133,12 @@ class MessagePayload {
    * Resolves data.
    * @returns {MessagePayload}
    */
-  resolveData() {
+  async resolveData() {
     if (this.data) return this;
     const isInteraction = this.isInteraction;
     const isWebhook = this.isWebhook;
 
-    const content = this.makeContent();
+    let content = this.makeContent();
     const tts = Boolean(this.options.tts);
 
     let nonce;
@@ -197,6 +208,37 @@ 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 (
@@ -205,7 +247,7 @@ class MessagePayload {
       this.options.activity.type
     ) {
       const type = ActivityFlags.resolve(this.options.activity.type);
-      const sessionId = this.target.client.sessionId;
+      const sessionId = this.target.client.session_id;
       const partyId = this.options.activity.partyId;
       activity = {
         type,
@@ -306,7 +348,7 @@ module.exports = MessagePayload;
 
 /**
  * A target for a message.
- * @typedef {TextBasedChannels|User|GuildMember|Webhook|WebhookClient|Interaction|InteractionWebhook|
+ * @typedef {TextBasedChannels|DMChannel|User|GuildMember|Webhook|WebhookClient|Interaction|InteractionWebhook|
  * Message|MessageManager} MessageTarget
  */
 

package/src/structures/MessageReaction.js

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

package/src/structures/MessageSelectMenu.js

@@ -1,7 +1,16 @@
 'use strict';
 
+const { setTimeout } = require('node:timers');
 const BaseMessageComponent = require('./BaseMessageComponent');
-const { ChannelTypes, MessageComponentTypes } = require('../util/Constants');
+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 Util = require('../util/Util');
 
 /**
@@ -94,6 +103,130 @@ 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
@@ -135,6 +268,124 @@ 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;