@velliajs/discord 1.0.3 → 1.0.4

package/src/structures/InteractionCollector.js

@@ -4,64 +4,28 @@ const { Collection } = require('@discordjs/collection');
 const Collector = require('./interfaces/Collector');
 const Events = require('../util/Events');
 
-/**
- * @typedef {CollectorOptions} InteractionCollectorOptions
- * @property {TextBasedChannelsResolvable} [channel] The channel to listen to interactions from
- * @property {ComponentType} [componentType] The type of component to listen for
- * @property {GuildResolvable} [guild] The guild to listen to interactions from
- * @property {InteractionType} [interactionType] The type of interaction to listen for
- * @property {number} [max] The maximum total amount of interactions to collect
- * @property {number} [maxComponents] The maximum number of components to collect
- * @property {number} [maxUsers] The maximum number of users to interact
- * @property {Message|APIMessage} [message] The message to listen to interactions from
- * @property {InteractionResponse} [interactionResponse] The interaction response to listen
- * to message component interactions from
- */
-
-/**
- * Collects interactions.
- * Will automatically stop if the message ({@link Client#event:messageDelete messageDelete} or
- * {@link Client#event:messageDeleteBulk messageDeleteBulk}),
- * channel ({@link Client#event:channelDelete channelDelete}), or
- * guild ({@link Client#event:guildDelete guildDelete}) is deleted.
- * <info>Interaction collectors that do not specify `time` or `idle` may be prone to always running.
- * Ensure your interaction collectors end via either of these options or manual cancellation.</info>
- * @extends {Collector}
- */
+
+
+
 class InteractionCollector extends Collector {
-  /**
-   * @param {Client} client The client on which to collect interactions
-   * @param {InteractionCollectorOptions} [options={}] The options to apply to this collector
-   */
+  
   constructor(client, options = {}) {
     super(client, options);
 
-    /**
-     * The message from which to collect interactions, if provided
-     * @type {?Snowflake}
-     */
+    
     this.messageId = options.message?.id ?? null;
 
-    /**
-     * The message interaction id from which to collect interactions, if provided
-     * @type {?Snowflake}
-     */
+    
     this.messageInteractionId = options.interactionResponse?.id ?? null;
 
-    /**
-     * The channel from which to collect interactions, if provided
-     * @type {?Snowflake}
-     */
+    
     this.channelId =
       options.interactionResponse?.interaction.channelId ??
       options.message?.channelId ??
       options.message?.channel_id ??
       this.client.channels.resolveId(options.channel);
 
-    /**
-     * The guild from which to collect interactions, if provided
-     * @type {?Snowflake}
-     */
+    
     this.guildId =
       options.interactionResponse?.interaction.guildId ??
       options.message?.guildId ??
@@ -69,28 +33,16 @@ class InteractionCollector extends Collector {
       this.client.guilds.resolveId(options.channel?.guild) ??
       this.client.guilds.resolveId(options.guild);
 
-    /**
-     * The type of interaction to collect
-     * @type {?InteractionType}
-     */
+    
     this.interactionType = options.interactionType ?? null;
 
-    /**
-     * The type of component to collect
-     * @type {?ComponentType}
-     */
+    
     this.componentType = options.componentType ?? null;
 
-    /**
-     * The users that have interacted with this collector
-     * @type {Collection<Snowflake, User>}
-     */
+    
     this.users = new Collection();
 
-    /**
-     * The total number of interactions collected
-     * @type {number}
-     */
+    
     this.total = 0;
 
     this.client.incrementMaxListeners();
@@ -135,18 +87,9 @@ class InteractionCollector extends Collector {
     });
   }
 
-  /**
-   * Handles an incoming interaction for possible collection.
-   * @param {BaseInteraction} interaction The interaction to possibly collect
-   * @returns {?Snowflake}
-   * @private
-   */
+  
   collect(interaction) {
-    /**
-     * Emitted whenever an interaction is collected.
-     * @event InteractionCollector#collect
-     * @param {BaseInteraction} interaction The interaction that was collected
-     */
+    
 
     if (this.interactionType && interaction.type !== this.interactionType) return null;
     if (this.componentType && interaction.componentType !== this.componentType) return null;
@@ -164,17 +107,9 @@ class InteractionCollector extends Collector {
     return interaction.id;
   }
 
-  /**
-   * Handles an interaction for possible disposal.
-   * @param {BaseInteraction} interaction The interaction that could be disposed of
-   * @returns {?Snowflake}
-   */
+  
   dispose(interaction) {
-    /**
-     * Emitted whenever an interaction is disposed of.
-     * @event InteractionCollector#dispose
-     * @param {BaseInteraction} interaction The interaction that was disposed of
-     */
+    
     if (this.type && interaction.type !== this.type) return null;
     if (this.componentType && interaction.componentType !== this.componentType) return null;
     if (this.messageId && interaction.message?.id !== this.messageId) return null;
@@ -185,9 +120,7 @@ class InteractionCollector extends Collector {
     return interaction.id;
   }
 
-  /**
-   * Empties this interaction collector.
-   */
+  
   empty() {
     this.total = 0;
     this.collected.clear();
@@ -195,11 +128,7 @@ class InteractionCollector extends Collector {
     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.maxComponents && this.collected.size >= this.options.maxComponents) return 'componentLimit';
@@ -207,12 +136,7 @@ class InteractionCollector extends Collector {
     return super.endReason;
   }
 
-  /**
-   * 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.messageId) {
       this.stop('messageDelete');
@@ -223,36 +147,21 @@ class InteractionCollector extends Collector {
     }
   }
 
-  /**
-   * 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.channelId || channel.threads?.cache.has(this.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.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.guildId) {
       this.stop('guildDelete');

package/src/structures/InteractionResponse.js

@@ -4,48 +4,27 @@ const { DiscordSnowflake } = require('@sapphire/snowflake');
 const { InteractionType } = require('discord-api-types/v10');
 const { DiscordjsError, ErrorCodes } = require('../errors');
 
-/**
- * Represents an interaction's response
- */
+
 class InteractionResponse {
   constructor(interaction, id) {
-    /**
-     * The interaction associated with the interaction response
-     * @type {BaseInteraction}
-     */
+    
     this.interaction = interaction;
-    /**
-     * The id of the original interaction response
-     * @type {Snowflake}
-     */
+    
     this.id = id ?? interaction.id;
     this.client = interaction.client;
   }
 
-  /**
-   * The timestamp the interaction response was created at
-   * @type {number}
-   * @readonly
-   */
+  
   get createdTimestamp() {
     return DiscordSnowflake.timestampFrom(this.id);
   }
 
-  /**
-   * The time the interaction response was created at
-   * @type {Date}
-   * @readonly
-   */
+  
   get createdAt() {
     return new Date(this.createdTimestamp);
   }
 
-  /**
-   * Collects a single component interaction that passes the filter.
-   * The Promise will reject if the time expires.
-   * @param {AwaitMessageComponentOptions} [options={}] Options to pass to the internal collector
-   * @returns {Promise<MessageComponentInteraction>}
-   */
+  
   awaitMessageComponent(options = {}) {
     const _options = { ...options, max: 1 };
     return new Promise((resolve, reject) => {
@@ -58,11 +37,7 @@ class InteractionResponse {
     });
   }
 
-  /**
-   * Creates a message component interaction collector
-   * @param {MessageComponentCollectorOptions} [options={}] Options to send to the collector
-   * @returns {InteractionCollector}
-   */
+  
   createMessageComponentCollector(options = {}) {
     return new InteractionCollector(this.client, {
       ...options,
@@ -71,32 +46,22 @@ class InteractionResponse {
     });
   }
 
-  /**
-   * Fetches the response as a {@link Message} object.
-   * @returns {Promise<Message>}
-   */
+  
   fetch() {
     return this.interaction.fetchReply();
   }
 
-  /**
-   * Deletes the response.
-   * @returns {Promise<void>}
-   */
+  
   delete() {
     return this.interaction.deleteReply();
   }
 
-  /**
-   * Edits the response.
-   * @param {string|MessagePayload|WebhookMessageEditOptions} options The new options for the response.
-   * @returns {Promise<Message>}
-   */
+  
   edit(options) {
     return this.interaction.editReply(options);
   }
 }
 
-// eslint-disable-next-line import/order
+
 const InteractionCollector = require('./InteractionCollector');
 module.exports = InteractionResponse;

package/src/structures/InteractionWebhook.js

@@ -2,52 +2,27 @@
 
 const Webhook = require('./Webhook');
 
-/**
- * Represents a webhook for an Interaction
- * @implements {Webhook}
- */
+
 class InteractionWebhook {
-  /**
-   * @param {Client} client The instantiating client
-   * @param {Snowflake} id The application's id
-   * @param {string} token The interaction's token
-   */
+  
   constructor(client, id, token) {
-    /**
-     * The client that instantiated the interaction webhook
-     * @name InteractionWebhook#client
-     * @type {Client}
-     * @readonly
-     */
+    
     Object.defineProperty(this, 'client', { value: client });
     this.id = id;
     Object.defineProperty(this, 'token', { value: token, writable: true, configurable: true });
   }
 
-  // These are here only for documentation purposes - they are implemented by Webhook
-  /* eslint-disable no-empty-function */
-  /**
-   * Sends a message with this webhook.
-   * @param {string|MessagePayload|InteractionReplyOptions} options The content for the reply
-   * @returns {Promise<Message>}
-   */
+  
+  
+  
 
   send() {}
 
-  /**
-   * Gets a message that was sent by this webhook.
-   * @param {Snowflake|'@original'} message The id of the message to fetch
-   * @returns {Promise<Message>} Returns the message sent by this webhook
-   */
+  
 
   fetchMessage() {}
 
-  /**
-   * Edits a message that was sent by this webhook.
-   * @param {MessageResolvable|'@original'} message The message to edit
-   * @param {string|MessagePayload|WebhookMessageEditOptions} options The options to provide
-   * @returns {Promise<Message>} Returns the message edited by this webhook
-   */
+  
 
   editMessage() {}
   deleteMessage() {}

package/src/structures/Invite.js

@@ -7,17 +7,9 @@ const IntegrationApplication = require('./IntegrationApplication');
 const InviteStageInstance = require('./InviteStageInstance');
 const { DiscordjsError, ErrorCodes } = require('../errors');
 
-/**
- * Represents an invitation to a guild channel.
- * @extends {Base}
- */
+
 class Invite extends Base {
-  /**
-   * A regular expression that matches Discord invite links.
-   * The `code` group property is present on the `exec()` result of this expression.
-   * @type {RegExp}
-   * @memberof Invite
-   */
+  
   static InvitesPattern = /discord(?:(?:app)?\.com\/invite|\.gg(?:\/invite)?)\/(?<code>[\w-]{2,255})/i;
 
   constructor(client, data) {
@@ -27,98 +19,61 @@ class Invite extends Base {
 
   _patch(data) {
     const InviteGuild = require('./InviteGuild');
-    /**
-     * The guild the invite is for including welcome screen data if present
-     * @type {?(Guild|InviteGuild)}
-     */
+    
     this.guild ??= null;
     if (data.guild) {
       this.guild = this.client.guilds.resolve(data.guild.id) ?? new InviteGuild(this.client, data.guild);
     }
 
     if ('code' in data) {
-      /**
-       * The code for this invite
-       * @type {string}
-       */
+      
       this.code = data.code;
     }
 
     if ('approximate_presence_count' in data) {
-      /**
-       * The approximate number of online members of the guild this invite is for
-       * <info>This is only available when the invite was fetched through {@link Client#fetchInvite}.</info>
-       * @type {?number}
-       */
+      
       this.presenceCount = data.approximate_presence_count;
     } else {
       this.presenceCount ??= null;
     }
 
     if ('approximate_member_count' in data) {
-      /**
-       * The approximate total number of members of the guild this invite is for
-       * <info>This is only available when the invite was fetched through {@link Client#fetchInvite}.</info>
-       * @type {?number}
-       */
+      
       this.memberCount = data.approximate_member_count;
     } else {
       this.memberCount ??= null;
     }
 
     if ('temporary' in data) {
-      /**
-       * Whether or not this invite only grants temporary membership
-       * <info>This is only available when the invite was fetched through {@link GuildInviteManager#fetch}
-       * or created through {@link GuildInviteManager#create}.</info>
-       * @type {?boolean}
-       */
+      
       this.temporary = data.temporary ?? null;
     } else {
       this.temporary ??= null;
     }
 
     if ('max_age' in data) {
-      /**
-       * The maximum age of the invite, in seconds, 0 if never expires
-       * <info>This is only available when the invite was fetched through {@link GuildInviteManager#fetch}
-       * or created through {@link GuildInviteManager#create}.</info>
-       * @type {?number}
-       */
+      
       this.maxAge = data.max_age;
     } else {
       this.maxAge ??= null;
     }
 
     if ('uses' in data) {
-      /**
-       * How many times this invite has been used
-       * <info>This is only available when the invite was fetched through {@link GuildInviteManager#fetch}
-       * or created through {@link GuildInviteManager#create}.</info>
-       * @type {?number}
-       */
+      
       this.uses = data.uses;
     } else {
       this.uses ??= null;
     }
 
     if ('max_uses' in data) {
-      /**
-       * The maximum uses of this invite
-       * <info>This is only available when the invite was fetched through {@link GuildInviteManager#fetch}
-       * or created through {@link GuildInviteManager#create}.</info>
-       * @type {?number}
-       */
+      
       this.maxUses = data.max_uses;
     } else {
       this.maxUses ??= null;
     }
 
     if ('inviter_id' in data) {
-      /**
-       * The user's id who created this invite
-       * @type {?Snowflake}
-       */
+      
       this.inviterId = data.inviter_id;
     } else {
       this.inviterId ??= null;
@@ -130,48 +85,33 @@ class Invite extends Base {
     }
 
     if ('target_user' in data) {
-      /**
-       * The user whose stream to display for this voice channel stream invite
-       * @type {?User}
-       */
+      
       this.targetUser = this.client.users._add(data.target_user);
     } else {
       this.targetUser ??= null;
     }
 
     if ('target_application' in data) {
-      /**
-       * The embedded application to open for this voice channel embedded application invite
-       * @type {?IntegrationApplication}
-       */
+      
       this.targetApplication = new IntegrationApplication(this.client, data.target_application);
     } else {
       this.targetApplication ??= null;
     }
 
     if ('target_type' in data) {
-      /**
-       * The target type
-       * @type {?InviteTargetType}
-       */
+      
       this.targetType = data.target_type;
     } else {
       this.targetType ??= null;
     }
 
     if ('channel_id' in data) {
-      /**
-       * The id of the channel this invite is for
-       * @type {?Snowflake}
-       */
+      
       this.channelId = data.channel_id;
     }
 
     if ('channel' in data) {
-      /**
-       * The channel this invite is for
-       * @type {?BaseChannel}
-       */
+      
       this.channel =
         this.client.channels._add(data.channel, this.guild, { cache: false }) ??
         this.client.channels.resolve(this.channelId);
@@ -180,10 +120,7 @@ class Invite extends Base {
     }
 
     if ('created_at' in data) {
-      /**
-       * The timestamp this invite was created at
-       * @type {?number}
-       */
+      
       this.createdTimestamp = Date.parse(data.created_at);
     } else {
       this.createdTimestamp ??= null;
@@ -196,41 +133,26 @@ class Invite extends Base {
     }
 
     if ('stage_instance' in data) {
-      /**
-       * The stage instance data if there is a public {@link StageInstance} in the stage channel this invite is for
-       * @type {?InviteStageInstance}
-       * @deprecated
-       */
+      
       this.stageInstance = new InviteStageInstance(this.client, data.stage_instance, this.channel.id, this.guild.id);
     } else {
       this.stageInstance ??= null;
     }
 
     if ('guild_scheduled_event' in data) {
-      /**
-       * The guild scheduled event data if there is a {@link GuildScheduledEvent} in the channel this invite is for
-       * @type {?GuildScheduledEvent}
-       */
+      
       this.guildScheduledEvent = new GuildScheduledEvent(this.client, data.guild_scheduled_event);
     } else {
       this.guildScheduledEvent ??= null;
     }
   }
 
-  /**
-   * The time the invite was created at
-   * @type {?Date}
-   * @readonly
-   */
+  
   get createdAt() {
     return this.createdTimestamp && new Date(this.createdTimestamp);
   }
 
-  /**
-   * Whether the invite is deletable by the client user
-   * @type {boolean}
-   * @readonly
-   */
+  
   get deletable() {
     const guild = this.guild;
     if (!guild || !this.client.guilds.cache.has(guild.id)) return false;
@@ -241,11 +163,7 @@ class Invite extends Base {
     );
   }
 
-  /**
-   * The timestamp the invite will expire at
-   * @type {?number}
-   * @readonly
-   */
+  
   get expiresTimestamp() {
     return (
       this._expiresTimestamp ??
@@ -253,50 +171,28 @@ class Invite extends Base {
     );
   }
 
-  /**
-   * The time the invite will expire at
-   * @type {?Date}
-   * @readonly
-   */
+  
   get expiresAt() {
     return this.expiresTimestamp && new Date(this.expiresTimestamp);
   }
 
-  /**
-   * The user who created this invite
-   * @type {?User}
-   * @readonly
-   */
+  
   get inviter() {
     return this.inviterId && this.client.users.resolve(this.inviterId);
   }
 
-  /**
-   * The URL to the invite
-   * @type {string}
-   * @readonly
-   */
+  
   get url() {
     return `${RouteBases.invite}/${this.code}`;
   }
 
-  /**
-   * Deletes this invite.
-   * @param {string} [reason] Reason for deleting this invite
-   * @returns {Promise<Invite>}
-   */
+  
   async delete(reason) {
     await this.client.rest.delete(Routes.invite(this.code), { reason });
     return this;
   }
 
-  /**
-   * When concatenated with a string, this automatically concatenates the invite's URL instead of the object.
-   * @returns {string}
-   * @example
-   * // Logs: Invite: https://discord.gg/A1b2C3
-   * console.log(`Invite: ${invite}`);
-   */
+  
   toString() {
     return this.url;
   }