discord-selfbot-v13.js 0.0.1-security → 2.5.0

package/src/structures/BaseGuildVoiceChannel.js

@@ -0,0 +1,243 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const GuildChannel = require('./GuildChannel');
+const TextBasedChannel = require('./interfaces/TextBasedChannel');
+const InteractionManager = require('../managers/InteractionManager');
+const MessageManager = require('../managers/MessageManager');
+const { VideoQualityModes } = require('../util/Constants');
+const Permissions = require('../util/Permissions');
+
+/**
+ * Represents a voice-based guild channel on Discord.
+ * @extends {GuildChannel}
+ * @implements {TextBasedChannel}
+ */
+class BaseGuildVoiceChannel extends GuildChannel {
+  constructor(guild, data, client) {
+    super(guild, data, client, false);
+    /**
+     * A manager of the messages sent to this channel
+     * @type {MessageManager}
+     */
+    this.messages = new MessageManager(this);
+
+    /**
+     * If the guild considers this channel NSFW
+     * @type {boolean}
+     */
+    this.nsfw = Boolean(data.nsfw);
+
+    /**
+     * A manager of the interactions sent to this channel
+     * @type {InteractionManager}
+     */
+    this.interactions = new InteractionManager(this);
+
+    this._patch(data);
+  }
+
+  _patch(data) {
+    super._patch(data);
+
+    if ('bitrate' in data) {
+      /**
+       * The bitrate of this voice-based channel
+       * @type {number}
+       */
+      this.bitrate = data.bitrate;
+    }
+
+    if ('rtc_region' in data) {
+      /**
+       * The RTC region for this voice-based channel. This region is automatically selected if `null`.
+       * @type {?string}
+       */
+      this.rtcRegion = data.rtc_region;
+    }
+
+    if ('user_limit' in data) {
+      /**
+       * The maximum amount of users allowed in this channel.
+       * @type {number}
+       */
+      this.userLimit = data.user_limit;
+    }
+
+    if ('video_quality_mode' in data) {
+      /**
+       * The camera video quality mode of the channel.
+       * @type {?VideoQualityMode}
+       */
+      this.videoQualityMode = VideoQualityModes[data.video_quality_mode];
+    } else {
+      this.videoQualityMode ??= null;
+    }
+
+    if ('last_message_id' in data) {
+      /**
+       * The last message id sent in the channel, if one was sent
+       * @type {?Snowflake}
+       */
+      this.lastMessageId = data.last_message_id;
+    }
+
+    if ('messages' in data) {
+      for (const message of data.messages) this.messages._add(message);
+    }
+
+    if ('rate_limit_per_user' in data) {
+      /**
+       * The rate limit per user (slowmode) for this channel in seconds
+       * @type {number}
+       */
+      this.rateLimitPerUser = data.rate_limit_per_user;
+    }
+
+    if ('nsfw' in data) {
+      this.nsfw = Boolean(data.nsfw);
+    }
+  }
+
+  /**
+   * The members in this voice-based channel
+   * @type {Collection<Snowflake, GuildMember>}
+   * @readonly
+   */
+  get members() {
+    const coll = new Collection();
+    for (const state of this.guild.voiceStates.cache.values()) {
+      if (state.channelId === this.id && state.member) {
+        coll.set(state.id, state.member);
+      }
+    }
+    return coll;
+  }
+
+  /**
+   * Checks if the voice-based channel is full
+   * @type {boolean}
+   * @readonly
+   */
+  get full() {
+    return this.userLimit > 0 && this.members.size >= this.userLimit;
+  }
+
+  /**
+   * Whether the channel is joinable by the client user
+   * @type {boolean}
+   * @readonly
+   */
+  get joinable() {
+    if (!this.viewable) return false;
+    const permissions = this.permissionsFor(this.client.user);
+    if (!permissions) return false;
+
+    // This flag allows joining even if timed out
+    if (permissions.has(Permissions.FLAGS.ADMINISTRATOR, false)) return true;
+
+    return (
+      this.guild.members.me.communicationDisabledUntilTimestamp < Date.now() &&
+      permissions.has(Permissions.FLAGS.CONNECT, false)
+    );
+  }
+
+  /**
+   * Creates an invite to this guild channel.
+   * @param {CreateInviteOptions} [options={}] The options for creating the invite
+   * @returns {Promise<Invite>}
+   * @example
+   * // Create an invite to a channel
+   * channel.createInvite()
+   *   .then(invite => console.log(`Created an invite with a code of ${invite.code}`))
+   *   .catch(console.error);
+   */
+  createInvite(options) {
+    return this.guild.invites.create(this.id, options);
+  }
+
+  /**
+   * Fetches a collection of invites to this guild channel.
+   * Resolves with a collection mapping invites by their codes.
+   * @param {boolean} [cache=true] Whether or not to cache the fetched invites
+   * @returns {Promise<Collection<string, Invite>>}
+   */
+  fetchInvites(cache = true) {
+    return this.guild.invites.fetch({ channelId: this.id, cache });
+  }
+
+  /**
+   * Sets the bitrate of the channel.
+   * @param {number} bitrate The new bitrate
+   * @param {string} [reason] Reason for changing the channel's bitrate
+   * @returns {Promise<VoiceChannel>}
+   * @example
+   * // Set the bitrate of a voice channel
+   * voiceChannel.setBitrate(48_000)
+   *   .then(vc => console.log(`Set bitrate to ${vc.bitrate}bps for ${vc.name}`))
+   *   .catch(console.error);
+   */
+  setBitrate(bitrate, reason) {
+    return this.edit({ bitrate }, reason);
+  }
+
+  /**
+   * Sets the RTC region of the channel.
+   * @param {?string} rtcRegion The new region of the channel. Set to `null` to remove a specific region for the channel
+   * @param {string} [reason] The reason for modifying this region.
+   * @returns {Promise<BaseGuildVoiceChannel>}
+   * @example
+   * // Set the RTC region to sydney
+   * channel.setRTCRegion('sydney');
+   * @example
+   * // Remove a fixed region for this channel - let Discord decide automatically
+   * channel.setRTCRegion(null, 'We want to let Discord decide.');
+   */
+  setRTCRegion(rtcRegion, reason) {
+    return this.edit({ rtcRegion }, reason);
+  }
+
+  /**
+   * Sets the user limit of the channel.
+   * @param {number} userLimit The new user limit
+   * @param {string} [reason] Reason for changing the user limit
+   * @returns {Promise<VoiceChannel>}
+   * @example
+   * // Set the user limit of a voice channel
+   * voiceChannel.setUserLimit(42)
+   *   .then(vc => console.log(`Set user limit to ${vc.userLimit} for ${vc.name}`))
+   *   .catch(console.error);
+   */
+  setUserLimit(userLimit, reason) {
+    return this.edit({ userLimit }, reason);
+  }
+
+  /**
+   * Sets the camera video quality mode of the channel.
+   * @param {VideoQualityMode|number} videoQualityMode The new camera video quality mode.
+   * @param {string} [reason] Reason for changing the camera video quality mode.
+   * @returns {Promise<VoiceChannel>}
+   */
+  setVideoQualityMode(videoQualityMode, reason) {
+    return this.edit({ videoQualityMode }, reason);
+  }
+
+  // These are here only for documentation purposes - they are implemented by TextBasedChannel
+  /* eslint-disable no-empty-function */
+  get lastMessage() {}
+  send() {}
+  sendTyping() {}
+  createMessageCollector() {}
+  awaitMessages() {}
+  createMessageComponentCollector() {}
+  awaitMessageComponent() {}
+  bulkDelete() {}
+  fetchWebhooks() {}
+  createWebhook() {}
+  setRateLimitPerUser() {}
+  setNSFW() {}
+}
+
+TextBasedChannel.applyToClass(BaseGuildVoiceChannel, true, ['lastPinAt']);
+
+module.exports = BaseGuildVoiceChannel;

package/src/structures/BaseMessageComponent.js

@@ -0,0 +1,114 @@
+'use strict';
+
+const { TypeError } = require('../errors');
+const { MessageComponentTypes, Events } = require('../util/Constants');
+
+/**
+ * Represents an interactive component of a Message or Modal. It should not be necessary to construct this directly.
+ * See {@link MessageComponent}
+ */
+class BaseMessageComponent {
+  /**
+   * Options for a BaseMessageComponent
+   * @typedef {Object} BaseMessageComponentOptions
+   * @property {MessageComponentTypeResolvable} type The type of this component
+   */
+
+  /**
+   * Data that can be resolved into options for a component. This can be:
+   * * MessageActionRowOptions
+   * * MessageButtonOptions
+   * * MessageSelectMenuOptions
+   * * TextInputComponentOptions
+   * @typedef {MessageActionRowOptions|MessageButtonOptions|MessageSelectMenuOptions} MessageComponentOptions
+   */
+
+  /**
+   * Components that can be sent in a payload. These can be:
+   * * MessageActionRow
+   * * MessageButton
+   * * MessageSelectMenu
+   * * TextInputComponent
+   * @typedef {MessageActionRow|MessageButton|MessageSelectMenu} MessageComponent
+   * @see {@link https://discord.com/developers/docs/interactions/message-components#component-object-component-types}
+   */
+
+  /**
+   * Data that can be resolved to a MessageComponentType. This can be:
+   * * MessageComponentType
+   * * string
+   * * number
+   * @typedef {string|number|MessageComponentType} MessageComponentTypeResolvable
+   */
+
+  /**
+   * @param {BaseMessageComponent|BaseMessageComponentOptions} [data={}] The options for this component
+   */
+  constructor(data) {
+    /**
+     * The type of this component
+     * @type {?MessageComponentType}
+     */
+    this.type = 'type' in data ? BaseMessageComponent.resolveType(data.type) : null;
+  }
+
+  /**
+   * Constructs a component based on the type of the incoming data
+   * @param {MessageComponentOptions} data Data for a MessageComponent
+   * @param {Client|WebhookClient} [client] Client constructing this component
+   * @returns {?(MessageComponent|ModalComponent)}
+   * @private
+   */
+  static create(data, client) {
+    let component;
+    let type = data.type;
+
+    if (typeof type === 'string') type = MessageComponentTypes[type];
+
+    switch (type) {
+      case MessageComponentTypes.ACTION_ROW: {
+        const MessageActionRow = require('./MessageActionRow');
+        component = data instanceof MessageActionRow ? data : new MessageActionRow(data, client);
+        break;
+      }
+      case MessageComponentTypes.BUTTON: {
+        const MessageButton = require('./MessageButton');
+        component = data instanceof MessageButton ? data : new MessageButton(data);
+        break;
+      }
+      case MessageComponentTypes.STRING_SELECT:
+      case MessageComponentTypes.USER_SELECT:
+      case MessageComponentTypes.ROLE_SELECT:
+      case MessageComponentTypes.MENTIONABLE_SELECT:
+      case MessageComponentTypes.CHANNEL_SELECT: {
+        const MessageSelectMenu = require('./MessageSelectMenu');
+        component = data instanceof MessageSelectMenu ? data : new MessageSelectMenu(data);
+        break;
+      }
+      case MessageComponentTypes.TEXT_INPUT: {
+        const TextInputComponent = require('./TextInputComponent');
+        component = data instanceof TextInputComponent ? data : new TextInputComponent(data);
+        break;
+      }
+      default:
+        if (client) {
+          client.emit(Events.DEBUG, `[BaseMessageComponent] Received component with unknown type: ${data.type}`);
+        } else {
+          throw new TypeError('INVALID_TYPE', 'data.type', 'valid MessageComponentType');
+        }
+    }
+    return component;
+  }
+
+  /**
+   * Resolves the type of a component
+   * @param {MessageComponentTypeResolvable} type The type to resolve
+   * @returns {MessageComponentType}
+   * @private
+   */
+  static resolveType(type) {
+    return typeof type === 'string' ? type : MessageComponentTypes[type];
+  }
+}
+
+module.exports = BaseMessageComponent;

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/Call.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const Base = require('./Base');
+
+/**
+ * Represents a call
+ * @extends {Base}
+ */
+class Call extends Base {
+  constructor(client, data) {
+    super(client);
+    /**
+     * The channel ID of the call
+     * @type {Snowflake}
+     */
+    this.channelId = data.channel_id;
+
+    /**
+     * The list of user ID who is ringing
+     * @type {Collection<Snowflake, User>}
+     */
+    this.ringing = new Collection();
+
+    this._patch(data);
+  }
+  _patch(data) {
+    if ('region' in data) {
+      /**
+       * The region of the call
+       * @type {string}
+       */
+      this.region = data.region;
+    }
+    if ('ringing' in data) {
+      for (const userId of data.ringing) {
+        this.ringing.set(userId, this.client.users.cache.get(userId));
+      }
+    }
+  }
+  /**
+   * The channel of the call
+   * @type {?DMChannel|PartialGroupDMChannel}
+   */
+  get channel() {
+    return this.client.channels.cache.get(this.channelId);
+  }
+  /**
+   * Sets the voice region of the call
+   * @param {string} region Region of the call
+   * @returns {Promise<void>}
+   */
+  setVoiceRegion(region) {
+    return this.client.api.channels(this.channelId).call.patch({ data: { region } });
+  }
+}
+
+module.exports = Call;

package/src/structures/CategoryChannel.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const GuildChannel = require('./GuildChannel');
+
+/**
+ * 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
+   */
+
+  /**
+   * Channels that are a part of this category
+   * @type {Collection<Snowflake, GuildChannel>}
+   * @readonly
+   */
+  get children() {
+    return this.guild.channels.cache.filter(c => c.parentId === this.id);
+  }
+
+  /**
+   * 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>}
+   */
+
+  /**
+   * Options for creating a channel using {@link CategoryChannel#createChannel}.
+   * @typedef {Object} CategoryCreateChannelOptions
+   * @property {string} [name] The name of the new channel
+   * @property {ChannelType|number} [type='GUILD_TEXT'] The type of the new channel.
+   * @property {number} [position] Position of the new channel
+   * @property {string} [topic] The topic for the new channel
+   * @property {boolean} [nsfw] Whether the new channel is NSFW
+   * @property {number} [bitrate] Bitrate of the new channel in bits (only voice)
+   * @property {number} [userLimit] Maximum amount of users allowed in the new channel (only voice)
+   * @property {OverwriteResolvable[]|Collection<Snowflake, OverwriteResolvable>} [permissionOverwrites]
+   * Permission overwrites of the new channel
+   * @property {number} [rateLimitPerUser] The rate limit per user (slowmode) for the new channel in seconds
+   * @property {ThreadAutoArchiveDuration} [defaultAutoArchiveDuration]
+   * The default auto archive duration for all new threads in this channel
+   * @property {?string} [rtcRegion] The specific region of the new channel
+   * @property {?VideoQualityMode|number} [videoQualityMode] The camera video quality mode of the new channel
+   * @property {ChannelFlagsResolvable} [flags] The flags to set on the new channel
+   * @property {GuildForumTagData[]} [availableTags] The tags to set as available in a forum channel
+   * @property {?DefaultReactionEmoji} [defaultReactionEmoji] The emoji to set as the default reaction emoji
+   * @property {number} [defaultThreadRateLimitPerUser] The rate limit per user (slowmode) to set on forum posts
+   * @property {?SortOrderType} [defaultSortOrder] The default sort order mode to set on the new channel
+   * @property {string} [reason] Reason for creating the new channel
+   */
+
+  /**
+   * Creates a new channel within this category.
+   * <info>You cannot create a channel of type `GUILD_CATEGORY` inside a CategoryChannel.</info>
+   * @param {string} name The name of the new channel
+   * @param {CategoryCreateChannelOptions} options Options for creating the new channel
+   * @returns {Promise<GuildChannel>}
+   */
+  createChannel(name, options) {
+    return this.guild.channels.create(name, {
+      ...options,
+      parent: this.id,
+    });
+  }
+}
+
+module.exports = CategoryChannel;