@velliajs/discord 1.0.3 → 1.0.4

package/src/structures/MessageCollector.js

@@ -3,38 +3,18 @@
 const Collector = require('./interfaces/Collector');
 const Events = require('../util/Events');
 
-/**
- * @typedef {CollectorOptions} MessageCollectorOptions
- * @property {number} max The maximum amount of messages to collect
- * @property {number} maxProcessed The maximum amount of messages to process
- */
-
-/**
- * Collects messages on a channel.
- * Will automatically stop if the channel ({@link Client#event:channelDelete channelDelete}),
- * thread ({@link Client#event:threadDelete threadDelete}), or
- * guild ({@link Client#event:guildDelete guildDelete}) is deleted.
- * @extends {Collector}
- */
+
+
+
 class MessageCollector extends Collector {
-  /**
-   * @param {TextBasedChannels} channel The channel
-   * @param {MessageCollectorOptions} options The options to be applied to this collector
-   * @emits MessageCollector#message
-   */
+  
   constructor(channel, options = {}) {
     super(channel.client, options);
 
-    /**
-     * The channel
-     * @type {TextBasedChannels}
-     */
+    
     this.channel = channel;
 
-    /**
-     * Total number of messages that were received in the channel during message collection
-     * @type {number}
-     */
+    
     this.received = 0;
 
     const bulkDeleteListener = messages => {
@@ -64,78 +44,42 @@ class MessageCollector extends Collector {
     });
   }
 
-  /**
-   * Handles a message for possible collection.
-   * @param {Message} message The message that could be collected
-   * @returns {?Snowflake}
-   * @private
-   */
+  
   collect(message) {
-    /**
-     * Emitted whenever a message is collected.
-     * @event MessageCollector#collect
-     * @param {Message} message The message that was collected
-     */
+    
     if (message.channelId !== this.channel.id) return null;
     this.received++;
     return message.id;
   }
 
-  /**
-   * Handles a message for possible disposal.
-   * @param {Message} message The message that could be disposed of
-   * @returns {?Snowflake}
-   */
+  
   dispose(message) {
-    /**
-     * Emitted whenever a message is disposed of.
-     * @event MessageCollector#dispose
-     * @param {Message} message The message that was disposed of
-     */
+    
     return message.channelId === this.channel.id ? message.id : null;
   }
 
-  /**
-   * 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.collected.size >= this.options.max) return 'limit';
     if (this.options.maxProcessed && this.received === this.options.maxProcessed) return 'processedLimit';
     return super.endReason;
   }
 
-  /**
-   * 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.channel.id || channel.id === this.channel.parentId) {
       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.channel.id) {
       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.channel.guild?.id) {
       this.stop('guildDelete');

package/src/structures/MessageComponentInteraction.js

@@ -7,89 +7,46 @@ const InteractionResponses = require('./interfaces/InteractionResponses');
 
 const getMessage = lazy(() => require('./Message').Message);
 
-/**
- * Represents a message component interaction.
- * @extends {BaseInteraction}
- * @implements {InteractionResponses}
- */
+
 class MessageComponentInteraction extends BaseInteraction {
   constructor(client, data) {
     super(client, data);
 
-    /**
-     * The id of the channel this interaction was sent in
-     * @type {Snowflake}
-     * @name MessageComponentInteraction#channelId
-     */
+    
 
-    /**
-     * The message to which the component was attached
-     * @type {Message}
-     */
+    
     this.message = this.channel?.messages._add(data.message) ?? new (getMessage())(client, data.message);
 
-    /**
-     * The custom id of the component which was interacted with
-     * @type {string}
-     */
+    
     this.customId = data.data.custom_id;
 
-    /**
-     * The type of component which was interacted with
-     * @type {ComponentType}
-     */
+    
     this.componentType = data.data.component_type;
 
-    /**
-     * Whether the reply to this interaction has been deferred
-     * @type {boolean}
-     */
+    
     this.deferred = false;
 
-    /**
-     * Whether the reply to this interaction is ephemeral
-     * @type {?boolean}
-     */
+    
     this.ephemeral = null;
 
-    /**
-     * Whether this interaction has already been replied to
-     * @type {boolean}
-     */
+    
     this.replied = false;
 
-    /**
-     * An associated interaction webhook, can be used to further interact with this interaction
-     * @type {InteractionWebhook}
-     */
+    
     this.webhook = new InteractionWebhook(this.client, this.applicationId, this.token);
   }
 
-  /**
-   * Components that can be placed in an action row for messages.
-   * * ButtonComponent
-   * * StringSelectMenuComponent
-   * * UserSelectMenuComponent
-   * * RoleSelectMenuComponent
-   * * MentionableSelectMenuComponent
-   * * ChannelSelectMenuComponent
-   * @typedef {ButtonComponent|StringSelectMenuComponent|UserSelectMenuComponent|
-   * RoleSelectMenuComponent|MentionableSelectMenuComponent|ChannelSelectMenuComponent} MessageActionRowComponent
-   */
-
-  /**
-   * The component which was interacted with
-   * @type {MessageActionRowComponent|APIMessageActionRowComponent}
-   * @readonly
-   */
+  
+
+  
   get component() {
     return this.message.components
       .flatMap(row => row.components)
       .find(component => (component.customId ?? component.custom_id) === this.customId);
   }
 
-  // These are here only for documentation purposes - they are implemented by InteractionResponses
-  /* eslint-disable no-empty-function */
+  
+  
   deferReply() {}
   reply() {}
   fetchReply() {}

package/src/structures/MessageContextMenuCommandInteraction.js

@@ -2,16 +2,9 @@
 
 const ContextMenuCommandInteraction = require('./ContextMenuCommandInteraction');
 
-/**
- * Represents a message context menu interaction.
- * @extends {ContextMenuCommandInteraction}
- */
+
 class MessageContextMenuCommandInteraction extends ContextMenuCommandInteraction {
-  /**
-   * The message this interaction was sent from
-   * @type {Message|APIMessage}
-   * @readonly
-   */
+  
   get targetMessage() {
     return this.options.getMessage('message');
   }

package/src/structures/MessageMentions.js

@@ -4,94 +4,42 @@ const { Collection } = require('@discordjs/collection');
 const { FormattingPatterns } = require('discord-api-types/v10');
 const { flatten } = require('../util/Util');
 
-/**
- * Keeps track of mentions in a {@link Message}.
- */
+
 class MessageMentions {
-  /**
-   * A regular expression that matches `@everyone` and `@here`.
-   * The `mention` group property is present on the `exec` result of this expression.
-   * @type {RegExp}
-   * @memberof MessageMentions
-   */
+  
   static EveryonePattern = /@(?<mention>everyone|here)/;
 
-  /**
-   * A regular expression that matches user mentions like `<@81440962496172032>`.
-   * The `id` group property is present on the `exec` result of this expression.
-   * @type {RegExp}
-   * @memberof MessageMentions
-   */
+  
   static UsersPattern = FormattingPatterns.UserWithOptionalNickname;
 
-  /**
-   * A regular expression that matches role mentions like `<@&297577916114403338>`.
-   * The `id` group property is present on the `exec` result of this expression.
-   * @type {RegExp}
-   * @memberof MessageMentions
-   */
+  
   static RolesPattern = FormattingPatterns.Role;
 
-  /**
-   * A regular expression that matches channel mentions like `<#222079895583457280>`.
-   * The `id` group property is present on the `exec` result of this expression.
-   * @type {RegExp}
-   * @memberof MessageMentions
-   */
+  
   static ChannelsPattern = FormattingPatterns.Channel;
 
-  /**
-   * A global regular expression variant of {@link MessageMentions.ChannelsPattern}.
-   * @type {RegExp}
-   * @memberof MessageMentions
-   * @private
-   */
+  
   static GlobalChannelsPattern = new RegExp(this.ChannelsPattern.source, 'g');
 
-  /**
-   * A global regular expression variant of {@link MessageMentions.UsersPattern}.
-   * @type {RegExp}
-   * @memberof MessageMentions
-   * @private
-   */
+  
   static GlobalUsersPattern = new RegExp(this.UsersPattern.source, 'g');
 
   constructor(message, users, roles, everyone, crosspostedChannels, repliedUser) {
-    /**
-     * The client the message is from
-     * @type {Client}
-     * @readonly
-     */
+    
     Object.defineProperty(this, 'client', { value: message.client });
 
-    /**
-     * The guild the message is in
-     * @type {?Guild}
-     * @readonly
-     */
+    
     Object.defineProperty(this, 'guild', { value: message.guild });
 
-    /**
-     * The initial message content
-     * @type {string}
-     * @readonly
-     * @private
-     */
+    
     Object.defineProperty(this, '_content', { value: message.content });
 
-    /**
-     * Whether `@everyone` or `@here` were mentioned
-     * @type {boolean}
-     */
+    
     this.everyone = Boolean(everyone);
 
     if (users) {
       if (users instanceof Collection) {
-        /**
-         * Any users that were mentioned
-         * <info>Order as received from the API, not as they appear in the message content</info>
-         * @type {Collection<Snowflake, User>}
-         */
+        
         this.users = new Collection(users);
       } else {
         this.users = new Collection();
@@ -108,11 +56,7 @@ class MessageMentions {
     }
 
     if (roles instanceof Collection) {
-      /**
-       * Any roles that were mentioned
-       * <info>Order as received from the API, not as they appear in the message content</info>
-       * @type {Collection<Snowflake, Role>}
-       */
+      
       this.roles = new Collection(roles);
     } else if (roles) {
       this.roles = new Collection();
@@ -127,43 +71,20 @@ class MessageMentions {
       this.roles = new Collection();
     }
 
-    /**
-     * Cached members for {@link MessageMentions#members}
-     * @type {?Collection<Snowflake, GuildMember>}
-     * @private
-     */
+    
     this._members = null;
 
-    /**
-     * Cached channels for {@link MessageMentions#channels}
-     * @type {?Collection<Snowflake, BaseChannel>}
-     * @private
-     */
+    
     this._channels = null;
 
-    /**
-     * Cached users for {@link MessageMentions#parsedUsers}
-     * @type {?Collection<Snowflake, User>}
-     * @private
-     */
+    
     this._parsedUsers = null;
 
-    /**
-     * Crossposted channel data.
-     * @typedef {Object} CrosspostedChannel
-     * @property {Snowflake} channelId The mentioned channel's id
-     * @property {Snowflake} guildId The id of the guild that has the channel
-     * @property {ChannelType} type The channel's type
-     * @property {string} name The channel's name
-     */
+    
 
     if (crosspostedChannels) {
       if (crosspostedChannels instanceof Collection) {
-        /**
-         * A collection of crossposted channels
-         * <info>Order as received from the API, not as they appear in the message content</info>
-         * @type {Collection<Snowflake, CrosspostedChannel>}
-         */
+        
         this.crosspostedChannels = new Collection(crosspostedChannels);
       } else {
         this.crosspostedChannels = new Collection();
@@ -180,19 +101,11 @@ class MessageMentions {
       this.crosspostedChannels = new Collection();
     }
 
-    /**
-     * The author of the message that this message is a reply to
-     * @type {?User}
-     */
+    
     this.repliedUser = repliedUser ? this.client.users._add(repliedUser) : null;
   }
 
-  /**
-   * Any members that were mentioned (only in {@link Guild}s)
-   * <info>Order as received from the API, not as they appear in the message content</info>
-   * @type {?Collection<Snowflake, GuildMember>}
-   * @readonly
-   */
+  
   get members() {
     if (this._members) return this._members;
     if (!this.guild) return null;
@@ -204,12 +117,7 @@ class MessageMentions {
     return this._members;
   }
 
-  /**
-   * Any channels that were mentioned
-   * <info>Order as they appear first in the message content</info>
-   * @type {Collection<Snowflake, BaseChannel>}
-   * @readonly
-   */
+  
   get channels() {
     if (this._channels) return this._channels;
     this._channels = new Collection();
@@ -223,12 +131,7 @@ class MessageMentions {
     return this._channels;
   }
 
-  /**
-   * Any user mentions that were included in the message content
-   * <info>Order as they appear first in the message content</info>
-   * @type {Collection<Snowflake, User>}
-   * @readonly
-   */
+  
   get parsedUsers() {
     if (this._parsedUsers) return this._parsedUsers;
     this._parsedUsers = new Collection();
@@ -240,23 +143,9 @@ class MessageMentions {
     return this._parsedUsers;
   }
 
-  /**
-   * Options used to check for a mention.
-   * @typedef {Object} MessageMentionsHasOptions
-   * @property {boolean} [ignoreDirect=false] Whether to ignore direct mentions to the item
-   * @property {boolean} [ignoreRoles=false] Whether to ignore role mentions to a guild member
-   * @property {boolean} [ignoreRepliedUser=false] Whether to ignore replied user mention to an user
-   * @property {boolean} [ignoreEveryone=false] Whether to ignore `@everyone`/`@here` mentions
-   */
-
-  /**
-   * Checks if a user, guild member, thread member, role, or channel is mentioned.
-   * Takes into account user mentions, role mentions, channel mentions,
-   * replied user mention, and `@everyone`/`@here` mentions.
-   * @param {UserResolvable|RoleResolvable|ChannelResolvable} data The User/Role/Channel to check for
-   * @param {MessageMentionsHasOptions} [options] The options for the check
-   * @returns {boolean}
-   */
+  
+
+  
   has(data, { ignoreDirect = false, ignoreRoles = false, ignoreRepliedUser = false, ignoreEveryone = false } = {}) {
     const user = this.client.users.resolve(data);
 

package/src/structures/MessagePayload.js

@@ -11,97 +11,57 @@ const { basename, verifyString } = require('../util/Util');
 
 const getBaseInteraction = lazy(() => require('./BaseInteraction'));
 
-/**
- * Represents a message to be sent to the API.
- */
+
 class MessagePayload {
-  /**
-   * @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} or a {@link WebhookClient}
-   * @type {boolean}
-   * @readonly
-   */
+  
   get isWebhook() {
     const Webhook = require('./Webhook');
     const WebhookClient = require('../client/WebhookClient');
     return this.target instanceof Webhook || this.target instanceof WebhookClient;
   }
 
-  /**
-   * Whether or not the target is a {@link User}
-   * @type {boolean}
-   * @readonly
-   */
+  
   get isUser() {
     const User = require('./User');
     const { GuildMember } = require('./GuildMember');
     return this.target instanceof User || this.target instanceof GuildMember;
   }
 
-  /**
-   * Whether or not the target is a {@link Message}
-   * @type {boolean}
-   * @readonly
-   */
+  
   get isMessage() {
     const { Message } = require('./Message');
     return this.target instanceof Message;
   }
 
-  /**
-   * Whether or not the target is a {@link MessageManager}
-   * @type {boolean}
-   * @readonly
-   */
+  
   get isMessageManager() {
     const MessageManager = require('../managers/MessageManager');
     return this.target instanceof MessageManager;
   }
 
-  /**
-   * Whether or not the target is an {@link BaseInteraction} or an {@link InteractionWebhook}
-   * @type {boolean}
-   * @readonly
-   */
+  
   get isInteraction() {
     const BaseInteraction = getBaseInteraction();
     const InteractionWebhook = require('./InteractionWebhook');
     return this.target instanceof BaseInteraction || this.target instanceof InteractionWebhook;
   }
 
-  /**
-   * Makes the content of this message.
-   * @returns {?string}
-   */
+  
   makeContent() {
     let content;
     if (this.options.content === null) {
@@ -113,10 +73,7 @@ class MessagePayload {
     return content;
   }
 
-  /**
-   * Resolves the body.
-   * @returns {MessagePayload}
-   */
+  
   resolveBody() {
     if (this.body) return this;
     const isInteraction = this.isInteraction;
@@ -151,7 +108,7 @@ class MessagePayload {
       this.isMessageManager
     ) {
       flags =
-        // eslint-disable-next-line eqeqeq
+        
         this.options.flags != null
           ? new MessageFlagsBitField(this.options.flags).bitfield
           : this.target.flags?.bitfield;
@@ -213,10 +170,7 @@ class MessagePayload {
     return this;
   }
 
-  /**
-   * Resolves files.
-   * @returns {Promise<MessagePayload>}
-   */
+  
   async resolveFiles() {
     if (this.files) return this;
 
@@ -224,11 +178,7 @@ class MessagePayload {
     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;
@@ -259,13 +209,7 @@ class MessagePayload {
     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,
@@ -276,24 +220,10 @@ class MessagePayload {
 
 module.exports = MessagePayload;
 
-/**
- * A target for a message.
- * @typedef {TextBasedChannels|User|GuildMember|Webhook|WebhookClient|BaseInteraction|InteractionWebhook|
- * Message|MessageManager} MessageTarget
- */
-
-/**
- * A possible payload option.
- * @typedef {MessageCreateOptions|MessageEditOptions|WebhookMessageCreateOptions|WebhookMessageEditOptions|
- * InteractionReplyOptions|InteractionUpdateOptions} MessagePayloadOption
- */
-
-/**
- * @external APIMessage
- * @see {@link https://discord.com/developers/docs/resources/channel#message-object}
- */
-
-/**
- * @external RawFile
- * @see {@link https://discord.js.org/docs/packages/rest/stable/RawFile:Interface}
- */
+
+
+
+
+
+
+