@velliajs/discord 1.0.2 → 1.0.4

package/src/structures/AutocompleteInteraction.js

@@ -5,81 +5,39 @@ const BaseInteraction = require('./BaseInteraction');
 const CommandInteractionOptionResolver = require('./CommandInteractionOptionResolver');
 const { DiscordjsError, ErrorCodes } = require('../errors');
 
-/**
- * Represents an autocomplete interaction.
- * @extends {BaseInteraction}
- */
+
 class AutocompleteInteraction extends BaseInteraction {
   constructor(client, data) {
     super(client, data);
 
-    /**
-     * The id of the channel this interaction was sent in
-     * @type {Snowflake}
-     * @name AutocompleteInteraction#channelId
-     */
+    
 
-    /**
-     * The invoked application command's id
-     * @type {Snowflake}
-     */
+    
     this.commandId = data.data.id;
 
-    /**
-     * The invoked application command's name
-     * @type {string}
-     */
+    
     this.commandName = data.data.name;
 
-    /**
-     * The invoked application command's type
-     * @type {ApplicationCommandType}
-     */
+    
     this.commandType = data.data.type;
 
-    /**
-     * The id of the guild the invoked application command is registered to
-     * @type {?Snowflake}
-     */
+    
     this.commandGuildId = data.data.guild_id ?? null;
 
-    /**
-     * Whether this interaction has already received a response
-     * @type {boolean}
-     */
+    
     this.responded = false;
 
-    /**
-     * The options passed to the command
-     * @type {CommandInteractionOptionResolver}
-     */
+    
     this.options = new CommandInteractionOptionResolver(this.client, data.data.options ?? []);
   }
 
-  /**
-   * The invoked application command, if it was fetched before
-   * @type {?ApplicationCommand}
-   */
+  
   get command() {
     const id = this.commandId;
     return this.guild?.commands.cache.get(id) ?? this.client.application.commands.cache.get(id) ?? null;
   }
 
-  /**
-   * Sends results for the autocomplete of this interaction.
-   * @param {ApplicationCommandOptionChoiceData[]} options The options for the autocomplete
-   * @returns {Promise<void>}
-   * @example
-   * // respond to autocomplete interaction
-   * interaction.respond([
-   *  {
-   *    name: 'Option 1',
-   *    value: 'option1',
-   *  },
-   * ])
-   *  .then(() => console.log('Successfully responded to the autocomplete interaction'))
-   *  .catch(console.error);
-   */
+  
   async respond(options) {
     if (this.responded) throw new DiscordjsError(ErrorCodes.InteractionAlreadyReplied);
 

package/src/structures/Base.js

@@ -2,18 +2,10 @@
 
 const { flatten } = require('../util/Util');
 
-/**
- * Represents a data model that is identifiable by a Snowflake (i.e. Discord API data models).
- * @abstract
- */
+
 class Base {
   constructor(client) {
-    /**
-     * The client that instantiated this
-     * @name Base#client
-     * @type {Client}
-     * @readonly
-     */
+    
     Object.defineProperty(this, 'client', { value: client });
   }
 

package/src/structures/BaseChannel.js

@@ -7,19 +7,12 @@ const Base = require('./Base');
 const ChannelFlagsBitField = require('../util/ChannelFlagsBitField');
 const { ThreadChannelTypes } = require('../util/Constants');
 
-/**
- * Represents any channel on Discord.
- * @extends {Base}
- * @abstract
- */
+
 class BaseChannel extends Base {
   constructor(client, data, immediatePatch = true) {
     super(client);
 
-    /**
-     * The type of the channel
-     * @type {ChannelType}
-     */
+    
     this.type = data.type;
 
     if (data && immediatePatch) this._patch(data);
@@ -27,122 +20,68 @@ class BaseChannel extends Base {
 
   _patch(data) {
     if ('flags' in data) {
-      /**
-       * The flags that are applied to the channel.
-       * <info>This is only `null` in a {@link PartialGroupDMChannel}. In all other cases, it is not `null`.</info>
-       * @type {?Readonly<ChannelFlagsBitField>}
-       */
+      
       this.flags = new ChannelFlagsBitField(data.flags).freeze();
     } else {
       this.flags ??= new ChannelFlagsBitField().freeze();
     }
 
-    /**
-     * The channel's id
-     * @type {Snowflake}
-     */
+    
     this.id = data.id;
   }
 
-  /**
-   * The timestamp the channel was created at
-   * @type {number}
-   * @readonly
-   */
+  
   get createdTimestamp() {
     return DiscordSnowflake.timestampFrom(this.id);
   }
 
-  /**
-   * The time the channel was created at
-   * @type {Date}
-   * @readonly
-   */
+  
   get createdAt() {
     return new Date(this.createdTimestamp);
   }
 
-  /**
-   * The URL to the channel
-   * @type {string}
-   * @readonly
-   */
+  
   get url() {
     return this.isDMBased() ? channelLink(this.id) : channelLink(this.id, this.guildId);
   }
 
-  /**
-   * Whether this Channel is a partial
-   * <info>This is always false outside of DM channels.</info>
-   * @type {boolean}
-   * @readonly
-   */
+  
   get partial() {
     return false;
   }
 
-  /**
-   * When concatenated with a string, this automatically returns the channel's mention instead of the Channel object.
-   * @returns {string}
-   * @example
-   * // Logs: Hello from <#123456789012345678>!
-   * console.log(`Hello from ${channel}!`);
-   */
+  
   toString() {
     return `<#${this.id}>`;
   }
 
-  /**
-   * Deletes this channel.
-   * @returns {Promise<BaseChannel>}
-   * @example
-   * // Delete the channel
-   * channel.delete()
-   *   .then(console.log)
-   *   .catch(console.error);
-   */
+  
   async delete() {
     await this.client.rest.delete(Routes.channel(this.id));
     return this;
   }
 
-  /**
-   * Fetches this channel.
-   * @param {boolean} [force=true] Whether to skip the cache check and request the API
-   * @returns {Promise<BaseChannel>}
-   */
+  
   fetch(force = true) {
     return this.client.channels.fetch(this.id, { force });
   }
 
-  /**
-   * Indicates whether this channel is a {@link ThreadChannel}.
-   * @returns {boolean}
-   */
+  
   isThread() {
     return ThreadChannelTypes.includes(this.type);
   }
 
-  /**
-   * Indicates whether this channel is {@link TextBasedChannels text-based}.
-   * @returns {boolean}
-   */
+  
   isTextBased() {
     return 'messages' in this;
   }
 
-  /**
-   * Indicates whether this channel is DM-based (either a {@link DMChannel} or a {@link PartialGroupDMChannel}).
-   * @returns {boolean}
-   */
+  
   isDMBased() {
     return [ChannelType.DM, ChannelType.GroupDM].includes(this.type);
   }
 
-  /**
-   * Indicates whether this channel is {@link BaseGuildVoiceChannel voice-based}.
-   * @returns {boolean}
-   */
+  
   isVoiceBased() {
     return 'bitrate' in this;
   }
@@ -154,7 +93,4 @@ class BaseChannel extends Base {
 
 exports.BaseChannel = BaseChannel;
 
-/**
- * @external APIChannel
- * @see {@link https://discord.com/developers/docs/resources/channel#channel-object}
- */
+

package/src/structures/BaseGuild.js

@@ -5,63 +5,35 @@ const { DiscordSnowflake } = require('@sapphire/snowflake');
 const { Routes, GuildFeature } = require('discord-api-types/v10');
 const Base = require('./Base');
 
-/**
- * The base class for {@link Guild}, {@link OAuth2Guild} and {@link InviteGuild}.
- * @extends {Base}
- * @abstract
- */
+
 class BaseGuild extends Base {
   constructor(client, data) {
     super(client);
 
-    /**
-     * The guild's id
-     * @type {Snowflake}
-     */
+    
     this.id = data.id;
 
-    /**
-     * The name of this guild
-     * @type {string}
-     */
+    
     this.name = data.name;
 
-    /**
-     * The icon hash of this guild
-     * @type {?string}
-     */
+    
     this.icon = data.icon;
 
-    /**
-     * An array of features available to this guild
-     * @type {GuildFeature[]}
-     */
+    
     this.features = data.features;
   }
 
-  /**
-   * The timestamp this guild was created at
-   * @type {number}
-   * @readonly
-   */
+  
   get createdTimestamp() {
     return DiscordSnowflake.timestampFrom(this.id);
   }
 
-  /**
-   * The time this guild was created at
-   * @type {Date}
-   * @readonly
-   */
+  
   get createdAt() {
     return new Date(this.createdTimestamp);
   }
 
-  /**
-   * The acronym that shows up in place of a guild icon
-   * @type {string}
-   * @readonly
-   */
+  
   get nameAcronym() {
     return this.name
       .replace(/'s /g, ' ')
@@ -69,37 +41,22 @@ class BaseGuild extends Base {
       .replace(/\s/g, '');
   }
 
-  /**
-   * Whether this guild is partnered
-   * @type {boolean}
-   * @readonly
-   */
+  
   get partnered() {
     return this.features.includes(GuildFeature.Partnered);
   }
 
-  /**
-   * Whether this guild is verified
-   * @type {boolean}
-   * @readonly
-   */
+  
   get verified() {
     return this.features.includes(GuildFeature.Verified);
   }
 
-  /**
-   * The URL to this guild's icon.
-   * @param {ImageURLOptions} [options={}] Options for the image URL
-   * @returns {?string}
-   */
+  
   iconURL(options = {}) {
     return this.icon && this.client.rest.cdn.icon(this.id, this.icon, options);
   }
 
-  /**
-   * Fetches this guild.
-   * @returns {Promise<Guild>}
-   */
+  
   async fetch() {
     const data = await this.client.rest.get(Routes.guild(this.id), {
       query: makeURLSearchParams({ with_counts: true }),
@@ -107,10 +64,7 @@ class BaseGuild extends Base {
     return this.client.guilds._add(data);
   }
 
-  /**
-   * When concatenated with a string, this automatically returns the guild's name instead of the Guild object.
-   * @returns {string}
-   */
+  
   toString() {
     return this.name;
   }

package/src/structures/BaseGuildEmoji.js

@@ -2,19 +2,12 @@
 
 const { Emoji } = require('./Emoji');
 
-/**
- * Parent class for {@link GuildEmoji} and {@link GuildPreviewEmoji}.
- * @extends {Emoji}
- * @abstract
- */
+
 class BaseGuildEmoji extends Emoji {
   constructor(client, data, guild) {
     super(client, data);
 
-    /**
-     * The guild this emoji is a part of
-     * @type {Guild|GuildPreview}
-     */
+    
     this.guild = guild;
 
     this.requiresColons = null;
@@ -28,26 +21,17 @@ class BaseGuildEmoji extends Emoji {
     if ('name' in data) this.name = data.name;
 
     if ('require_colons' in data) {
-      /**
-       * Whether or not this emoji requires colons surrounding it
-       * @type {?boolean}
-       */
+      
       this.requiresColons = data.require_colons;
     }
 
     if ('managed' in data) {
-      /**
-       * Whether this emoji is managed by an external service
-       * @type {?boolean}
-       */
+      
       this.managed = data.managed;
     }
 
     if ('available' in data) {
-      /**
-       * Whether this emoji is available
-       * @type {?boolean}
-       */
+      
       this.available = data.available;
     }
   }

package/src/structures/BaseGuildTextChannel.js

@@ -5,31 +5,18 @@ const TextBasedChannel = require('./interfaces/TextBasedChannel');
 const GuildTextThreadManager = require('../managers/GuildTextThreadManager');
 const MessageManager = require('../managers/MessageManager');
 
-/**
- * Represents a text-based guild channel on Discord.
- * @extends {GuildChannel}
- * @implements {TextBasedChannel}
- */
+
 class BaseGuildTextChannel 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);
 
-    /**
-     * A manager of the threads belonging to this channel
-     * @type {GuildTextThreadManager}
-     */
+    
     this.threads = new GuildTextThreadManager(this);
 
-    /**
-     * If the guild considers this channel NSFW
-     * @type {boolean}
-     */
+    
     this.nsfw = Boolean(data.nsfw);
 
     this._patch(data);
@@ -39,10 +26,7 @@ class BaseGuildTextChannel extends GuildChannel {
     super._patch(data);
 
     if ('topic' in data) {
-      /**
-       * The topic of the text channel
-       * @type {?string}
-       */
+      
       this.topic = data.topic;
     }
 
@@ -51,26 +35,17 @@ class BaseGuildTextChannel extends GuildChannel {
     }
 
     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 ('last_pin_timestamp' in data) {
-      /**
-       * The timestamp when the last pinned message was pinned, if there was one
-       * @type {?number}
-       */
+      
       this.lastPinTimestamp = data.last_pin_timestamp ? Date.parse(data.last_pin_timestamp) : null;
     }
 
     if ('default_auto_archive_duration' in data) {
-      /**
-       * The default auto archive duration for newly created threads in this channel
-       * @type {?ThreadAutoArchiveDuration}
-       */
+      
       this.defaultAutoArchiveDuration = data.default_auto_archive_duration;
     }
 
@@ -79,93 +54,37 @@ class BaseGuildTextChannel extends GuildChannel {
     }
   }
 
-  /**
-   * Sets the default auto archive duration for all newly created threads in this channel.
-   * @param {ThreadAutoArchiveDuration} defaultAutoArchiveDuration The new default auto archive duration
-   * @param {string} [reason] Reason for changing the channel's default auto archive duration
-   * @returns {Promise<TextChannel>}
-   */
+  
   setDefaultAutoArchiveDuration(defaultAutoArchiveDuration, reason) {
     return this.edit({ defaultAutoArchiveDuration, reason });
   }
 
-  /**
-   * Sets the type of this channel.
-   * <info>Only conversion between {@link TextChannel} and {@link NewsChannel} is supported.</info>
-   * @param {ChannelType.GuildText|ChannelType.GuildAnnouncement} type The new channel type
-   * @param {string} [reason] Reason for changing the channel's type
-   * @returns {Promise<GuildChannel>}
-   */
+  
   setType(type, reason) {
     return this.edit({ type, reason });
   }
 
-  /**
-   * Sets a new topic for the guild channel.
-   * @param {?string} topic The new topic for the guild channel
-   * @param {string} [reason] Reason for changing the guild channel's topic
-   * @returns {Promise<GuildChannel>}
-   * @example
-   * // Set a new channel topic
-   * channel.setTopic('needs more rate limiting')
-   *   .then(newChannel => console.log(`Channel's new topic is ${newChannel.topic}`))
-   *   .catch(console.error);
-   */
+  
   setTopic(topic, reason) {
     return this.edit({ topic, reason });
   }
 
-  /**
-   * Data that can be resolved to an Application. This can be:
-   * * An Application
-   * * An Activity with associated Application
-   * * A Snowflake
-   * @typedef {Application|Snowflake} ApplicationResolvable
-   */
-
-  /**
-   * Options used to create an invite to a guild channel.
-   * @typedef {Object} InviteCreateOptions
-   * @property {boolean} [temporary] Whether members that joined via the invite should be automatically
-   * kicked after 24 hours if they have not yet received a role
-   * @property {number} [maxAge] How long the invite should last (in seconds, 0 for forever)
-   * @property {number} [maxUses] Maximum number of uses
-   * @property {boolean} [unique] Create a unique invite, or use an existing one with similar settings
-   * @property {UserResolvable} [targetUser] The user whose stream to display for this invite,
-   * required if `targetType` is {@link InviteTargetType.Stream}, the user must be streaming in the channel
-   * @property {ApplicationResolvable} [targetApplication] The embedded application to open for this invite,
-   * required if `targetType` is {@link InviteTargetType.Stream}, the application must have the
-   * {@link InviteTargetType.EmbeddedApplication} flag
-   * @property {InviteTargetType} [targetType] The type of the target for this voice channel invite
-   * @property {string} [reason] The reason for creating the invite
-   */
-
-  /**
-   * Creates an invite to this guild channel.
-   * @param {InviteCreateOptions} [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 });
   }
 
-  // These are here only for documentation purposes - they are implemented by TextBasedChannel
-  /* eslint-disable no-empty-function */
+  
+  
   get lastMessage() {}
   get lastPinAt() {}
   send() {}