@velliajs/discord 1.0.2 → 1.0.4

package/src/structures/Webhook.js

@@ -10,35 +10,21 @@ const DataResolver = require('../util/DataResolver');
 
 const getMessage = lazy(() => require('./Message').Message);
 
-/**
- * Represents a webhook.
- */
+
 class Webhook {
   constructor(client, data) {
-    /**
-     * The client that instantiated the webhook
-     * @name Webhook#client
-     * @type {Client}
-     * @readonly
-     */
+    
     Object.defineProperty(this, 'client', { value: client });
     if (data) this._patch(data);
   }
 
   _patch(data) {
     if ('name' in data) {
-      /**
-       * The name of the webhook
-       * @type {string}
-       */
+      
       this.name = data.name;
     }
 
-    /**
-     * The token for the webhook, unavailable for follower webhooks and webhooks owned by another application.
-     * @name Webhook#token
-     * @type {?string}
-     */
+    
     Object.defineProperty(this, 'token', {
       value: data.token ?? null,
       writable: true,
@@ -46,162 +32,67 @@ class Webhook {
     });
 
     if ('avatar' in data) {
-      /**
-       * The avatar for the webhook
-       * @type {?string}
-       */
+      
       this.avatar = data.avatar;
     }
 
-    /**
-     * The webhook's id
-     * @type {Snowflake}
-     */
+    
     this.id = data.id;
 
     if ('type' in data) {
-      /**
-       * The type of the webhook
-       * @type {WebhookType}
-       */
+      
       this.type = data.type;
     }
 
     if ('guild_id' in data) {
-      /**
-       * The guild the webhook belongs to
-       * @type {Snowflake}
-       */
+      
       this.guildId = data.guild_id;
     }
 
     if ('channel_id' in data) {
-      /**
-       * The id of the channel the webhook belongs to
-       * @type {Snowflake}
-       */
+      
       this.channelId = data.channel_id;
     }
 
     if ('user' in data) {
-      /**
-       * The owner of the webhook
-       * @type {?(User|APIUser)}
-       */
+      
       this.owner = this.client.users?._add(data.user) ?? data.user;
     } else {
       this.owner ??= null;
     }
 
     if ('application_id' in data) {
-      /**
-       * The application that created this webhook
-       * @type {?Snowflake}
-       */
+      
       this.applicationId = data.application_id;
     } else {
       this.applicationId ??= null;
     }
 
     if ('source_guild' in data) {
-      /**
-       * The source guild of the webhook
-       * @type {?(Guild|APIGuild)}
-       */
+      
       this.sourceGuild = this.client.guilds?.resolve(data.source_guild.id) ?? data.source_guild;
     } else {
       this.sourceGuild ??= null;
     }
 
     if ('source_channel' in data) {
-      /**
-       * The source channel of the webhook
-       * @type {?(NewsChannel|APIChannel)}
-       */
+      
       this.sourceChannel = this.client.channels?.resolve(data.source_channel?.id) ?? data.source_channel;
     } else {
       this.sourceChannel ??= null;
     }
   }
 
-  /**
-   * Options that can be passed into send.
-   * @typedef {BaseMessageOptions} WebhookMessageCreateOptions
-   * @property {boolean} [tts=false] Whether the message should be spoken aloud
-   * @property {MessageFlags} [flags] Which flags to set for the message.
-   * <info>Only the {@link MessageFlags.SuppressEmbeds} flag can be set.</info>
-   * @property {string} [username=this.name] Username override for the message
-   * @property {string} [avatarURL] Avatar URL override for the message
-   * @property {Snowflake} [threadId] The id of the thread in the channel to send to.
-   * <info>For interaction webhooks, this property is ignored</info>
-   * @property {string} [threadName] Name of the thread to create (only available if webhook is in a forum channel)
-   */
-
-  /**
-   * Options that can be passed into editMessage.
-   * @typedef {BaseMessageOptions} WebhookMessageEditOptions
-   * @property {Attachment[]} [attachments] Attachments to send with the message
-   * @property {Snowflake} [threadId] The id of the thread this message belongs to
-   * <info>For interaction webhooks, this property is ignored</info>
-   */
-
-  /**
-   * The channel the webhook belongs to
-   * @type {?(TextChannel|VoiceChannel|StageChannel|NewsChannel|ForumChannel)}
-   * @readonly
-   */
+  
+
+  
+
+  
   get channel() {
     return this.client.channels.resolve(this.channelId);
   }
 
-  /**
-   * Sends a message with this webhook.
-   * @param {string|MessagePayload|WebhookMessageCreateOptions} options The options to provide
-   * @returns {Promise<Message>}
-   * @example
-   * // Send a basic message
-   * webhook.send('hello!')
-   *   .then(message => console.log(`Sent message: ${message.content}`))
-   *   .catch(console.error);
-   * @example
-   * // Send a basic message in a thread
-   * webhook.send({ content: 'hello!', threadId: '836856309672348295' })
-   *   .then(message => console.log(`Sent message: ${message.content}`))
-   *   .catch(console.error);
-   * @example
-   * // Send a remote file
-   * webhook.send({
-   *   files: ['https://cdn.discordapp.com/icons/222078108977594368/6e1019b3179d71046e463a75915e7244.png?size=2048']
-   * })
-   *   .then(console.log)
-   *   .catch(console.error);
-   * @example
-   * // Send a local file
-   * webhook.send({
-   *   files: [{
-   *     attachment: 'entire/path/to/file.jpg',
-   *     name: 'file.jpg'
-   *   }]
-   * })
-   *   .then(console.log)
-   *   .catch(console.error);
-   * @example
-   * // Send an embed with a local image inside
-   * webhook.send({
-   *   content: 'This is an embed',
-   *   embeds: [{
-   *     thumbnail: {
-   *          url: 'attachment://file.jpg'
-   *       }
-   *    }],
-   *    files: [{
-   *       attachment: 'entire/path/to/file.jpg',
-   *       name: 'file.jpg'
-   *    }]
-   * })
-   *   .then(console.log)
-   *   .catch(console.error);
-   */
+  
   async send(options) {
     if (!this.token) throw new DiscordjsError(ErrorCodes.WebhookTokenUnavailable);
 
@@ -230,24 +121,7 @@ class Webhook {
     return this.client.channels.cache.get(d.channel_id)?.messages._add(d, false) ?? new (getMessage())(this.client, d);
   }
 
-  /**
-   * Sends a raw slack message with this webhook.
-   * @param {Object} body The raw body to send
-   * @returns {Promise<boolean>}
-   * @example
-   * // Send a slack message
-   * webhook.sendSlackMessage({
-   *   'username': 'Wumpus',
-   *   'attachments': [{
-   *     'pretext': 'this looks pretty cool',
-   *     'color': '#F0F',
-   *     'footer_icon': 'http://snek.s3.amazonaws.com/topSnek.png',
-   *     'footer': 'Powered by sneks',
-   *     'ts': Date.now() / 1_000
-   *   }]
-   * }).catch(console.error);
-   * @see {@link https://api.slack.com/messaging/webhooks}
-   */
+  
   async sendSlackMessage(body) {
     if (!this.token) throw new DiscordjsError(ErrorCodes.WebhookTokenUnavailable);
 
@@ -259,20 +133,9 @@ class Webhook {
     return data.toString() === 'ok';
   }
 
-  /**
-   * Options used to edit a {@link Webhook}.
-   * @typedef {Object} WebhookEditOptions
-   * @property {string} [name=this.name] The new name for the webhook
-   * @property {?(BufferResolvable)} [avatar] The new avatar for the webhook
-   * @property {GuildTextChannelResolvable} [channel] The new channel for the webhook
-   * @property {string} [reason] Reason for editing the webhook
-   */
-
-  /**
-   * Edits this webhook.
-   * @param {WebhookEditOptions} options Options for editing the webhook
-   * @returns {Promise<Webhook>}
-   */
+  
+
+  
   async edit({ name = this.name, avatar, channel, reason }) {
     if (avatar && !(typeof avatar === 'string' && avatar.startsWith('data:'))) {
       avatar = await DataResolver.resolveImage(avatar);
@@ -290,20 +153,9 @@ class Webhook {
     return this;
   }
 
-  /**
-   * Options that can be passed into fetchMessage.
-   * @typedef {options} WebhookFetchMessageOptions
-   * @property {boolean} [cache=true] Whether to cache the message.
-   * @property {Snowflake} [threadId] The id of the thread this message belongs to.
-   * <info>For interaction webhooks, this property is ignored</info>
-   */
-
-  /**
-   * Gets a message that was sent by this webhook.
-   * @param {Snowflake|'@original'} message The id of the message to fetch
-   * @param {WebhookFetchMessageOptions} [options={}] The options to provide to fetch the message.
-   * @returns {Promise<Message>} Returns the message sent by this webhook
-   */
+  
+
+  
   async fetchMessage(message, { threadId } = {}) {
     if (!this.token) throw new DiscordjsError(ErrorCodes.WebhookTokenUnavailable);
 
@@ -319,12 +171,7 @@ class Webhook {
     );
   }
 
-  /**
-   * 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
-   */
+  
   async editMessage(message, options) {
     if (!this.token) throw new DiscordjsError(ErrorCodes.WebhookTokenUnavailable);
 
@@ -361,11 +208,7 @@ class Webhook {
     return clone;
   }
 
-  /**
-   * Deletes the webhook.
-   * @param {string} [reason] Reason for deleting this webhook
-   * @returns {Promise<void>}
-   */
+  
   async delete(reason) {
     await this.client.rest.delete(Routes.webhook(this.id, this.token), {
       reason,
@@ -373,12 +216,7 @@ class Webhook {
     });
   }
 
-  /**
-   * Delete a message that was sent by this webhook.
-   * @param {MessageResolvable|'@original'} message The message to delete
-   * @param {Snowflake} [threadId] The id of the thread this message belongs to
-   * @returns {Promise<void>}
-   */
+  
   async deleteMessage(message, threadId) {
     if (!this.token) throw new DiscordjsError(ErrorCodes.WebhookTokenUnavailable);
 
@@ -391,70 +229,42 @@ class Webhook {
     );
   }
 
-  /**
-   * The timestamp the webhook was created at
-   * @type {number}
-   * @readonly
-   */
+  
   get createdTimestamp() {
     return DiscordSnowflake.timestampFrom(this.id);
   }
 
-  /**
-   * The time the webhook was created at
-   * @type {Date}
-   * @readonly
-   */
+  
   get createdAt() {
     return new Date(this.createdTimestamp);
   }
 
-  /**
-   * The URL of this webhook
-   * @type {string}
-   * @readonly
-   */
+  
   get url() {
     return this.client.options.rest.api + Routes.webhook(this.id, this.token);
   }
 
-  /**
-   * A link to the webhook's avatar.
-   * @param {ImageURLOptions} [options={}] Options for the image URL
-   * @returns {?string}
-   */
+  
   avatarURL(options = {}) {
     return this.avatar && this.client.rest.cdn.avatar(this.id, this.avatar, options);
   }
 
-  /**
-   * Whether this webhook is created by a user.
-   * @returns {boolean}
-   */
+  
   isUserCreated() {
     return Boolean(this.type === WebhookType.Incoming && this.owner && !this.owner.bot);
   }
 
-  /**
-   * Whether this webhook is created by an application.
-   * @returns {boolean}
-   */
+  
   isApplicationCreated() {
     return this.type === WebhookType.Application;
   }
 
-  /**
-   * Whether or not this webhook is a channel follower webhook.
-   * @returns {boolean}
-   */
+  
   isChannelFollower() {
     return this.type === WebhookType.ChannelFollower;
   }
 
-  /**
-   * Whether or not this webhook is an incoming webhook.
-   * @returns {boolean}
-   */
+  
   isIncoming() {
     return this.type === WebhookType.Incoming;
   }

package/src/structures/WelcomeChannel.js

@@ -3,55 +3,33 @@
 const Base = require('./Base');
 const { Emoji } = require('./Emoji');
 
-/**
- * Represents a channel link in a guild's welcome screen.
- * @extends {Base}
- */
+
 class WelcomeChannel extends Base {
   constructor(guild, data) {
     super(guild.client);
 
-    /**
-     * The guild for this welcome channel
-     * @type {Guild|InviteGuild}
-     */
+    
     this.guild = guild;
 
-    /**
-     * The description of this welcome channel
-     * @type {string}
-     */
+    
     this.description = data.description;
 
-    /**
-     * The raw emoji data
-     * @type {Object}
-     * @private
-     */
+    
     this._emoji = {
       name: data.emoji_name,
       id: data.emoji_id,
     };
 
-    /**
-     * The id of this welcome channel
-     * @type {Snowflake}
-     */
+    
     this.channelId = data.channel_id;
   }
 
-  /**
-   * The channel of this welcome channel
-   * @type {?(TextChannel|NewsChannel|ForumChannel)}
-   */
+  
   get channel() {
     return this.client.channels.resolve(this.channelId);
   }
 
-  /**
-   * The emoji of this welcome channel
-   * @type {GuildEmoji|Emoji}
-   */
+  
   get emoji() {
     return this.client.emojis.resolve(this._emoji.id) ?? new Emoji(this.client, this._emoji);
   }

package/src/structures/WelcomeScreen.js

@@ -5,30 +5,18 @@ const { GuildFeature } = require('discord-api-types/v10');
 const Base = require('./Base');
 const WelcomeChannel = require('./WelcomeChannel');
 
-/**
- * Represents a welcome screen.
- * @extends {Base}
- */
+
 class WelcomeScreen extends Base {
   constructor(guild, data) {
     super(guild.client);
 
-    /**
-     * The guild for this welcome screen
-     * @type {Guild}
-     */
+    
     this.guild = guild;
 
-    /**
-     * The description of this welcome screen
-     * @type {?string}
-     */
+    
     this.description = data.description ?? null;
 
-    /**
-     * Collection of welcome channels belonging to this welcome screen
-     * @type {Collection<Snowflake, WelcomeChannel>}
-     */
+    
     this.welcomeChannels = new Collection();
 
     for (const channel of data.welcome_channels) {
@@ -37,10 +25,7 @@ class WelcomeScreen extends Base {
     }
   }
 
-  /**
-   * Whether the welcome screen is enabled on the guild
-   * @type {boolean}
-   */
+  
   get enabled() {
     return this.guild.features.includes(GuildFeature.WelcomeScreenEnabled);
   }

package/src/structures/Widget.js

@@ -5,79 +5,48 @@ const { Routes } = require('discord-api-types/v10');
 const Base = require('./Base');
 const WidgetMember = require('./WidgetMember');
 
-/**
- * Represents a Widget.
- * @extends {Base}
- */
+
 class Widget extends Base {
   constructor(client, data) {
     super(client);
     this._patch(data);
   }
 
-  /**
-   * Represents a channel in a Widget
-   * @typedef {Object} WidgetChannel
-   * @property {Snowflake} id Id of the channel
-   * @property {string} name Name of the channel
-   * @property {number} position Position of the channel
-   */
+  
 
   _patch(data) {
-    /**
-     * The id of the guild.
-     * @type {Snowflake}
-     */
+    
     this.id = data.id;
 
     if ('name' in data) {
-      /**
-       * The name of the guild.
-       * @type {string}
-       */
+      
       this.name = data.name;
     }
 
     if ('instant_invite' in data) {
-      /**
-       * The invite of the guild.
-       * @type {?string}
-       */
+      
       this.instantInvite = data.instant_invite;
     }
 
-    /**
-     * The list of channels in the guild.
-     * @type {Collection<Snowflake, WidgetChannel>}
-     */
+    
     this.channels = new Collection();
     for (const channel of data.channels) {
       this.channels.set(channel.id, channel);
     }
 
-    /**
-     * The list of members in the guild.
-     * These strings are just arbitrary numbers, they aren't Snowflakes.
-     * @type {Collection<string, WidgetMember>}
-     */
+    
     this.members = new Collection();
     for (const member of data.members) {
       this.members.set(member.id, new WidgetMember(this.client, member));
     }
 
     if ('presence_count' in data) {
-      /**
-       * The number of members online.
-       * @type {number}
-       */
+      
       this.presenceCount = data.presence_count;
     }
   }
 
-  /**
-   * Update the Widget.
-   * @returns {Promise<Widget>}
-   */
+  
   async fetch() {
     const data = await this.client.rest.get(Routes.guildWidgetJSON(this.id));
     this._patch(data);