@velliajs/discord 1.0.2 → 1.0.4

package/src/managers/GuildChannelManager.js

@@ -18,10 +18,7 @@ const { setPosition } = require('../util/Util');
 
 let cacheWarningEmitted = false;
 
-/**
- * Manages API methods for GuildChannels and stores their cache.
- * @extends {CachedManager}
- */
+
 class GuildChannelManager extends CachedManager {
   constructor(guild, iterable) {
     super(guild.client, GuildChannel, iterable);
@@ -37,19 +34,11 @@ class GuildChannelManager extends CachedManager {
       );
     }
 
-    /**
-     * The guild this Manager belongs to
-     * @type {Guild}
-     */
+    
     this.guild = guild;
   }
 
-  /**
-   * The number of channels in this managers cache excluding thread channels
-   * that do not count towards a guild's maximum channels restriction.
-   * @type {number}
-   * @readonly
-   */
+  
   get channelCountWithoutThreads() {
     return this.cache.reduce((acc, channel) => {
       if (ThreadChannelTypes.includes(channel.type)) return acc;
@@ -57,11 +46,7 @@ class GuildChannelManager extends CachedManager {
     }, 0);
   }
 
-  /**
-   * The cache of this Manager
-   * @type {Collection<Snowflake, GuildChannel|ThreadChannel>}
-   * @name GuildChannelManager#cache
-   */
+  
 
   _add(channel) {
     const existing = this.cache.get(channel.id);
@@ -70,41 +55,21 @@ class GuildChannelManager extends CachedManager {
     return channel;
   }
 
-  /**
-   * Data that can be resolved to give a Guild Channel object. This can be:
-   * * A GuildChannel object
-   * * A ThreadChannel object
-   * * A Snowflake
-   * @typedef {GuildChannel|ThreadChannel|Snowflake} GuildChannelResolvable
-   */
-
-  /**
-   * Resolves a GuildChannelResolvable to a Channel object.
-   * @param {GuildChannelResolvable} channel The GuildChannel resolvable to resolve
-   * @returns {?(GuildChannel|ThreadChannel)}
-   */
+  
+
+  
   resolve(channel) {
     if (channel instanceof ThreadChannel) return super.resolve(channel.id);
     return super.resolve(channel);
   }
 
-  /**
-   * Resolves a GuildChannelResolvable to a channel id.
-   * @param {GuildChannelResolvable} channel The GuildChannel resolvable to resolve
-   * @returns {?Snowflake}
-   */
+  
   resolveId(channel) {
     if (channel instanceof ThreadChannel) return super.resolveId(channel.id);
     return super.resolveId(channel);
   }
 
-  /**
-   * Adds the target channel to a channel's followers.
-   * @param {NewsChannel|Snowflake} channel The channel to follow
-   * @param {TextChannelResolvable} targetChannel The channel where published announcements will be posted at
-   * @param {string} [reason] Reason for creating the webhook
-   * @returns {Promise<Snowflake>} Returns created target webhook id.
-   */
+  
   async addFollower(channel, targetChannel, reason) {
     const channelId = this.resolveId(channel);
     const targetChannelId = this.resolveId(targetChannel);
@@ -116,34 +81,9 @@ class GuildChannelManager extends CachedManager {
     return webhook_id;
   }
 
-  /**
-   * Options used to create a new channel in a guild.
-   * @typedef {CategoryCreateChannelOptions} GuildChannelCreateOptions
-   * @property {?CategoryChannelResolvable} [parent] Parent of the new channel
-   */
-
-  /**
-   * Creates a new channel in the guild.
-   * @param {GuildChannelCreateOptions} options Options for creating the new channel
-   * @returns {Promise<GuildChannel>}
-   * @example
-   * // Create a new text channel
-   * guild.channels.create({ name: 'new-general', reason: 'Needed a cool new channel' })
-   *   .then(console.log)
-   *   .catch(console.error);
-   * @example
-   * // Create a new channel with permission overwrites
-   * guild.channels.create({
-   *   name: 'new-general',
-   *   type: ChannelType.GuildVoice,
-   *   permissionOverwrites: [
-   *      {
-   *        id: message.author.id,
-   *        deny: [PermissionFlagsBits.ViewChannel],
-   *     },
-   *   ],
-   * })
-   */
+  
+
+  
   async create({
     name,
     type,
@@ -192,27 +132,9 @@ class GuildChannelManager extends CachedManager {
     return this.client.actions.ChannelCreate.handle(data).channel;
   }
 
-  /**
-   * @typedef {ChannelWebhookCreateOptions} WebhookCreateOptions
-   * @property {TextChannel|NewsChannel|VoiceChannel|StageChannel|ForumChannel|Snowflake} channel
-   * The channel to create the webhook for
-   */
-
-  /**
-   * Creates a webhook for the channel.
-   * @param {WebhookCreateOptions} options Options for creating the webhook
-   * @returns {Promise<Webhook>} Returns the created Webhook
-   * @example
-   * // Create a webhook for the current channel
-   * guild.channels.createWebhook({
-   *   channel: '222197033908436994',
-   *   name: 'Snek',
-   *   avatar: 'https://i.imgur.com/mI8XcpG.jpg',
-   *   reason: 'Needed a cool new Webhook'
-   * })
-   *   .then(console.log)
-   *   .catch(console.error)
-   */
+  
+
+  
   async createWebhook({ channel, name, avatar, reason }) {
     const id = this.resolveId(channel);
     if (!id) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'channel', 'GuildChannelResolvable');
@@ -229,46 +151,9 @@ class GuildChannelManager extends CachedManager {
     return new Webhook(this.client, data);
   }
 
-  /**
-   * Options used to edit a guild channel.
-   * @typedef {Object} GuildChannelEditOptions
-   * @property {string} [name] The name of the channel
-   * @property {ChannelType} [type] The type of the channel (only conversion between text and news is supported)
-   * @property {number} [position] The position of the channel
-   * @property {?string} [topic] The topic of the text channel
-   * @property {boolean} [nsfw] Whether the channel is NSFW
-   * @property {number} [bitrate] The bitrate of the voice channel
-   * @property {number} [userLimit] The user limit of the voice channel
-   * @property {?CategoryChannelResolvable} [parent] The parent of the channel
-   * @property {boolean} [lockPermissions]
-   * Lock the permissions of the channel to what the parent's permissions are
-   * @property {OverwriteResolvable[]|Collection<Snowflake, OverwriteResolvable>} [permissionOverwrites]
-   * Permission overwrites for the channel
-   * @property {number} [rateLimitPerUser] The rate limit per user (slowmode) for the channel in seconds
-   * @property {ThreadAutoArchiveDuration} [defaultAutoArchiveDuration]
-   * The default auto archive duration for all new threads in this channel
-   * @property {?string} [rtcRegion] The RTC region of the channel
-   * @property {?VideoQualityMode} [videoQualityMode] The camera video quality mode of the channel
-   * @property {GuildForumTagData[]} [availableTags] The tags to set as available in a forum channel
-   * @property {?DefaultReactionEmoji} [defaultReactionEmoji] The emoji to set as the default reaction emoji
-   * @property {number} [defaultThreadRateLimitPerUser] The rate limit per user (slowmode) to set on forum posts
-   * @property {ChannelFlagsResolvable} [flags] The flags to set on the channel
-   * @property {?SortOrderType} [defaultSortOrder] The default sort order mode to set on the channel
-   * @property {ForumLayoutType} [defaultForumLayout] The default forum layout to set on the channel
-   * @property {string} [reason] Reason for editing this channel
-   */
-
-  /**
-   * Edits the channel.
-   * @param {GuildChannelResolvable} channel The channel to edit
-   * @param {GuildChannelEditOptions} options Options for editing the channel
-   * @returns {Promise<GuildChannel>}
-   * @example
-   * // Edit a channel
-   * guild.channels.edit('222197033908436994', { name: 'new-channel' })
-   *   .then(console.log)
-   *   .catch(console.error);
-   */
+  
+
+  
   async edit(channel, options) {
     channel = this.resolve(channel);
     if (!channel) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'channel', 'GuildChannelResolvable');
@@ -325,18 +210,7 @@ class GuildChannelManager extends CachedManager {
     return this.client.actions.ChannelUpdate.handle(newData).updated;
   }
 
-  /**
-   * Sets a new position for the guild channel.
-   * @param {GuildChannelResolvable} channel The channel to set the position for
-   * @param {number} position The new position for the guild channel
-   * @param {SetChannelPositionOptions} options Options for setting position
-   * @returns {Promise<GuildChannel>}
-   * @example
-   * // Set a new channel position
-   * guild.channels.setPosition('222078374472843266', 2)
-   *   .then(newChannel => console.log(`Channel's new position is ${newChannel.position}`))
-   *   .catch(console.error);
-   */
+  
   async setPosition(channel, position, { relative, reason } = {}) {
     channel = this.resolve(channel);
     if (!channel) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'channel', 'GuildChannelResolvable');
@@ -357,22 +231,7 @@ class GuildChannelManager extends CachedManager {
     return channel;
   }
 
-  /**
-   * Obtains one or more guild channels from Discord, or the channel cache if they're already available.
-   * @param {Snowflake} [id] The channel's id
-   * @param {BaseFetchOptions} [options] Additional options for this fetch
-   * @returns {Promise<?GuildChannel|ThreadChannel|Collection<Snowflake, ?GuildChannel>>}
-   * @example
-   * // Fetch all channels from the guild (excluding threads)
-   * message.guild.channels.fetch()
-   *   .then(channels => console.log(`There are ${channels.size} channels.`))
-   *   .catch(console.error);
-   * @example
-   * // Fetch a single channel
-   * message.guild.channels.fetch('222197033908436994')
-   *   .then(channel => console.log(`The channel name is: ${channel.name}`))
-   *   .catch(console.error);
-   */
+  
   async fetch(id, { cache = true, force = false } = {}) {
     if (id && !force) {
       const existing = this.cache.get(id);
@@ -381,7 +240,7 @@ class GuildChannelManager extends CachedManager {
 
     if (id) {
       const data = await this.client.rest.get(Routes.channel(id));
-      // Since this is the guild manager, throw if on a different guild
+      
       if (this.guild.id !== data.guild_id) throw new DiscordjsError(ErrorCodes.GuildChannelUnowned);
       return this.client.channels._add(data, this.guild, { cache });
     }
@@ -392,16 +251,7 @@ class GuildChannelManager extends CachedManager {
     return channels;
   }
 
-  /**
-   * Fetches all webhooks for the channel.
-   * @param {GuildChannelResolvable} channel The channel to fetch webhooks for
-   * @returns {Promise<Collection<Snowflake, Webhook>>}
-   * @example
-   * // Fetch webhooks
-   * guild.channels.fetchWebhooks('769862166131245066')
-   *   .then(hooks => console.log(`This channel has ${hooks.size} hooks`))
-   *   .catch(console.error);
-   */
+  
   async fetchWebhooks(channel) {
     const id = this.resolveId(channel);
     if (!id) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'channel', 'GuildChannelResolvable');
@@ -409,32 +259,11 @@ class GuildChannelManager extends CachedManager {
     return data.reduce((hooks, hook) => hooks.set(hook.id, new Webhook(this.client, hook)), new Collection());
   }
 
-  /**
-   * Data that can be resolved to give a Category Channel object. This can be:
-   * * A CategoryChannel object
-   * * A Snowflake
-   * @typedef {CategoryChannel|Snowflake} CategoryChannelResolvable
-   */
-
-  /**
-   * The data needed for updating a channel's position.
-   * @typedef {Object} ChannelPosition
-   * @property {GuildChannel|Snowflake} channel Channel to update
-   * @property {number} [position] New position for the channel
-   * @property {CategoryChannelResolvable} [parent] Parent channel for this channel
-   * @property {boolean} [lockPermissions] If the overwrites should be locked to the parents overwrites
-   */
-
-  /**
-   * Batch-updates the guild's channels' positions.
-   * <info>Only one channel's parent can be changed at a time</info>
-   * @param {ChannelPosition[]} channelPositions Channel positions to update
-   * @returns {Promise<Guild>}
-   * @example
-   * guild.channels.setPositions([{ channel: channelId, position: newChannelIndex }])
-   *   .then(guild => console.log(`Updated channel positions for ${guild}`))
-   *   .catch(console.error);
-   */
+  
+
+  
+
+  
   async setPositions(channelPositions) {
     channelPositions = channelPositions.map(r => ({
       id: this.client.channels.resolveId(r.channel),
@@ -450,39 +279,15 @@ class GuildChannelManager extends CachedManager {
     }).guild;
   }
 
-  /**
-   * Data returned from fetching threads.
-   * @typedef {Object} FetchedThreads
-   * @property {Collection<Snowflake, ThreadChannel>} threads The threads that were fetched
-   * @property {Collection<Snowflake, ThreadMember>} members The thread members in the received threads
-   */
-
-  /**
-   * Obtains all active thread channels in the guild.
-   * @param {boolean} [cache=true] Whether to cache the fetched data
-   * @returns {Promise<FetchedThreads>}
-   * @example
-   * // Fetch all threads from the guild
-   * message.guild.channels.fetchActiveThreads()
-   *   .then(fetched => console.log(`There are ${fetched.threads.size} threads.`))
-   *   .catch(console.error);
-   */
+  
+
+  
   async fetchActiveThreads(cache = true) {
     const raw = await this.client.rest.get(Routes.guildActiveThreads(this.guild.id));
     return GuildTextThreadManager._mapThreads(raw, this.client, { guild: this.guild, cache });
   }
 
-  /**
-   * Deletes the channel.
-   * @param {GuildChannelResolvable} channel The channel to delete
-   * @param {string} [reason] Reason for deleting this channel
-   * @returns {Promise<void>}
-   * @example
-   * // Delete the channel
-   * guild.channels.delete('858850993013260338', 'making room for new channels')
-   *   .then(console.log)
-   *   .catch(console.error);
-   */
+  
   async delete(channel, reason) {
     const id = this.resolveId(channel);
     if (!id) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'channel', 'GuildChannelResolvable');

package/src/managers/GuildEmojiManager.js

@@ -6,18 +6,12 @@ const BaseGuildEmojiManager = require('./BaseGuildEmojiManager');
 const { DiscordjsError, DiscordjsTypeError, ErrorCodes } = require('../errors');
 const DataResolver = require('../util/DataResolver');
 
-/**
- * Manages API methods for GuildEmojis and stores their cache.
- * @extends {BaseGuildEmojiManager}
- */
+
 class GuildEmojiManager extends BaseGuildEmojiManager {
   constructor(guild, iterable) {
     super(guild.client, iterable);
 
-    /**
-     * The guild this manager belongs to
-     * @type {Guild}
-     */
+    
     this.guild = guild;
   }
 
@@ -25,30 +19,9 @@ class GuildEmojiManager extends BaseGuildEmojiManager {
     return super._add(data, cache, { extras: [this.guild] });
   }
 
-  /**
-   * Options used for creating an emoji in a guild.
-   * @typedef {Object} GuildEmojiCreateOptions
-   * @property {BufferResolvable|Base64Resolvable} attachment The image for the emoji
-   * @property {string} name The name for the emoji
-   * @property {Collection<Snowflake, Role>|RoleResolvable[]} [roles] The roles to limit the emoji to
-   * @property {string} [reason] The reason for creating the emoji
-   */
-
-  /**
-   * Creates a new custom emoji in the guild.
-   * @param {GuildEmojiCreateOptions} options Options for creating the emoji
-   * @returns {Promise<Emoji>} The created emoji
-   * @example
-   * // Create a new emoji from a URL
-   * guild.emojis.create({ attachment: 'https://i.imgur.com/w3duR07.png', name: 'rip' })
-   *   .then(emoji => console.log(`Created new emoji with name ${emoji.name}!`))
-   *   .catch(console.error);
-   * @example
-   * // Create a new emoji from a file on your computer
-   * guild.emojis.create({ attachment: './memes/banana.png', name: 'banana' })
-   *   .then(emoji => console.log(`Created new emoji with name ${emoji.name}!`))
-   *   .catch(console.error);
-   */
+  
+
+  
   async create({ attachment, name, roles, reason }) {
     attachment = await DataResolver.resolveImage(attachment);
     if (!attachment) throw new DiscordjsTypeError(ErrorCodes.ReqResourceType);
@@ -77,22 +50,7 @@ class GuildEmojiManager extends BaseGuildEmojiManager {
     return this.client.actions.GuildEmojiCreate.handle(this.guild, emoji).emoji;
   }
 
-  /**
-   * Obtains one or more emojis from Discord, or the emoji cache if they're already available.
-   * @param {Snowflake} [id] The emoji's id
-   * @param {BaseFetchOptions} [options] Additional options for this fetch
-   * @returns {Promise<GuildEmoji|Collection<Snowflake, GuildEmoji>>}
-   * @example
-   * // Fetch all emojis from the guild
-   * message.guild.emojis.fetch()
-   *   .then(emojis => console.log(`There are ${emojis.size} emojis.`))
-   *   .catch(console.error);
-   * @example
-   * // Fetch a single emoji
-   * message.guild.emojis.fetch('222078108977594368')
-   *   .then(emoji => console.log(`The emoji name is: ${emoji.name}`))
-   *   .catch(console.error);
-   */
+  
   async fetch(id, { cache = true, force = false } = {}) {
     if (id) {
       if (!force) {
@@ -109,24 +67,14 @@ class GuildEmojiManager extends BaseGuildEmojiManager {
     return emojis;
   }
 
-  /**
-   * Deletes an emoji.
-   * @param {EmojiResolvable} emoji The Emoji resolvable to delete
-   * @param {string} [reason] Reason for deleting the emoji
-   * @returns {Promise<void>}
-   */
+  
   async delete(emoji, reason) {
     const id = this.resolveId(emoji);
     if (!id) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'emoji', 'EmojiResolvable', true);
     await this.client.rest.delete(Routes.guildEmoji(this.guild.id, id), { reason });
   }
 
-  /**
-   * Edits an emoji.
-   * @param {EmojiResolvable} emoji The Emoji resolvable to edit
-   * @param {GuildEmojiEditOptions} options The options to provide
-   * @returns {Promise<GuildEmoji>}
-   */
+  
   async edit(emoji, options) {
     const id = this.resolveId(emoji);
     if (!id) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'emoji', 'EmojiResolvable', true);
@@ -147,11 +95,7 @@ class GuildEmojiManager extends BaseGuildEmojiManager {
     return this._add(newData);
   }
 
-  /**
-   * Fetches the author for this emoji
-   * @param {EmojiResolvable} emoji The emoji to fetch the author of
-   * @returns {Promise<User>}
-   */
+  
   async fetchAuthor(emoji) {
     emoji = this.resolve(emoji);
     if (!emoji) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'emoji', 'EmojiResolvable', true);

package/src/managers/GuildEmojiRoleManager.js

@@ -5,40 +5,23 @@ const DataManager = require('./DataManager');
 const { DiscordjsTypeError, ErrorCodes } = require('../errors');
 const { Role } = require('../structures/Role');
 
-/**
- * Manages API methods for roles belonging to emojis and stores their cache.
- * @extends {DataManager}
- */
+
 class GuildEmojiRoleManager extends DataManager {
   constructor(emoji) {
     super(emoji.client, Role);
 
-    /**
-     * The emoji belonging to this manager
-     * @type {GuildEmoji}
-     */
+    
     this.emoji = emoji;
-    /**
-     * The guild belonging to this manager
-     * @type {Guild}
-     */
+    
     this.guild = emoji.guild;
   }
 
-  /**
-   * The cache of roles belonging to this emoji
-   * @type {Collection<Snowflake, Role>}
-   * @readonly
-   */
+  
   get cache() {
     return this.guild.roles.cache.filter(role => this.emoji._roles.includes(role.id));
   }
 
-  /**
-   * Adds a role (or multiple roles) to the list of roles that can use this emoji.
-   * @param {RoleResolvable|RoleResolvable[]|Collection<Snowflake, Role>} roleOrRoles The role or roles to add
-   * @returns {Promise<GuildEmoji>}
-   */
+  
   add(roleOrRoles) {
     if (!Array.isArray(roleOrRoles) && !(roleOrRoles instanceof Collection)) roleOrRoles = [roleOrRoles];
 
@@ -55,11 +38,7 @@ class GuildEmojiRoleManager extends DataManager {
     return this.set(newRoles);
   }
 
-  /**
-   * Removes a role (or multiple roles) from the list of roles that can use this emoji.
-   * @param {RoleResolvable|RoleResolvable[]|Collection<Snowflake, Role>} roleOrRoles The role or roles to remove
-   * @returns {Promise<GuildEmoji>}
-   */
+  
   remove(roleOrRoles) {
     if (!Array.isArray(roleOrRoles) && !(roleOrRoles instanceof Collection)) roleOrRoles = [roleOrRoles];
 
@@ -76,21 +55,7 @@ class GuildEmojiRoleManager extends DataManager {
     return this.set(newRoles);
   }
 
-  /**
-   * Sets the role(s) that can use this emoji.
-   * @param {Collection<Snowflake, Role>|RoleResolvable[]} roles The roles or role ids to apply
-   * @returns {Promise<GuildEmoji>}
-   * @example
-   * // Set the emoji's roles to a single role
-   * guildEmoji.roles.set(['391156570408615936'])
-   *   .then(console.log)
-   *   .catch(console.error);
-   * @example
-   * // Remove all roles from an emoji
-   * guildEmoji.roles.set([])
-   *    .then(console.log)
-   *    .catch(console.error);
-   */
+  
   set(roles) {
     return this.emoji.edit({ roles });
   }
@@ -101,11 +66,7 @@ class GuildEmojiRoleManager extends DataManager {
     return clone;
   }
 
-  /**
-   * Patches the roles for this manager's cache
-   * @param {Snowflake[]} roles The new roles
-   * @private
-   */
+  
   _patch(roles) {
     this.emoji._roles = roles;
   }

package/src/managers/GuildForumThreadManager.js

@@ -5,49 +5,15 @@ const ThreadManager = require('./ThreadManager');
 const { DiscordjsTypeError, ErrorCodes } = require('../errors');
 const MessagePayload = require('../structures/MessagePayload');
 
-/**
- * Manages API methods for threads in forum channels and stores their cache.
- * @extends {ThreadManager}
- */
+
 class GuildForumThreadManager extends ThreadManager {
-  /**
-   * The channel this Manager belongs to
-   * @name GuildForumThreadManager#channel
-   * @type {ForumChannel}
-   */
+  
 
-  /**
-   * @typedef {BaseMessageOptions} GuildForumThreadMessageCreateOptions
-   * @property {StickerResolvable} [stickers] The stickers to send with the message
-   * @property {BitFieldResolvable} [flags] The flags to send with the message
-   * <info>Only `MessageFlags.SuppressEmbeds` and `MessageFlags.SuppressNotifications` can be set.</info>
-   */
+  
 
-  /**
-   * Options for creating a thread.
-   * @typedef {StartThreadOptions} GuildForumThreadCreateOptions
-   * @property {GuildForumThreadMessageCreateOptions|MessagePayload} message The message associated with the thread post
-   * @property {Snowflake[]} [appliedTags] The tags to apply to the thread
-   */
+  
 
-  /**
-   * Creates a new thread in the channel.
-   * @param {GuildForumThreadCreateOptions} [options] Options to create a new thread
-   * @returns {Promise<ThreadChannel>}
-   * @example
-   * // Create a new forum post
-   * forum.threads
-   *   .create({
-   *     name: 'Food Talk',
-   *     autoArchiveDuration: ThreadAutoArchiveDuration.OneHour,
-   *     message: {
-   *      content: 'Discuss your favorite food!',
-   *     },
-   *     reason: 'Needed a separate thread for food',
-   *   })
-   *   .then(threadChannel => console.log(threadChannel))
-   *   .catch(console.error);
-   */
+  
   async create({
     name,
     autoArchiveDuration = this.channel.defaultAutoArchiveDuration,