@velliajs/discord 1.0.2 → 1.0.4

package/src/structures/interfaces/InteractionResponses.js

@@ -7,62 +7,19 @@ const InteractionCollector = require('../InteractionCollector');
 const InteractionResponse = require('../InteractionResponse');
 const MessagePayload = require('../MessagePayload');
 
-/**
- * @typedef {Object} ModalComponentData
- * @property {string} title The title of the modal
- * @property {string} customId The custom id of the modal
- * @property {ActionRow[]} components The components within this modal
- */
-
-/**
- * Interface for classes that support shared interaction response types.
- * @interface
- */
+
+
+
 class InteractionResponses {
-  /**
-   * Options for deferring the reply to an {@link BaseInteraction}.
-   * @typedef {Object} InteractionDeferReplyOptions
-   * @property {boolean} [ephemeral] Whether the reply should be ephemeral
-   * @property {boolean} [fetchReply] Whether to fetch the reply
-   */
-
-  /**
-   * Options for deferring and updating the reply to a {@link MessageComponentInteraction}.
-   * @typedef {Object} InteractionDeferUpdateOptions
-   * @property {boolean} [fetchReply] Whether to fetch the reply
-   */
-
-  /**
-   * Options for a reply to a {@link BaseInteraction}.
-   * @typedef {BaseMessageOptions} InteractionReplyOptions
-   * @property {boolean} [tts=false] Whether the message should be spoken aloud
-   * @property {boolean} [ephemeral] Whether the reply should be ephemeral
-   * @property {boolean} [fetchReply] Whether to fetch the reply
-   * @property {MessageFlags} [flags] Which flags to set for the message.
-   * <info>Only `MessageFlags.SuppressEmbeds` and `MessageFlags.Ephemeral` can be set.</info>
-   */
-
-  /**
-   * Options for updating the message received from a {@link MessageComponentInteraction}.
-   * @typedef {MessageEditOptions} InteractionUpdateOptions
-   * @property {boolean} [fetchReply] Whether to fetch the reply
-   */
-
-  /**
-   * Defers the reply to this interaction.
-   * @param {InteractionDeferReplyOptions} [options] Options for deferring the reply to this interaction
-   * @returns {Promise<Message|InteractionResponse>}
-   * @example
-   * // Defer the reply to this interaction
-   * interaction.deferReply()
-   *   .then(console.log)
-   *   .catch(console.error)
-   * @example
-   * // Defer to send an ephemeral reply later
-   * interaction.deferReply({ ephemeral: true })
-   *   .then(console.log)
-   *   .catch(console.error);
-   */
+  
+
+  
+
+  
+
+  
+
+  
   async deferReply(options = {}) {
     if (this.deferred || this.replied) throw new DiscordjsError(ErrorCodes.InteractionAlreadyReplied);
     this.ephemeral = options.ephemeral ?? false;
@@ -80,24 +37,7 @@ class InteractionResponses {
     return options.fetchReply ? this.fetchReply() : new InteractionResponse(this);
   }
 
-  /**
-   * Creates a reply to this interaction.
-   * <info>Use the `fetchReply` option to get the bot's reply message.</info>
-   * @param {string|MessagePayload|InteractionReplyOptions} options The options for the reply
-   * @returns {Promise<Message|InteractionResponse>}
-   * @example
-   * // Reply to the interaction and fetch the response
-   * interaction.reply({ content: 'Pong!', fetchReply: true })
-   *   .then((message) => console.log(`Reply sent with content ${message.content}`))
-   *   .catch(console.error);
-   * @example
-   * // Create an ephemeral reply with an embed
-   * const embed = new EmbedBuilder().setDescription('Pong!');
-   *
-   * interaction.reply({ embeds: [embed], ephemeral: true })
-   *   .then(() => console.log('Reply sent.'))
-   *   .catch(console.error);
-   */
+  
   async reply(options) {
     if (this.deferred || this.replied) throw new DiscordjsError(ErrorCodes.InteractionAlreadyReplied);
     this.ephemeral = options.ephemeral ?? false;
@@ -121,38 +61,14 @@ class InteractionResponses {
     return options.fetchReply ? this.fetchReply() : new InteractionResponse(this);
   }
 
-  /**
-   * Fetches a reply to this interaction.
-   * @see Webhook#fetchMessage
-   * @param {Snowflake|'@original'} [message='@original'] The response to fetch
-   * @returns {Promise<Message>}
-   * @example
-   * // Fetch the initial reply to this interaction
-   * interaction.fetchReply()
-   *   .then(reply => console.log(`Replied with ${reply.content}`))
-   *   .catch(console.error);
-   */
+  
   fetchReply(message = '@original') {
     return this.webhook.fetchMessage(message);
   }
 
-  /**
-   * Options that can be passed into {@link InteractionResponses#editReply}.
-   * @typedef {WebhookMessageEditOptions} InteractionEditReplyOptions
-   * @property {MessageResolvable|'@original'} [message='@original'] The response to edit
-   */
-
-  /**
-   * Edits a reply to this interaction.
-   * @see Webhook#editMessage
-   * @param {string|MessagePayload|InteractionEditReplyOptions} options The new options for the message
-   * @returns {Promise<Message>}
-   * @example
-   * // Edit the initial reply to this interaction
-   * interaction.editReply('New content')
-   *   .then(console.log)
-   *   .catch(console.error);
-   */
+  
+
+  
   async editReply(options) {
     if (!this.deferred && !this.replied) throw new DiscordjsError(ErrorCodes.InteractionNotReplied);
     const msg = await this.webhook.editMessage(options.message ?? '@original', options);
@@ -160,41 +76,18 @@ class InteractionResponses {
     return msg;
   }
 
-  /**
-   * Deletes a reply to this interaction.
-   * @see Webhook#deleteMessage
-   * @param {MessageResolvable|'@original'} [message='@original'] The response to delete
-   * @returns {Promise<void>}
-   * @example
-   * // Delete the initial reply to this interaction
-   * interaction.deleteReply()
-   *   .then(console.log)
-   *   .catch(console.error);
-   */
+  
   async deleteReply(message = '@original') {
     await this.webhook.deleteMessage(message);
   }
 
-  /**
-   * Send a follow-up message to this interaction.
-   * @param {string|MessagePayload|InteractionReplyOptions} options The options for the reply
-   * @returns {Promise<Message>}
-   */
+  
   followUp(options) {
     if (!this.deferred && !this.replied) return Promise.reject(new DiscordjsError(ErrorCodes.InteractionNotReplied));
     return this.webhook.send(options);
   }
 
-  /**
-   * Defers an update to the message to which the component was attached.
-   * @param {InteractionDeferUpdateOptions} [options] Options for deferring the update to this interaction
-   * @returns {Promise<Message|InteractionResponse>}
-   * @example
-   * // Defer updating and reset the component's loading state
-   * interaction.deferUpdate()
-   *   .then(console.log)
-   *   .catch(console.error);
-   */
+  
   async deferUpdate(options = {}) {
     if (this.deferred || this.replied) throw new DiscordjsError(ErrorCodes.InteractionAlreadyReplied);
     await this.client.rest.post(Routes.interactionCallback(this.id, this.token), {
@@ -208,19 +101,7 @@ class InteractionResponses {
     return options.fetchReply ? this.fetchReply() : new InteractionResponse(this, this.message?.interaction?.id);
   }
 
-  /**
-   * Updates the original message of the component on which the interaction was received on.
-   * @param {string|MessagePayload|InteractionUpdateOptions} options The options for the updated message
-   * @returns {Promise<Message|void>}
-   * @example
-   * // Remove the components from the message
-   * interaction.update({
-   *   content: "A component interaction was received",
-   *   components: []
-   * })
-   *   .then(console.log)
-   *   .catch(console.error);
-   */
+  
   async update(options) {
     if (this.deferred || this.replied) throw new DiscordjsError(ErrorCodes.InteractionAlreadyReplied);
 
@@ -243,11 +124,7 @@ class InteractionResponses {
     return options.fetchReply ? this.fetchReply() : new InteractionResponse(this, this.message.interaction?.id);
   }
 
-  /**
-   * Shows a modal component
-   * @param {ModalBuilder|ModalComponentData|APIModalInteractionResponseCallbackData} modal The modal to show
-   * @returns {Promise<void>}
-   */
+  
   async showModal(modal) {
     if (this.deferred || this.replied) throw new DiscordjsError(ErrorCodes.InteractionAlreadyReplied);
     await this.client.rest.post(Routes.interactionCallback(this.id, this.token), {
@@ -260,25 +137,9 @@ class InteractionResponses {
     this.replied = true;
   }
 
-  /**
-   * An object containing the same properties as {@link CollectorOptions}, but a few less:
-   * @typedef {Object} AwaitModalSubmitOptions
-   * @property {CollectorFilter} [filter] The filter applied to this collector
-   * @property {number} time Time in milliseconds to wait for an interaction before rejecting
-   */
-
-  /**
-   * Collects a single modal submit interaction that passes the filter.
-   * The Promise will reject if the time expires.
-   * @param {AwaitModalSubmitOptions} options Options to pass to the internal collector
-   * @returns {Promise<ModalSubmitInteraction>}
-   * @example
-   * // Collect a modal submit interaction
-   * const filter = (interaction) => interaction.customId === 'modal';
-   * interaction.awaitModalSubmit({ filter, time: 15_000 })
-   *   .then(interaction => console.log(`${interaction.customId} was submitted!`))
-   *   .catch(console.error);
-   */
+  
+
+  
   awaitModalSubmit(options) {
     if (typeof options.time !== 'number') throw new DiscordjsError(ErrorCodes.InvalidType, 'time', 'number');
     const _options = { ...options, max: 1, interactionType: InteractionType.ModalSubmit };

package/src/structures/interfaces/TextBasedChannel.js

@@ -9,138 +9,44 @@ const InteractionCollector = require('../InteractionCollector');
 const MessageCollector = require('../MessageCollector');
 const MessagePayload = require('../MessagePayload');
 
-/**
- * Interface for classes that have text-channel-like features.
- * @interface
- */
+
 class TextBasedChannel {
   constructor() {
-    /**
-     * A manager of the messages sent to this channel
-     * @type {MessageManager}
-     */
+    
     this.messages = new MessageManager(this);
 
-    /**
-     * The channel's last message id, if one was sent
-     * @type {?Snowflake}
-     */
+    
     this.lastMessageId = null;
 
-    /**
-     * The timestamp when the last pinned message was pinned, if there was one
-     * @type {?number}
-     */
+    
     this.lastPinTimestamp = null;
   }
 
-  /**
-   * The Message object of the last message in the channel, if one was sent
-   * @type {?Message}
-   * @readonly
-   */
+  
   get lastMessage() {
     return this.messages.resolve(this.lastMessageId);
   }
 
-  /**
-   * The date when the last pinned message was pinned, if there was one
-   * @type {?Date}
-   * @readonly
-   */
+  
   get lastPinAt() {
     return this.lastPinTimestamp && new Date(this.lastPinTimestamp);
   }
 
-  /**
-   * The base message options for messages.
-   * @typedef {Object} BaseMessageOptions
-   * @property {string|null} [content=''] The content for the message. This can only be `null` when editing a message.
-   * @property {Array<(EmbedBuilder|Embed|APIEmbed)>} [embeds] The embeds for the message
-   * @property {MessageMentionOptions} [allowedMentions] Which mentions should be parsed from the message content
-   * (see [here](https://discord.com/developers/docs/resources/channel#allowed-mentions-object) for more details)
-   * @property {Array<(AttachmentBuilder|Attachment|AttachmentPayload|BufferResolvable)>} [files]
-   * The files to send with the message.
-   * @property {Array<(ActionRowBuilder|ActionRow|APIActionRowComponent)>} [components]
-   * Action rows containing interactive components for the message (buttons, select menus)
-   */
-
-  /**
-   * Options for sending a message with a reply.
-   * @typedef {Object} ReplyOptions
-   * @property {MessageResolvable} messageReference The message to reply to (must be in the same channel and not system)
-   * @property {boolean} [failIfNotExists=this.client.options.failIfNotExists] Whether to error if the referenced
-   * message does not exist (creates a standard message in this case when false)
-   */
-
-  /**
-   * The options for sending a message.
-   * @typedef {BaseMessageOptions} BaseMessageCreateOptions
-   * @property {boolean} [tts=false] Whether the message should be spoken aloud
-   * @property {string} [nonce=''] The nonce for the message
-   * @property {StickerResolvable[]} [stickers=[]] The stickers to send in the message
-   * @property {MessageFlags} [flags] Which flags to set for the message.
-   * <info>Only `MessageFlags.SuppressEmbeds` and `MessageFlags.SuppressNotifications` can be set.</info>
-   */
-
-  /**
-   * The options for sending a message.
-   * @typedef {BaseMessageCreateOptions} MessageCreateOptions
-   * @property {ReplyOptions} [reply] The options for replying to a message
-   */
-
-  /**
-   * Options provided to control parsing of mentions by Discord
-   * @typedef {Object} MessageMentionOptions
-   * @property {MessageMentionTypes[]} [parse] Types of mentions to be parsed
-   * @property {Snowflake[]} [users] Snowflakes of Users to be parsed as mentions
-   * @property {Snowflake[]} [roles] Snowflakes of Roles to be parsed as mentions
-   * @property {boolean} [repliedUser=true] Whether the author of the Message being replied to should be pinged
-   */
-
-  /**
-   * Types of mentions to enable in MessageMentionOptions.
-   * - `roles`
-   * - `users`
-   * - `everyone`
-   * @typedef {string} MessageMentionTypes
-   */
-
-  /**
-   * @typedef {Object} FileOptions
-   * @property {BufferResolvable} attachment File to attach
-   * @property {string} [name='file.jpg'] Filename of the attachment
-   * @property {string} description The description of the file
-   */
-
-  /**
-   * Sends a message to this channel.
-   * @param {string|MessagePayload|MessageCreateOptions} options The options to provide
-   * @returns {Promise<Message>}
-   * @example
-   * // Send a basic message
-   * channel.send('hello!')
-   *   .then(message => console.log(`Sent message: ${message.content}`))
-   *   .catch(console.error);
-   * @example
-   * // Send a remote file
-   * channel.send({
-   *   files: ['https://cdn.discordapp.com/icons/222078108977594368/6e1019b3179d71046e463a75915e7244.png?size=2048']
-   * })
-   *   .then(console.log)
-   *   .catch(console.error);
-   * @example
-   * // Send a local file
-   * channel.send({
-   *   files: [{
-   *     attachment: 'entire/path/to/file.jpg',
-   *     name: 'file.jpg',
-   *     description: 'A description of the file'
-   *   }]
-   * })
-   *   .then(console.log)
-   *   .catch(console.error);
-   */
+  
+
+  
+
+  
+
+  
+
+  
+
+  
+
+  
+
+  
   async send(options) {
     const User = require('../User');
     const { GuildMember } = require('../GuildMember');
@@ -164,51 +70,19 @@ class TextBasedChannel {
     return this.messages.cache.get(d.id) ?? this.messages._add(d);
   }
 
-  /**
-   * Sends a typing indicator in the channel.
-   * @returns {Promise<void>} Resolves upon the typing status being sent
-   * @example
-   * // Start typing in a channel
-   * channel.sendTyping();
-   */
+  
   async sendTyping() {
     await this.client.rest.post(Routes.channelTyping(this.id));
   }
 
-  /**
-   * Creates a Message Collector.
-   * @param {MessageCollectorOptions} [options={}] The options to pass to the collector
-   * @returns {MessageCollector}
-   * @example
-   * // Create a message collector
-   * const filter = m => m.content.includes('discord');
-   * const collector = channel.createMessageCollector({ filter, time: 15_000 });
-   * collector.on('collect', m => console.log(`Collected ${m.content}`));
-   * collector.on('end', collected => console.log(`Collected ${collected.size} items`));
-   */
+  
   createMessageCollector(options = {}) {
     return new MessageCollector(this, options);
   }
 
-  /**
-   * An object containing the same properties as CollectorOptions, but a few more:
-   * @typedef {MessageCollectorOptions} AwaitMessagesOptions
-   * @property {string[]} [errors] Stop/end reasons that cause the promise to reject
-   */
-
-  /**
-   * Similar to createMessageCollector but in promise form.
-   * Resolves with a collection of messages that pass the specified filter.
-   * @param {AwaitMessagesOptions} [options={}] Optional options to pass to the internal collector
-   * @returns {Promise<Collection<Snowflake, Message>>}
-   * @example
-   * // Await !vote messages
-   * const filter = m => m.content.startsWith('!vote');
-   * // Errors: ['time'] treats ending because of the time limit as an error
-   * channel.awaitMessages({ filter, max: 4, time: 60_000, errors: ['time'] })
-   *   .then(collected => console.log(collected.size))
-   *   .catch(collected => console.log(`After a minute, only ${collected.size} out of 4 voted.`));
-   */
+  
+
+  
   awaitMessages(options = {}) {
     return new Promise((resolve, reject) => {
       const collector = this.createMessageCollector(options);
@@ -222,17 +96,7 @@ class TextBasedChannel {
     });
   }
 
-  /**
-   * Creates a component interaction collector.
-   * @param {MessageComponentCollectorOptions} [options={}] Options to send to the collector
-   * @returns {InteractionCollector}
-   * @example
-   * // Create a button interaction collector
-   * const filter = (interaction) => interaction.customId === 'button' && interaction.user.id === 'someId';
-   * const collector = channel.createMessageComponentCollector({ filter, time: 15_000 });
-   * collector.on('collect', i => console.log(`Collected ${i.customId}`));
-   * collector.on('end', collected => console.log(`Collected ${collected.size} items`));
-   */
+  
   createMessageComponentCollector(options = {}) {
     return new InteractionCollector(this.client, {
       ...options,
@@ -241,18 +105,7 @@ class TextBasedChannel {
     });
   }
 
-  /**
-   * 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>}
-   * @example
-   * // Collect a message component interaction
-   * const filter = (interaction) => interaction.customId === 'button' && interaction.user.id === 'someId';
-   * channel.awaitMessageComponent({ filter, time: 15_000 })
-   *   .then(interaction => console.log(`${interaction.customId} was clicked!`))
-   *   .catch(console.error);
-   */
+  
   awaitMessageComponent(options = {}) {
     const _options = { ...options, max: 1 };
     return new Promise((resolve, reject) => {
@@ -265,18 +118,7 @@ class TextBasedChannel {
     });
   }
 
-  /**
-   * Bulk deletes given messages that are newer than two weeks.
-   * @param {Collection<Snowflake, Message>|MessageResolvable[]|number} messages
-   * Messages or number of messages to delete
-   * @param {boolean} [filterOld=false] Filter messages to remove those which are older than two weeks automatically
-   * @returns {Promise<Collection<Snowflake, Message|undefined>>} Returns the deleted messages
-   * @example
-   * // Bulk delete messages
-   * channel.bulkDelete(5)
-   *   .then(messages => console.log(`Bulk deleted ${messages.size} messages`))
-   *   .catch(console.error);
-   */
+  
   async bulkDelete(messages, filterOld = false) {
     if (Array.isArray(messages) || messages instanceof Collection) {
       let messageIds = messages instanceof Collection ? [...messages.keys()] : messages.map(m => m.id ?? m);
@@ -318,61 +160,24 @@ class TextBasedChannel {
     throw new DiscordjsTypeError(ErrorCodes.MessageBulkDeleteType);
   }
 
-  /**
-   * Fetches all webhooks for the channel.
-   * @returns {Promise<Collection<Snowflake, Webhook>>}
-   * @example
-   * // Fetch webhooks
-   * channel.fetchWebhooks()
-   *   .then(hooks => console.log(`This channel has ${hooks.size} hooks`))
-   *   .catch(console.error);
-   */
+  
   fetchWebhooks() {
     return this.guild.channels.fetchWebhooks(this.id);
   }
 
-  /**
-   * Options used to create a {@link Webhook}.
-   * @typedef {Object} ChannelWebhookCreateOptions
-   * @property {string} name The name of the webhook
-   * @property {?(BufferResolvable|Base64Resolvable)} [avatar] Avatar for the webhook
-   * @property {string} [reason] Reason for creating the webhook
-   */
-
-  /**
-   * Creates a webhook for the channel.
-   * @param {ChannelWebhookCreateOptions} [options] Options for creating the webhook
-   * @returns {Promise<Webhook>} Returns the created Webhook
-   * @example
-   * // Create a webhook for the current channel
-   * channel.createWebhook({
-   *   name: 'Snek',
-   *   avatar: 'https://i.imgur.com/mI8XcpG.jpg',
-   *   reason: 'Needed a cool new Webhook'
-   * })
-   *   .then(console.log)
-   *   .catch(console.error)
-   */
+  
+
+  
   createWebhook(options) {
     return this.guild.channels.createWebhook({ channel: this.id, ...options });
   }
 
-  /**
-   * Sets the rate limit per user (slowmode) for this channel.
-   * @param {number} rateLimitPerUser The new rate limit in seconds
-   * @param {string} [reason] Reason for changing the channel's rate limit
-   * @returns {Promise<this>}
-   */
+  
   setRateLimitPerUser(rateLimitPerUser, reason) {
     return this.edit({ rateLimitPerUser, reason });
   }
 
-  /**
-   * Sets whether this channel is flagged as NSFW.
-   * @param {boolean} [nsfw=true] Whether the channel should be considered NSFW
-   * @param {string} [reason] Reason for changing the channel's NSFW flag
-   * @returns {Promise<this>}
-   */
+  
   setNSFW(nsfw = true, reason) {
     return this.edit({ nsfw, reason });
   }
@@ -408,6 +213,6 @@ class TextBasedChannel {
 
 module.exports = TextBasedChannel;
 
-// Fixes Circular
-// eslint-disable-next-line import/order
+
+
 const MessageManager = require('../../managers/MessageManager');