discord.jselfbot-v13 0.0.1-security → 2.17.2

package/src/structures/Presence.js

@@ -0,0 +1,441 @@
+'use strict';
+
+const Base = require('./Base');
+const { Emoji } = require('./Emoji');
+const { CustomStatus, SpotifyRPC, RichPresence } = require('./RichPresence');
+const ActivityFlags = require('../util/ActivityFlags');
+const { ActivityTypes } = require('../util/Constants');
+const Util = require('../util/Util');
+
+/**
+ * Activity sent in a message.
+ * @typedef {Object} MessageActivity
+ * @property {string} [partyId] Id of the party represented in activity
+ * @property {MessageActivityType} type Type of activity sent
+ */
+
+/**
+ * @external MessageActivityType
+ * @see {@link https://discord-api-types.dev/api/discord-api-types-v9/enum/MessageActivityType}
+ */
+
+/**
+ * The status of this presence:
+ * * **`online`** - user is online
+ * * **`idle`** - user is AFK
+ * * **`offline`** - user is offline or invisible
+ * * **`dnd`** - user is in Do Not Disturb
+ * @typedef {string} PresenceStatus
+ */
+
+/**
+ * The status of this presence:
+ * * **`online`** - user is online
+ * * **`idle`** - user is AFK
+ * * **`dnd`** - user is in Do Not Disturb
+ * @typedef {string} ClientPresenceStatus
+ */
+
+/**
+ * Represents a user's presence.
+ * @extends {Base}
+ */
+class Presence extends Base {
+  constructor(client, data = {}) {
+    super(client);
+
+    /**
+     * The presence's user id
+     * @type {Snowflake}
+     */
+    this.userId = data.user.id;
+
+    /**
+     * The guild this presence is in
+     * @type {?Guild}
+     */
+    this.guild = data.guild ?? null;
+
+    this._patch(data);
+  }
+
+  /**
+   * The user of this presence
+   * @type {?User}
+   * @readonly
+   */
+  get user() {
+    return this.client.users.resolve(this.userId);
+  }
+
+  /**
+   * The member of this presence
+   * @type {?GuildMember}
+   * @readonly
+   */
+  get member() {
+    return this.guild.members.resolve(this.userId);
+  }
+
+  _patch(data, fromClient) {
+    if ('status' in data) {
+      /**
+       * The status of this presence
+       * @type {PresenceStatus}
+       */
+      this.status = data.status;
+    } else {
+      this.status ??= 'offline';
+    }
+
+    if ('activities' in data) {
+      /**
+       * The activities of this presence
+       * @type {Activity[]}
+       */
+      this.activities = data.activities.map(activity => {
+        if (fromClient === true) {
+          if ([ActivityTypes.CUSTOM, 'CUSTOM'].includes(activity.type)) {
+            return new CustomStatus(activity, this);
+          } else if (activity.id == 'spotify:1') {
+            return new SpotifyRPC(this.client, activity, this);
+          } else {
+            return new RichPresence(this.client, activity, false, this);
+          }
+        } else {
+          return new Activity(this, activity);
+        }
+      });
+    } else {
+      this.activities ??= [];
+    }
+
+    if ('client_status' in data) {
+      /**
+       * The devices this presence is on
+       * @type {?Object}
+       * @property {?ClientPresenceStatus} web The current presence in the web application
+       * @property {?ClientPresenceStatus} mobile The current presence in the mobile application
+       * @property {?ClientPresenceStatus} desktop The current presence in the desktop application
+       */
+      this.clientStatus = data.client_status;
+    } else {
+      this.clientStatus ??= null;
+    }
+
+    if ('last_modified' in data) {
+      /**
+       * The timestamp this presence was last updated
+       * @type {number}
+       */
+      this.lastModified = data.last_modified;
+    }
+
+    return this;
+  }
+
+  _clone() {
+    const clone = Object.assign(Object.create(this), this);
+    clone.activities = this.activities.map(activity => activity._clone());
+    return clone;
+  }
+
+  /**
+   * Whether this presence is equal to another.
+   * @param {Presence} presence The presence to compare with
+   * @returns {boolean}
+   */
+  equals(presence) {
+    return (
+      this === presence ||
+      (presence &&
+        this.status === presence.status &&
+        this.activities.length === presence.activities.length &&
+        this.activities.every((activity, index) => activity.equals(presence.activities[index])) &&
+        this.clientStatus?.web === presence.clientStatus?.web &&
+        this.clientStatus?.mobile === presence.clientStatus?.mobile &&
+        this.clientStatus?.desktop === presence.clientStatus?.desktop)
+    );
+  }
+
+  toJSON() {
+    return Util.flatten(this);
+  }
+}
+
+/**
+ * The platform of this activity:
+ * * **`desktop`**
+ * * **`samsung`** - playing on Samsung Galaxy
+ * * **`xbox`** - playing on Xbox Live
+ * @typedef {string} ActivityPlatform
+ */
+
+/**
+ * Represents an activity that is part of a user's presence.
+ */
+class Activity {
+  constructor(presence, data) {
+    /**
+     * The presence of the Activity
+     * @type {Presence}
+     * @readonly
+     * @name Activity#presence
+     */
+    Object.defineProperty(this, 'presence', { value: presence });
+
+    /**
+     * The activity's id
+     * @type {string}
+     */
+    this.id = data.id;
+
+    /**
+     * The activity's name
+     * @type {string}
+     */
+    this.name = data.name;
+
+    /**
+     * The activity status's type
+     * @type {ActivityType}
+     */
+    this.type = typeof data.type === 'number' ? ActivityTypes[data.type] : data.type;
+
+    /**
+     * If the activity is being streamed, a link to the stream
+     * @type {?string}
+     */
+    this.url = data.url ?? null;
+
+    /**
+     * Details about the activity
+     * @type {?string}
+     */
+    this.details = data.details ?? null;
+
+    /**
+     * State of the activity
+     * @type {?string}
+     */
+    this.state = data.state ?? null;
+
+    /**
+     * The id of the application associated with this activity
+     * @type {?Snowflake}
+     */
+    this.applicationId = data.application_id ?? null;
+
+    /**
+     * Represents timestamps of an activity
+     * @typedef {Object} ActivityTimestamps
+     * @property {?Date} start When the activity started
+     * @property {?Date} end When the activity will end
+     */
+
+    /**
+     * Timestamps for the activity
+     * @type {?ActivityTimestamps}
+     */
+    this.timestamps = data.timestamps
+      ? {
+          start: data.timestamps.start ? new Date(Number(data.timestamps.start)) : null,
+          end: data.timestamps.end ? new Date(Number(data.timestamps.end)) : null,
+        }
+      : null;
+
+    /**
+     * The Spotify song's id
+     * @type {?string}
+     */
+    this.syncId = data.sync_id ?? null;
+
+    /**
+     * The platform the game is being played on
+     * @type {?ActivityPlatform}
+     */
+    this.platform = data.platform ?? null;
+
+    /**
+     * Represents a party of an activity
+     * @typedef {Object} ActivityParty
+     * @property {?string} id The party's id
+     * @property {number[]} size Size of the party as `[current, max]`
+     */
+
+    /**
+     * Party of the activity
+     * @type {?ActivityParty}
+     */
+    this.party = data.party ?? null;
+
+    /**
+     * Assets for rich presence
+     * @type {?RichPresenceAssets}
+     */
+    this.assets = data.assets ? new RichPresenceAssets(this, data.assets) : null;
+
+    /**
+     * Flags that describe the activity
+     * @type {Readonly<ActivityFlags>}
+     */
+    this.flags = new ActivityFlags(data.flags).freeze();
+
+    /**
+     * Emoji for a custom activity
+     * @type {?Emoji}
+     */
+    this.emoji = data.emoji ? new Emoji(presence.client, data.emoji) : null;
+
+    /**
+     * The game's or Spotify session's id
+     * @type {?string}
+     */
+    this.sessionId = data.session_id ?? null;
+
+    /**
+     * The labels of the buttons of this rich presence
+     * @type {string[]}
+     */
+    this.buttons = data.buttons ?? [];
+
+    /**
+     * Creation date of the activity
+     * @type {number}
+     */
+    this.createdTimestamp = data.created_at;
+  }
+
+  /**
+   * Whether this activity is equal to another activity.
+   * @param {Activity} activity The activity to compare with
+   * @returns {boolean}
+   */
+  equals(activity) {
+    return (
+      this === activity ||
+      (activity &&
+        this.name === activity.name &&
+        this.type === activity.type &&
+        this.url === activity.url &&
+        this.state === activity.state &&
+        this.details === activity.details &&
+        this.emoji?.id === activity.emoji?.id &&
+        this.emoji?.name === activity.emoji?.name)
+    );
+  }
+
+  /**
+   * The time the activity was created at
+   * @type {Date}
+   * @readonly
+   */
+  get createdAt() {
+    return new Date(this.createdTimestamp);
+  }
+
+  /**
+   * When concatenated with a string, this automatically returns the activities' name instead of the Activity object.
+   * @returns {string}
+   */
+  toString() {
+    return this.name;
+  }
+
+  _clone() {
+    return Object.assign(Object.create(this), this);
+  }
+}
+
+/**
+ * Assets for a rich presence
+ */
+class RichPresenceAssets {
+  constructor(activity, assets) {
+    /**
+     * The activity of the RichPresenceAssets
+     * @type {Activity}
+     * @readonly
+     * @name RichPresenceAssets#activity
+     */
+    Object.defineProperty(this, 'activity', { value: activity });
+
+    /**
+     * Hover text for the large image
+     * @type {?string}
+     */
+    this.largeText = assets.large_text ?? null;
+
+    /**
+     * Hover text for the small image
+     * @type {?string}
+     */
+    this.smallText = assets.small_text ?? null;
+
+    /**
+     * The large image asset's id
+     * @type {?Snowflake}
+     */
+    this.largeImage = assets.large_image ?? null;
+
+    /**
+     * The small image asset's id
+     * @type {?Snowflake}
+     */
+    this.smallImage = assets.small_image ?? null;
+  }
+
+  /**
+   * Gets the URL of the small image asset
+   * @param {StaticImageURLOptions} [options] Options for the image URL
+   * @returns {?string}
+   */
+  smallImageURL({ format, size } = {}) {
+    if (!this.smallImage) return null;
+    if (this.smallImage.includes(':')) {
+      const [platform, id] = this.smallImage.split(':');
+      switch (platform) {
+        case 'mp':
+          return `https://media.discordapp.net/${id}`;
+        default:
+          return null;
+      }
+    }
+
+    return this.activity.presence.client.rest.cdn.AppAsset(this.activity.applicationId, this.smallImage, {
+      format,
+      size,
+    });
+  }
+
+  /**
+   * Gets the URL of the large image asset
+   * @param {StaticImageURLOptions} [options] Options for the image URL
+   * @returns {?string}
+   */
+  largeImageURL({ format, size } = {}) {
+    if (!this.largeImage) return null;
+    if (this.largeImage.includes(':')) {
+      const [platform, id] = this.largeImage.split(':');
+      switch (platform) {
+        case 'mp':
+          return `https://media.discordapp.net/${id}`;
+        case 'spotify':
+          return `https://i.scdn.co/image/${id}`;
+        case 'twitch':
+          return `https://static-cdn.jtvnw.net/previews-ttv/live_user_${id}.png`;
+        default:
+          return null;
+      }
+    }
+
+    return this.activity.presence.client.rest.cdn.AppAsset(this.activity.applicationId, this.largeImage, {
+      format,
+      size,
+    });
+  }
+}
+
+exports.Presence = Presence;
+exports.Activity = Activity;
+exports.RichPresenceAssets = RichPresenceAssets;

package/src/structures/ReactionCollector.js

@@ -0,0 +1,229 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const Collector = require('./interfaces/Collector');
+const { Events } = require('../util/Constants');
+
+/**
+ * @typedef {CollectorOptions} ReactionCollectorOptions
+ * @property {number} max The maximum total amount of reactions to collect
+ * @property {number} maxEmojis The maximum number of emojis to collect
+ * @property {number} maxUsers The maximum number of users to react
+ */
+
+/**
+ * Collects reactions on messages.
+ * Will automatically stop if the message ({@link Client#event:messageDelete messageDelete} or
+ * {@link Client#event:messageDeleteBulk messageDeleteBulk}),
+ * channel ({@link Client#event:channelDelete channelDelete}),
+ * thread ({@link Client#event:threadDelete threadDelete}), or
+ * guild ({@link Client#event:guildDelete guildDelete}) is deleted.
+ * @extends {Collector}
+ */
+class ReactionCollector extends Collector {
+  /**
+   * @param {Message} message The message upon which to collect reactions
+   * @param {ReactionCollectorOptions} [options={}] The options to apply to this collector
+   */
+  constructor(message, options = {}) {
+    super(message.client, options);
+
+    /**
+     * The message upon which to collect reactions
+     * @type {Message}
+     */
+    this.message = message;
+
+    /**
+     * The users that have reacted to this message
+     * @type {Collection}
+     */
+    this.users = new Collection();
+
+    /**
+     * The total number of reactions collected
+     * @type {number}
+     */
+    this.total = 0;
+
+    this.empty = this.empty.bind(this);
+    this._handleChannelDeletion = this._handleChannelDeletion.bind(this);
+    this._handleThreadDeletion = this._handleThreadDeletion.bind(this);
+    this._handleGuildDeletion = this._handleGuildDeletion.bind(this);
+    this._handleMessageDeletion = this._handleMessageDeletion.bind(this);
+
+    const bulkDeleteListener = messages => {
+      if (messages.has(this.message.id)) this.stop('messageDelete');
+    };
+
+    this.client.incrementMaxListeners();
+    this.client.on(Events.MESSAGE_REACTION_ADD, this.handleCollect);
+    this.client.on(Events.MESSAGE_REACTION_REMOVE, this.handleDispose);
+    this.client.on(Events.MESSAGE_REACTION_REMOVE_ALL, this.empty);
+    this.client.on(Events.MESSAGE_DELETE, this._handleMessageDeletion);
+    this.client.on(Events.MESSAGE_BULK_DELETE, bulkDeleteListener);
+    this.client.on(Events.CHANNEL_DELETE, this._handleChannelDeletion);
+    this.client.on(Events.THREAD_DELETE, this._handleThreadDeletion);
+    this.client.on(Events.GUILD_DELETE, this._handleGuildDeletion);
+
+    this.once('end', () => {
+      this.client.removeListener(Events.MESSAGE_REACTION_ADD, this.handleCollect);
+      this.client.removeListener(Events.MESSAGE_REACTION_REMOVE, this.handleDispose);
+      this.client.removeListener(Events.MESSAGE_REACTION_REMOVE_ALL, this.empty);
+      this.client.removeListener(Events.MESSAGE_DELETE, this._handleMessageDeletion);
+      this.client.removeListener(Events.MESSAGE_BULK_DELETE, bulkDeleteListener);
+      this.client.removeListener(Events.CHANNEL_DELETE, this._handleChannelDeletion);
+      this.client.removeListener(Events.THREAD_DELETE, this._handleThreadDeletion);
+      this.client.removeListener(Events.GUILD_DELETE, this._handleGuildDeletion);
+      this.client.decrementMaxListeners();
+    });
+
+    this.on('collect', (reaction, user) => {
+      /**
+       * Emitted whenever a reaction is newly created on a message. Will emit only when a new reaction is
+       * added to the message, as opposed to {@link Collector#collect} which will
+       * be emitted even when a reaction has already been added to the message.
+       * @event ReactionCollector#create
+       * @param {MessageReaction} reaction The reaction that was added
+       * @param {User} user The user that added the reaction
+       */
+      if (reaction.count === 1) {
+        this.emit('create', reaction, user);
+      }
+      this.total++;
+      this.users.set(user.id, user);
+    });
+
+    this.on('remove', (reaction, user) => {
+      this.total--;
+      if (!this.collected.some(r => r.users.cache.has(user.id))) this.users.delete(user.id);
+    });
+  }
+
+  /**
+   * Handles an incoming reaction for possible collection.
+   * @param {MessageReaction} reaction The reaction to possibly collect
+   * @param {User} user The user that added the reaction
+   * @returns {?(Snowflake|string)}
+   * @private
+   */
+  collect(reaction) {
+    /**
+     * Emitted whenever a reaction is collected.
+     * @event ReactionCollector#collect
+     * @param {MessageReaction} reaction The reaction that was collected
+     * @param {User} user The user that added the reaction
+     */
+    if (reaction.message.id !== this.message.id) return null;
+
+    return ReactionCollector.key(reaction);
+  }
+
+  /**
+   * Handles a reaction deletion for possible disposal.
+   * @param {MessageReaction} reaction The reaction to possibly dispose of
+   * @param {User} user The user that removed the reaction
+   * @returns {?(Snowflake|string)}
+   */
+  dispose(reaction, user) {
+    /**
+     * Emitted when the reaction had all the users removed and the `dispose` option is set to true.
+     * @event ReactionCollector#dispose
+     * @param {MessageReaction} reaction The reaction that was disposed of
+     * @param {User} user The user that removed the reaction
+     */
+    if (reaction.message.id !== this.message.id) return null;
+
+    /**
+     * Emitted when the reaction had one user removed and the `dispose` option is set to true.
+     * @event ReactionCollector#remove
+     * @param {MessageReaction} reaction The reaction that was removed
+     * @param {User} user The user that removed the reaction
+     */
+    if (this.collected.has(ReactionCollector.key(reaction)) && this.users.has(user.id)) {
+      this.emit('remove', reaction, user);
+    }
+    return reaction.count ? null : ReactionCollector.key(reaction);
+  }
+
+  /**
+   * Empties this reaction collector.
+   */
+  empty() {
+    this.total = 0;
+    this.collected.clear();
+    this.users.clear();
+    this.checkEnd();
+  }
+
+  /**
+   * The reason this collector has ended with, or null if it hasn't ended yet
+   * @type {?string}
+   * @readonly
+   */
+  get endReason() {
+    if (this.options.max && this.total >= this.options.max) return 'limit';
+    if (this.options.maxEmojis && this.collected.size >= this.options.maxEmojis) return 'emojiLimit';
+    if (this.options.maxUsers && this.users.size >= this.options.maxUsers) return 'userLimit';
+    return null;
+  }
+
+  /**
+   * Handles checking if the message has been deleted, and if so, stops the collector with the reason 'messageDelete'.
+   * @private
+   * @param {Message} message The message that was deleted
+   * @returns {void}
+   */
+  _handleMessageDeletion(message) {
+    if (message.id === this.message.id) {
+      this.stop('messageDelete');
+    }
+  }
+
+  /**
+   * Handles checking if the channel has been deleted, and if so, stops the collector with the reason 'channelDelete'.
+   * @private
+   * @param {GuildChannel} channel The channel that was deleted
+   * @returns {void}
+   */
+  _handleChannelDeletion(channel) {
+    if (channel.id === this.message.channelId || channel.threads?.cache.has(this.message.channelId)) {
+      this.stop('channelDelete');
+    }
+  }
+
+  /**
+   * Handles checking if the thread has been deleted, and if so, stops the collector with the reason 'threadDelete'.
+   * @private
+   * @param {ThreadChannel} thread The thread that was deleted
+   * @returns {void}
+   */
+  _handleThreadDeletion(thread) {
+    if (thread.id === this.message.channelId) {
+      this.stop('threadDelete');
+    }
+  }
+
+  /**
+   * Handles checking if the guild has been deleted, and if so, stops the collector with the reason 'guildDelete'.
+   * @private
+   * @param {Guild} guild The guild that was deleted
+   * @returns {void}
+   */
+  _handleGuildDeletion(guild) {
+    if (guild.id === this.message.guild?.id) {
+      this.stop('guildDelete');
+    }
+  }
+
+  /**
+   * Gets the collector key for a reaction.
+   * @param {MessageReaction} reaction The message reaction to get the key for
+   * @returns {Snowflake|string}
+   */
+  static key(reaction) {
+    return reaction.emoji.id ?? reaction.emoji.name;
+  }
+}
+
+module.exports = ReactionCollector;

package/src/structures/ReactionEmoji.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const { Emoji } = require('./Emoji');
+const Util = require('../util/Util');
+
+/**
+ * Represents a limited emoji set used for both custom and unicode emojis. Custom emojis
+ * will use this class opposed to the Emoji class when the client doesn't know enough
+ * information about them.
+ * @extends {Emoji}
+ */
+class ReactionEmoji extends Emoji {
+  constructor(reaction, emoji) {
+    super(reaction.message.client, emoji);
+    /**
+     * The message reaction this emoji refers to
+     * @type {MessageReaction}
+     */
+    this.reaction = reaction;
+  }
+
+  toJSON() {
+    return Util.flatten(this, { identifier: true });
+  }
+
+  valueOf() {
+    return this.id;
+  }
+}
+
+module.exports = ReactionEmoji;