@velliajs/discord 1.0.2 → 1.0.4

package/src/managers/PermissionOverwriteManager.js

@@ -10,10 +10,7 @@ const { Role } = require('../structures/Role');
 
 let cacheWarningEmitted = false;
 
-/**
- * Manages API methods for guild channel permission overwrites and stores their cache.
- * @extends {CachedManager}
- */
+
 class PermissionOverwriteManager extends CachedManager {
   constructor(channel, iterable) {
     super(channel.client, PermissionOverwrites);
@@ -25,10 +22,7 @@ class PermissionOverwriteManager extends CachedManager {
       );
     }
 
-    /**
-     * The channel of the permission overwrite this manager belongs to
-     * @type {GuildChannel}
-     */
+    
     this.channel = channel;
 
     if (iterable) {
@@ -38,30 +32,13 @@ class PermissionOverwriteManager extends CachedManager {
     }
   }
 
-  /**
-   * The cache of this Manager
-   * @type {Collection<Snowflake, PermissionOverwrites>}
-   * @name PermissionOverwriteManager#cache
-   */
+  
 
   _add(data, cache) {
     return super._add(data, cache, { extras: [this.channel] });
   }
 
-  /**
-   * Replaces the permission overwrites in this channel.
-   * @param {OverwriteResolvable[]|Collection<Snowflake, OverwriteResolvable>} overwrites
-   * Permission overwrites the channel gets updated with
-   * @param {string} [reason] Reason for updating the channel overwrites
-   * @returns {Promise<GuildChannel>}
-   * @example
-   * message.channel.permissionOverwrites.set([
-   *   {
-   *      id: message.author.id,
-   *      deny: [PermissionsFlagsBit.ViewChannel],
-   *   },
-   * ], 'Needed to change permissions');
-   */
+  
   set(overwrites, reason) {
     if (!Array.isArray(overwrites) && !(overwrites instanceof Collection)) {
       return Promise.reject(
@@ -76,23 +53,9 @@ class PermissionOverwriteManager extends CachedManager {
     return this.channel.edit({ permissionOverwrites: overwrites, reason });
   }
 
-  /**
-   * Extra information about the overwrite.
-   * @typedef {Object} GuildChannelOverwriteOptions
-   * @property {string} [reason] The reason for creating/editing this overwrite
-   * @property {OverwriteType} [type] The type of overwrite. Use this to bypass automatic resolution of `type`
-   * that results in an error for an uncached structure
-   */
-
-  /**
-   * Creates or edits permission overwrites for a user or role in this channel.
-   * @param {RoleResolvable|UserResolvable} userOrRole The user or role to update
-   * @param {PermissionOverwriteOptions} options The options for the update
-   * @param {GuildChannelOverwriteOptions} [overwriteOptions] The extra information for the update
-   * @param {PermissionOverwrites} [existing] The existing overwrites to merge with this update
-   * @returns {Promise<GuildChannel>}
-   * @private
-   */
+  
+
+  
   async upsert(userOrRole, options, overwriteOptions = {}, existing) {
     let userOrRoleId = this.channel.guild.roles.resolveId(userOrRole) ?? this.client.users.resolveId(userOrRole);
     let { type, reason } = overwriteOptions;
@@ -111,38 +74,12 @@ class PermissionOverwriteManager extends CachedManager {
     return this.channel;
   }
 
-  /**
-   * Creates permission overwrites for a user or role in this channel, or replaces them if already present.
-   * @param {RoleResolvable|UserResolvable} userOrRole The user or role to update
-   * @param {PermissionOverwriteOptions} options The options for the update
-   * @param {GuildChannelOverwriteOptions} [overwriteOptions] The extra information for the update
-   * @returns {Promise<GuildChannel>}
-   * @example
-   * // Create or Replace permission overwrites for a message author
-   * message.channel.permissionOverwrites.create(message.author, {
-   *   SendMessages: false
-   * })
-   *   .then(channel => console.log(channel.permissionOverwrites.cache.get(message.author.id)))
-   *   .catch(console.error);
-   */
+  
   create(userOrRole, options, overwriteOptions) {
     return this.upsert(userOrRole, options, overwriteOptions);
   }
 
-  /**
-   * Edits permission overwrites for a user or role in this channel, or creates an entry if not already present.
-   * @param {RoleResolvable|UserResolvable} userOrRole The user or role to update
-   * @param {PermissionOverwriteOptions} options The options for the update
-   * @param {GuildChannelOverwriteOptions} [overwriteOptions] The extra information for the update
-   * @returns {Promise<GuildChannel>}
-   * @example
-   * // Edit or Create permission overwrites for a message author
-   * message.channel.permissionOverwrites.edit(message.author, {
-   *   SendMessages: false
-   * })
-   *   .then(channel => console.log(channel.permissionOverwrites.cache.get(message.author.id)))
-   *   .catch(console.error);
-   */
+  
   edit(userOrRole, options, overwriteOptions) {
     const existing = this.cache.get(
       this.channel.guild.roles.resolveId(userOrRole) ?? this.client.users.resolveId(userOrRole),
@@ -150,12 +87,7 @@ class PermissionOverwriteManager extends CachedManager {
     return this.upsert(userOrRole, options, overwriteOptions, existing);
   }
 
-  /**
-   * Deletes permission overwrites for a user or role in this channel.
-   * @param {UserResolvable|RoleResolvable} userOrRole The user or role to delete
-   * @param {string} [reason] The reason for deleting the overwrite
-   * @returns {Promise<GuildChannel>}
-   */
+  
   async delete(userOrRole, reason) {
     const userOrRoleId = this.channel.guild.roles.resolveId(userOrRole) ?? this.client.users.resolveId(userOrRole);
     if (!userOrRoleId) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'parameter', 'User nor a Role');

package/src/managers/PresenceManager.js

@@ -3,38 +3,21 @@
 const CachedManager = require('./CachedManager');
 const { Presence } = require('../structures/Presence');
 
-/**
- * Manages API methods for Presences and holds their cache.
- * @extends {CachedManager}
- */
+
 class PresenceManager extends CachedManager {
   constructor(client, iterable) {
     super(client, Presence, iterable);
   }
 
-  /**
-   * The cache of Presences
-   * @type {Collection<Snowflake, Presence>}
-   * @name PresenceManager#cache
-   */
+  
 
   _add(data, cache) {
     return super._add(data, cache, { id: data.user.id });
   }
 
-  /**
-   * Data that can be resolved to a Presence object. This can be:
-   * * A Presence
-   * * A UserResolvable
-   * * A Snowflake
-   * @typedef {Presence|UserResolvable|Snowflake} PresenceResolvable
-   */
-
-  /**
-   * Resolves a {@link PresenceResolvable} to a {@link Presence} object.
-   * @param {PresenceResolvable} presence The presence resolvable to resolve
-   * @returns {?Presence}
-   */
+  
+
+  
   resolve(presence) {
     const presenceResolvable = super.resolve(presence);
     if (presenceResolvable) return presenceResolvable;
@@ -42,11 +25,7 @@ class PresenceManager extends CachedManager {
     return super.resolve(UserResolvable);
   }
 
-  /**
-   * Resolves a {@link PresenceResolvable} to a {@link Presence} id.
-   * @param {PresenceResolvable} presence The presence resolvable to resolve
-   * @returns {?Snowflake}
-   */
+  
   resolveId(presence) {
     const presenceResolvable = super.resolveId(presence);
     if (presenceResolvable) return presenceResolvable;

package/src/managers/ReactionManager.js

@@ -4,18 +4,12 @@ const { Routes } = require('discord-api-types/v10');
 const CachedManager = require('./CachedManager');
 const MessageReaction = require('../structures/MessageReaction');
 
-/**
- * Manages API methods for reactions and holds their cache.
- * @extends {CachedManager}
- */
+
 class ReactionManager extends CachedManager {
   constructor(message, iterable) {
     super(message.client, MessageReaction, iterable);
 
-    /**
-     * The message that this manager belongs to
-     * @type {Message}
-     */
+    
     this.message = message;
   }
 
@@ -23,42 +17,15 @@ class ReactionManager extends CachedManager {
     return super._add(data, cache, { id: data.emoji.id ?? data.emoji.name, extras: [this.message] });
   }
 
-  /**
-   * The reaction cache of this manager
-   * @type {Collection<string|Snowflake, MessageReaction>}
-   * @name ReactionManager#cache
-   */
+  
 
-  /**
-   * Data that can be resolved to a MessageReaction object. This can be:
-   * * A MessageReaction
-   * * A Snowflake
-   * * The Unicode representation of an emoji
-   * @typedef {MessageReaction|Snowflake} MessageReactionResolvable
-   */
+  
 
-  /**
-   * Resolves a {@link MessageReactionResolvable} to a {@link MessageReaction} object.
-   * @method resolve
-   * @memberof ReactionManager
-   * @instance
-   * @param {MessageReactionResolvable} reaction The MessageReaction to resolve
-   * @returns {?MessageReaction}
-   */
+  
 
-  /**
-   * Resolves a {@link MessageReactionResolvable} to a {@link MessageReaction} id.
-   * @method resolveId
-   * @memberof ReactionManager
-   * @instance
-   * @param {MessageReactionResolvable} reaction The MessageReaction to resolve
-   * @returns {?Snowflake}
-   */
+  
 
-  /**
-   * Removes all reactions from a message.
-   * @returns {Promise<Message>}
-   */
+  
   async removeAll() {
     await this.client.rest.delete(Routes.channelMessageAllReactions(this.message.channelId, this.message.id));
     return this.message;

package/src/managers/ReactionUserManager.js

@@ -7,39 +7,20 @@ const CachedManager = require('./CachedManager');
 const { DiscordjsError, ErrorCodes } = require('../errors');
 const User = require('../structures/User');
 
-/**
- * Manages API methods for users who reacted to a reaction and stores their cache.
- * @extends {CachedManager}
- */
+
 class ReactionUserManager extends CachedManager {
   constructor(reaction, iterable) {
     super(reaction.client, User, iterable);
 
-    /**
-     * The reaction that this manager belongs to
-     * @type {MessageReaction}
-     */
+    
     this.reaction = reaction;
   }
 
-  /**
-   * The cache of this manager
-   * @type {Collection<Snowflake, User>}
-   * @name ReactionUserManager#cache
-   */
+  
 
-  /**
-   * Options used to fetch users who gave a reaction.
-   * @typedef {Object} FetchReactionUsersOptions
-   * @property {number} [limit=100] The maximum amount of users to fetch, defaults to `100`
-   * @property {Snowflake} [after] Limit fetching users to those with an id greater than the supplied id
-   */
+  
 
-  /**
-   * Fetches all the users that gave this reaction. Resolves with a collection of users, mapped by their ids.
-   * @param {FetchReactionUsersOptions} [options] Options for fetching the users
-   * @returns {Promise<Collection<Snowflake, User>>}
-   */
+  
   async fetch({ limit = 100, after } = {}) {
     const message = this.reaction.message;
     const query = makeURLSearchParams({ limit, after });
@@ -56,11 +37,7 @@ class ReactionUserManager extends CachedManager {
     return users;
   }
 
-  /**
-   * Removes a user from this reaction.
-   * @param {UserResolvable} [user=this.client.user] The user to remove the reaction of
-   * @returns {Promise<MessageReaction>}
-   */
+  
   async remove(user = this.client.user) {
     const userId = this.client.users.resolveId(user);
     if (!userId) throw new DiscordjsError(ErrorCodes.ReactionResolveUser);

package/src/managers/RoleManager.js

@@ -12,10 +12,7 @@ const { setPosition, resolveColor } = require('../util/Util');
 
 let cacheWarningEmitted = false;
 
-/**
- * Manages API methods for roles and stores their cache.
- * @extends {CachedManager}
- */
+
 class RoleManager extends CachedManager {
   constructor(guild, iterable) {
     super(guild.client, Role, iterable);
@@ -27,113 +24,39 @@ class RoleManager extends CachedManager {
       );
     }
 
-    /**
-     * The guild belonging to this manager
-     * @type {Guild}
-     */
+    
     this.guild = guild;
   }
 
-  /**
-   * The role cache of this manager
-   * @type {Collection<Snowflake, Role>}
-   * @name RoleManager#cache
-   */
+  
 
   _add(data, cache) {
     return super._add(data, cache, { extras: [this.guild] });
   }
 
-  /**
-   * Obtains a role from Discord, or the role cache if they're already available.
-   * @param {Snowflake} [id] The role's id
-   * @param {BaseFetchOptions} [options] Additional options for this fetch
-   * @returns {Promise<?Role|Collection<Snowflake, Role>>}
-   * @example
-   * // Fetch all roles from the guild
-   * message.guild.roles.fetch()
-   *   .then(roles => console.log(`There are ${roles.size} roles.`))
-   *   .catch(console.error);
-   * @example
-   * // Fetch a single role
-   * message.guild.roles.fetch('222078108977594368')
-   *   .then(role => console.log(`The role color is: ${role.color}`))
-   *   .catch(console.error);
-   */
+  
   async fetch(id, { cache = true, force = false } = {}) {
     if (id && !force) {
       const existing = this.cache.get(id);
       if (existing) return existing;
     }
 
-    // We cannot fetch a single role, as of this commit's date, Discord API throws with 405
+    
     const data = await this.client.rest.get(Routes.guildRoles(this.guild.id));
     const roles = new Collection();
     for (const role of data) roles.set(role.id, this._add(role, cache));
     return id ? roles.get(id) ?? null : roles;
   }
 
-  /**
-   * Data that can be resolved to a Role object. This can be:
-   * * A Role
-   * * A Snowflake
-   * @typedef {Role|Snowflake} RoleResolvable
-   */
-
-  /**
-   * Resolves a {@link RoleResolvable} to a {@link Role} object.
-   * @method resolve
-   * @memberof RoleManager
-   * @instance
-   * @param {RoleResolvable} role The role resolvable to resolve
-   * @returns {?Role}
-   */
-
-  /**
-   * Resolves a {@link RoleResolvable} to a {@link Role} id.
-   * @method resolveId
-   * @memberof RoleManager
-   * @instance
-   * @param {RoleResolvable} role The role resolvable to resolve
-   * @returns {?Snowflake}
-   */
-
-  /**
-   * Options used to create a new role.
-   * @typedef {Object} RoleCreateOptions
-   * @property {string} [name] The name of the new role
-   * @property {ColorResolvable} [color] The data to create the role with
-   * @property {boolean} [hoist] Whether or not the new role should be hoisted
-   * @property {PermissionResolvable} [permissions] The permissions for the new role
-   * @property {number} [position] The position of the new role
-   * @property {boolean} [mentionable] Whether or not the new role should be mentionable
-   * @property {?(BufferResolvable|Base64Resolvable|EmojiResolvable)} [icon] The icon for the role
-   * <warn>The `EmojiResolvable` should belong to the same guild as the role.
-   * If not, pass the emoji's URL directly</warn>
-   * @property {?string} [unicodeEmoji] The unicode emoji for the role
-   * @property {string} [reason] The reason for creating this role
-   */
-
-  /**
-   * Creates a new role in the guild with given information.
-   * <warn>The position will silently reset to 1 if an invalid one is provided, or none.</warn>
-   * @param {RoleCreateOptions} [options] Options for creating the new role
-   * @returns {Promise<Role>}
-   * @example
-   * // Create a new role
-   * guild.roles.create()
-   *   .then(console.log)
-   *   .catch(console.error);
-   * @example
-   * // Create a new role with data and a reason
-   * guild.roles.create({
-   *   name: 'Super Cool Blue People',
-   *   color: Colors.Blue,
-   *   reason: 'we needed a role for Super Cool People',
-   * })
-   *   .then(console.log)
-   *   .catch(console.error);
-   */
+  
+
+  
+
+  
+
+  
+
+  
   async create(options = {}) {
     let { name, color, hoist, permissions, position, mentionable, reason, icon, unicodeEmoji } = options;
     color &&= resolveColor(color);
@@ -164,23 +87,9 @@ class RoleManager extends CachedManager {
     return role;
   }
 
-  /**
-   * Options for editing a role
-   * @typedef {RoleData} RoleEditOptions
-   * @property {string} [reason] The reason for editing this role
-   */
-
-  /**
-   * Edits a role of the guild.
-   * @param {RoleResolvable} role The role to edit
-   * @param {RoleEditOptions} options The options to provide
-   * @returns {Promise<Role>}
-   * @example
-   * // Edit a role
-   * guild.roles.edit('222079219327434752', { name: 'buddies' })
-   *   .then(updated => console.log(`Edited role name to ${updated.name}`))
-   *   .catch(console.error);
-   */
+  
+
+  
   async edit(role, options) {
     role = this.resolve(role);
     if (!role) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'role', 'RoleResolvable');
@@ -213,35 +122,14 @@ class RoleManager extends CachedManager {
     return clone;
   }
 
-  /**
-   * Deletes a role.
-   * @param {RoleResolvable} role The role to delete
-   * @param {string} [reason] Reason for deleting the role
-   * @returns {Promise<void>}
-   * @example
-   * // Delete a role
-   * guild.roles.delete('222079219327434752', 'The role needed to go')
-   *   .then(() => console.log('Deleted the role'))
-   *   .catch(console.error);
-   */
+  
   async delete(role, reason) {
     const id = this.resolveId(role);
     await this.client.rest.delete(Routes.guildRole(this.guild.id, id), { reason });
     this.client.actions.GuildRoleDelete.handle({ guild_id: this.guild.id, role_id: id });
   }
 
-  /**
-   * Sets the new position of the role.
-   * @param {RoleResolvable} role The role to change the position of
-   * @param {number} position The new position for the role
-   * @param {SetRolePositionOptions} [options] Options for setting the position
-   * @returns {Promise<Role>}
-   * @example
-   * // Set the position of the role
-   * guild.roles.setPosition('222197033908436994', 1)
-   *   .then(updated => console.log(`Role position: ${updated.position}`))
-   *   .catch(console.error);
-   */
+  
   async setPosition(role, position, { relative, reason } = {}) {
     role = this.resolve(role);
     if (!role) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'role', 'RoleResolvable');
@@ -262,30 +150,17 @@ class RoleManager extends CachedManager {
     return role;
   }
 
-  /**
-   * The data needed for updating a guild role's position
-   * @typedef {Object} GuildRolePosition
-   * @property {RoleResolvable} role The role's id
-   * @property {number} position The position to update
-   */
-
-  /**
-   * Batch-updates the guild's role positions
-   * @param {GuildRolePosition[]} rolePositions Role positions to update
-   * @returns {Promise<Guild>}
-   * @example
-   * guild.roles.setPositions([{ role: roleId, position: updatedRoleIndex }])
-   *  .then(guild => console.log(`Role positions updated for ${guild}`))
-   *  .catch(console.error);
-   */
+  
+
+  
   async setPositions(rolePositions) {
-    // Make sure rolePositions are prepared for API
+    
     rolePositions = rolePositions.map(o => ({
       id: this.resolveId(o.role),
       position: o.position,
     }));
 
-    // Call the API to update role positions
+    
     await this.client.rest.patch(Routes.guildRoles(this.guild.id), { body: rolePositions });
     return this.client.actions.GuildRolesPositionUpdate.handle({
       guild_id: this.guild.id,
@@ -293,13 +168,7 @@ class RoleManager extends CachedManager {
     }).guild;
   }
 
-  /**
-   * Compares the positions of two roles.
-   * @param {RoleResolvable} role1 First role to compare
-   * @param {RoleResolvable} role2 Second role to compare
-   * @returns {number} Negative number if the first role's position is lower (second role's is higher),
-   * positive number if the first's is higher (second's is lower), 0 if equal
-   */
+  
   comparePositions(role1, role2) {
     const resolvedRole1 = this.resolve(role1);
     const resolvedRole2 = this.resolve(role2);
@@ -317,41 +186,24 @@ class RoleManager extends CachedManager {
     return role1Position - role2Position;
   }
 
-  /**
-   * Gets the managed role a user created when joining the guild, if any
-   * <info>Only ever available for bots</info>
-   * @param {UserResolvable} user The user to access the bot role for
-   * @returns {?Role}
-   */
+  
   botRoleFor(user) {
     const userId = this.client.users.resolveId(user);
     if (!userId) return null;
     return this.cache.find(role => role.tags?.botId === userId) ?? null;
   }
 
-  /**
-   * The `@everyone` role of the guild
-   * @type {Role}
-   * @readonly
-   */
+  
   get everyone() {
     return this.cache.get(this.guild.id);
   }
 
-  /**
-   * The premium subscriber role of the guild, if any
-   * @type {?Role}
-   * @readonly
-   */
+  
   get premiumSubscriberRole() {
     return this.cache.find(role => role.tags?.premiumSubscriberRole) ?? null;
   }
 
-  /**
-   * The role with the highest position in the cache
-   * @type {Role}
-   * @readonly
-   */
+  
   get highest() {
     return this.cache.reduce((prev, role) => (role.comparePositionTo(prev) > 0 ? role : prev), this.cache.first());
   }