@velliajs/discord 1.0.3 → 1.0.4

package/src/managers/GuildMemberManager.js

@@ -14,43 +14,24 @@ const Events = require('../util/Events');
 const { GuildMemberFlagsBitField } = require('../util/GuildMemberFlagsBitField');
 const Partials = require('../util/Partials');
 
-/**
- * Manages API methods for GuildMembers and stores their cache.
- * @extends {CachedManager}
- */
+
 class GuildMemberManager extends CachedManager {
   constructor(guild, iterable) {
     super(guild.client, GuildMember, iterable);
 
-    /**
-     * The guild this manager belongs to
-     * @type {Guild}
-     */
+    
     this.guild = guild;
   }
 
-  /**
-   * The cache of this Manager
-   * @type {Collection<Snowflake, GuildMember>}
-   * @name GuildMemberManager#cache
-   */
+  
 
   _add(data, cache = true) {
     return super._add(data, cache, { id: data.user.id, extras: [this.guild] });
   }
 
-  /**
-   * Data that resolves to give a GuildMember object. This can be:
-   * * A GuildMember object
-   * * A User resolvable
-   * @typedef {GuildMember|UserResolvable} GuildMemberResolvable
-   */
-
-  /**
-   * Resolves a {@link GuildMemberResolvable} to a {@link GuildMember} object.
-   * @param {GuildMemberResolvable} member The user that is part of the guild
-   * @returns {?GuildMember}
-   */
+  
+
+  
   resolve(member) {
     const memberResolvable = super.resolve(member);
     if (memberResolvable) return memberResolvable;
@@ -59,11 +40,7 @@ class GuildMemberManager extends CachedManager {
     return null;
   }
 
-  /**
-   * Resolves a {@link GuildMemberResolvable} to a member id.
-   * @param {GuildMemberResolvable} member The user that is part of the guild
-   * @returns {?Snowflake}
-   */
+  
   resolveId(member) {
     const memberResolvable = super.resolveId(member);
     if (memberResolvable) return memberResolvable;
@@ -71,30 +48,9 @@ class GuildMemberManager extends CachedManager {
     return this.cache.has(userResolvable) ? userResolvable : null;
   }
 
-  /**
-   * Options used to add a user to a guild using OAuth2.
-   * @typedef {Object} AddGuildMemberOptions
-   * @property {string} accessToken An OAuth2 access token for the user with the {@link OAuth2Scopes.GuildsJoin}
-   * scope granted to the bot's application
-   * @property {string} [nick] The nickname to give to the member
-   * <info>This property requires the {@link PermissionFlagsBits.ManageNicknames} permission.</info>
-   * @property {Collection<Snowflake, Role>|RoleResolvable[]} [roles] The roles to add to the member
-   * <info>This property requires the {@link PermissionFlagsBits.ManageRoles} permission.</info>
-   * @property {boolean} [mute] Whether the member should be muted
-   * <info>This property requires the {@link PermissionFlagsBits.MuteMembers} permission.</info>
-   * @property {boolean} [deaf] Whether the member should be deafened
-   * <info>This property requires the {@link PermissionFlagsBits.MuteMembers} permission.</info>
-   * @property {boolean} [force] Whether to skip the cache check and request the API directly
-   * @property {boolean} [fetchWhenExisting=true] Whether to fetch the user if not cached and already a member
-   */
-
-  /**
-   * Adds a user to the guild using OAuth2.
-   * <info>This method requires the {@link PermissionFlagsBits.CreateInstantInvite} permission.
-   * @param {UserResolvable} user The user to add to the guild
-   * @param {AddGuildMemberOptions} options Options for adding the user to the guild
-   * @returns {Promise<GuildMember|null>}
-   */
+  
+
+  
   async add(user, options) {
     const userId = this.client.users.resolveId(user);
     if (!userId) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'user', 'UserResolvable');
@@ -128,7 +84,7 @@ class GuildMemberManager extends CachedManager {
       resolvedOptions.roles = resolvedRoles;
     }
     const data = await this.client.rest.put(Routes.guildMember(this.guild.id, userId), { body: resolvedOptions });
-    // Data is an empty Uint8Array if the member is already part of the guild.
+    
     return data instanceof Uint8Array
       ? options.fetchWhenExisting === false
         ? null
@@ -136,11 +92,7 @@ class GuildMemberManager extends CachedManager {
       : this._add(data);
   }
 
-  /**
-   * The client user as a GuildMember of this guild
-   * @type {?GuildMember}
-   * @readonly
-   */
+  
   get me() {
     return (
       this.resolve(this.client.user.id) ??
@@ -150,59 +102,11 @@ class GuildMemberManager extends CachedManager {
     );
   }
 
-  /**
-   * Options used to fetch a single member from a guild.
-   * @typedef {BaseFetchOptions} FetchMemberOptions
-   * @property {UserResolvable} user The user to fetch
-   */
-
-  /**
-   * Options used to fetch multiple members from a guild.
-   * @typedef {Object} FetchMembersOptions
-   * @property {UserResolvable|UserResolvable[]} [user] The user(s) to fetch
-   * @property {?string} [query] Limit fetch to members with similar usernames
-   * @property {number} [limit=0] Maximum number of members to request
-   * @property {boolean} [withPresences=false] Whether to include the presences
-   * @property {number} [time=120e3] Timeout for receipt of members
-   * @property {?string} [nonce] Nonce for this request (32 characters max - default to base 16 now timestamp)
-   */
-
-  /**
-   * Fetches member(s) from a guild.
-   * @param {UserResolvable|FetchMemberOptions|FetchMembersOptions} [options] Options for fetching member(s).
-   * Omitting the parameter or providing `undefined` will fetch all members.
-   * @returns {Promise<GuildMember|Collection<Snowflake, GuildMember>>}
-   * @example
-   * // Fetch all members from a guild
-   * guild.members.fetch()
-   *   .then(console.log)
-   *   .catch(console.error);
-   * @example
-   * // Fetch a single member
-   * guild.members.fetch('66564597481480192')
-   *   .then(console.log)
-   *   .catch(console.error);
-   * @example
-   * // Fetch a single member without checking cache
-   * guild.members.fetch({ user, force: true })
-   *   .then(console.log)
-   *   .catch(console.error)
-   * @example
-   * // Fetch a single member without caching
-   * guild.members.fetch({ user, cache: false })
-   *   .then(console.log)
-   *   .catch(console.error);
-   * @example
-   * // Fetch by an array of users including their presences
-   * guild.members.fetch({ user: ['66564597481480192', '191615925336670208'], withPresences: true })
-   *   .then(console.log)
-   *   .catch(console.error);
-   * @example
-   * // Fetch by query
-   * guild.members.fetch({ query: 'hydra', limit: 1 })
-   *   .then(console.log)
-   *   .catch(console.error);
-   */
+  
+
+  
+
+  
   fetch(options) {
     if (!options) return this._fetchMany();
     const { user: users, limit, withPresences, cache, force } = options;
@@ -271,28 +175,14 @@ class GuildMemberManager extends CachedManager {
     });
   }
 
-  /**
-   * Fetches the client user as a GuildMember of the guild.
-   * @param {BaseFetchOptions} [options] The options for fetching the member
-   * @returns {Promise<GuildMember>}
-   */
+  
   fetchMe(options) {
     return this.fetch({ ...options, user: this.client.user.id });
   }
 
-  /**
-   * Options used for searching guild members.
-   * @typedef {Object} GuildSearchMembersOptions
-   * @property {string} query Filter members whose username or nickname start with this query
-   * @property {number} [limit] Maximum number of members to search
-   * @property {boolean} [cache=true] Whether or not to cache the fetched member(s)
-   */
-
-  /**
-   * Searches for members in the guild based on a query.
-   * @param {GuildSearchMembersOptions} options Options for searching members
-   * @returns {Promise<Collection<Snowflake, GuildMember>>}
-   */
+  
+
+  
   async search({ query, limit, cache = true } = {}) {
     const data = await this.client.rest.get(Routes.guildMembersSearch(this.guild.id), {
       query: makeURLSearchParams({ query, limit }),
@@ -300,47 +190,18 @@ class GuildMemberManager extends CachedManager {
     return data.reduce((col, member) => col.set(member.user.id, this._add(member, cache)), new Collection());
   }
 
-  /**
-   * Options used for listing guild members.
-   * @typedef {Object} GuildListMembersOptions
-   * @property {Snowflake} [after] Limit fetching members to those with an id greater than the supplied id
-   * @property {number} [limit] Maximum number of members to list
-   * @property {boolean} [cache=true] Whether or not to cache the fetched member(s)
-   */
-
-  /**
-   * Lists up to 1000 members of the guild.
-   * @param {GuildListMembersOptions} [options] Options for listing members
-   * @returns {Promise<Collection<Snowflake, GuildMember>>}
-   */
+  
+
+  
   async list({ after, limit, cache = true } = {}) {
     const query = makeURLSearchParams({ limit, after });
     const data = await this.client.rest.get(Routes.guildMembers(this.guild.id), { query });
     return data.reduce((col, member) => col.set(member.user.id, this._add(member, cache)), new Collection());
   }
 
-  /**
-   * The data for editing a guild member.
-   * @typedef {Object} GuildMemberEditOptions
-   * @property {?string} [nick] The nickname to set for the member
-   * @property {Collection<Snowflake, Role>|RoleResolvable[]} [roles] The roles or role ids to apply
-   * @property {boolean} [mute] Whether or not the member should be muted
-   * @property {boolean} [deaf] Whether or not the member should be deafened
-   * @property {GuildVoiceChannelResolvable|null} [channel] Channel to move the member to
-   * (if they are connected to voice), or `null` if you want to disconnect them from voice
-   * @property {DateResolvable|null} [communicationDisabledUntil] The date or timestamp
-   * for the member's communication to be disabled until. Provide `null` to enable communication again.
-   * @property {GuildMemberFlagsResolvable} [flags] The flags to set for the member
-   * @property {string} [reason] Reason for editing this user
-   */
-
-  /**
-   * Edits a member of the guild.
-   * <info>The user must be a member of the guild</info>
-   * @param {UserResolvable} user The member to edit
-   * @param {GuildMemberEditOptions} options The options to provide
-   * @returns {Promise<GuildMember>}
-   */
+  
+
+  
   async edit(user, { reason, ...options }) {
     const id = this.client.users.resolveId(user);
     if (!id) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'user', 'UserResolvable');
@@ -360,7 +221,7 @@ class GuildMemberManager extends CachedManager {
 
     if (options.communicationDisabledUntil !== undefined) {
       options.communication_disabled_until =
-        // eslint-disable-next-line eqeqeq
+        
         options.communicationDisabledUntil != null
           ? new Date(options.communicationDisabledUntil).toISOString()
           : options.communicationDisabledUntil;
@@ -385,38 +246,9 @@ class GuildMemberManager extends CachedManager {
     return clone ?? this._add(d, false);
   }
 
-  /**
-   * Options used for pruning guild members.
-   * <info>It's recommended to set {@link GuildPruneMembersOptions#count options.count}
-   * to `false` for large guilds.</info>
-   * @typedef {Object} GuildPruneMembersOptions
-   * @property {number} [days] Number of days of inactivity required to kick
-   * @property {boolean} [dry=false] Get the number of users that will be kicked, without actually kicking them
-   * @property {boolean} [count] Whether or not to return the number of users that have been kicked.
-   * @property {RoleResolvable[]} [roles] Array of roles to bypass the "...and no roles" constraint when pruning
-   * @property {string} [reason] Reason for this prune
-   */
-
-  /**
-   * Prunes members from the guild based on how long they have been inactive.
-   * @param {GuildPruneMembersOptions} [options] Options for pruning
-   * @returns {Promise<number|null>} The number of members that were/will be kicked
-   * @example
-   * // See how many members will be pruned
-   * guild.members.prune({ dry: true })
-   *   .then(pruned => console.log(`This will prune ${pruned} people!`))
-   *   .catch(console.error);
-   * @example
-   * // Actually prune the members
-   * guild.members.prune({ days: 1, reason: 'too many people!' })
-   *   .then(pruned => console.log(`I just pruned ${pruned} people!`))
-   *   .catch(console.error);
-   * @example
-   * // Include members with a specified role
-   * guild.members.prune({ days: 7, roles: ['657259391652855808'] })
-   *    .then(pruned => console.log(`I just pruned ${pruned} people!`))
-   *    .catch(console.error);
-   */
+  
+
+  
   async prune({ days, dry = false, count: compute_prune_count, roles = [], reason } = {}) {
     if (typeof days !== 'number') throw new DiscordjsTypeError(ErrorCodes.PruneDaysType);
 
@@ -444,20 +276,7 @@ class GuildMemberManager extends CachedManager {
     return pruned;
   }
 
-  /**
-   * Kicks a user from the guild.
-   * <info>The user must be a member of the guild</info>
-   * @param {UserResolvable} user The member to kick
-   * @param {string} [reason] Reason for kicking
-   * @returns {Promise<GuildMember|User|Snowflake>} Result object will be resolved as specifically as possible.
-   * If the GuildMember cannot be resolved, the User will instead be attempted to be resolved. If that also cannot
-   * be resolved, the user's id will be the result.
-   * @example
-   * // Kick a user by id (or with a user/guild member object)
-   * guild.members.kick('84484653687267328')
-   *   .then(kickInfo => console.log(`Kicked ${kickInfo.user?.tag ?? kickInfo.tag ?? kickInfo}`))
-   *   .catch(console.error);
-   */
+  
   async kick(user, reason) {
     const id = this.client.users.resolveId(user);
     if (!id) return Promise.reject(new DiscordjsTypeError(ErrorCodes.InvalidType, 'user', 'UserResolvable'));
@@ -467,52 +286,19 @@ class GuildMemberManager extends CachedManager {
     return this.resolve(user) ?? this.client.users.resolve(user) ?? id;
   }
 
-  /**
-   * Bans a user from the guild.
-   * @param {UserResolvable} user The user to ban
-   * @param {BanOptions} [options] Options for the ban
-   * @returns {Promise<GuildMember|User|Snowflake>} Result object will be resolved as specifically as possible.
-   * If the GuildMember cannot be resolved, the User will instead be attempted to be resolved. If that also cannot
-   * be resolved, the user id will be the result.
-   * Internally calls the GuildBanManager#create method.
-   * @example
-   * // Ban a user by id (or with a user/guild member object)
-   * guild.members.ban('84484653687267328')
-   *   .then(banInfo => console.log(`Banned ${banInfo.user?.tag ?? banInfo.tag ?? banInfo}`))
-   *   .catch(console.error);
-   */
+  
   ban(user, options) {
     return this.guild.bans.create(user, options);
   }
 
-  /**
-   * Unbans a user from the guild. Internally calls the {@link GuildBanManager#remove} method.
-   * @param {UserResolvable} user The user to unban
-   * @param {string} [reason] Reason for unbanning user
-   * @returns {Promise<?User>} The user that was unbanned
-   * @example
-   * // Unban a user by id (or with a user/guild member object)
-   * guild.members.unban('84484653687267328')
-   *   .then(user => console.log(`Unbanned ${user.username} from ${guild.name}`))
-   *   .catch(console.error);
-   */
+  
   unban(user, reason) {
     return this.guild.bans.remove(user, reason);
   }
 
-  /**
-   * Options used for adding or removing a role from a member.
-   * @typedef {Object} AddOrRemoveGuildMemberRoleOptions
-   * @property {GuildMemberResolvable} user The user to add/remove the role from
-   * @property {RoleResolvable} role The role to add/remove
-   * @property {string} [reason] Reason for adding/removing the role
-   */
-
-  /**
-   * Adds a role to a member.
-   * @param {AddOrRemoveGuildMemberRoleOptions} options Options for adding the role
-   * @returns {Promise<GuildMember|User|Snowflake>}
-   */
+  
+
+  
   async addRole(options) {
     const { user, role, reason } = options;
     const userId = this.guild.members.resolveId(user);
@@ -522,11 +308,7 @@ class GuildMemberManager extends CachedManager {
     return this.resolve(user) ?? this.client.users.resolve(user) ?? userId;
   }
 
-  /**
-   * Removes a role from a member.
-   * @param {AddOrRemoveGuildMemberRoleOptions} options Options for removing the role
-   * @returns {Promise<GuildMember|User|Snowflake>}
-   */
+  
   async removeRole(options) {
     const { user, role, reason } = options;
     const userId = this.guild.members.resolveId(user);

package/src/managers/GuildMemberRoleManager.js

@@ -6,105 +6,62 @@ const DataManager = require('./DataManager');
 const { DiscordjsTypeError, ErrorCodes } = require('../errors');
 const { Role } = require('../structures/Role');
 
-/**
- * Manages API methods for roles of a GuildMember and stores their cache.
- * @extends {DataManager}
- */
+
 class GuildMemberRoleManager extends DataManager {
   constructor(member) {
     super(member.client, Role);
 
-    /**
-     * The GuildMember this manager belongs to
-     * @type {GuildMember}
-     */
+    
     this.member = member;
 
-    /**
-     * The Guild this manager belongs to
-     * @type {Guild}
-     */
+    
     this.guild = member.guild;
   }
 
-  /**
-   * The roles of this member
-   * @type {Collection<Snowflake, Role>}
-   * @readonly
-   */
+  
   get cache() {
     const everyone = this.guild.roles.everyone;
     return this.guild.roles.cache.filter(role => this.member._roles.includes(role.id)).set(everyone.id, everyone);
   }
 
-  /**
-   * The role of the member used to hoist them in a separate category in the users list
-   * @type {?Role}
-   * @readonly
-   */
+  
   get hoist() {
     const hoistedRoles = this.cache.filter(role => role.hoist);
     if (!hoistedRoles.size) return null;
     return hoistedRoles.reduce((prev, role) => (role.comparePositionTo(prev) > 0 ? role : prev));
   }
 
-  /**
-   * The role of the member used to set their role icon
-   * @type {?Role}
-   * @readonly
-   */
+  
   get icon() {
     const iconRoles = this.cache.filter(role => role.icon || role.unicodeEmoji);
     if (!iconRoles.size) return null;
     return iconRoles.reduce((prev, role) => (role.comparePositionTo(prev) > 0 ? role : prev));
   }
 
-  /**
-   * The role of the member used to set their color
-   * @type {?Role}
-   * @readonly
-   */
+  
   get color() {
     const coloredRoles = this.cache.filter(role => role.color);
     if (!coloredRoles.size) return null;
     return coloredRoles.reduce((prev, role) => (role.comparePositionTo(prev) > 0 ? role : prev));
   }
 
-  /**
-   * The role of the member with the highest position
-   * @type {Role}
-   * @readonly
-   */
+  
   get highest() {
     return this.cache.reduce((prev, role) => (role.comparePositionTo(prev) > 0 ? role : prev), this.cache.first());
   }
 
-  /**
-   * The premium subscriber role of the guild, if present on the member
-   * @type {?Role}
-   * @readonly
-   */
+  
   get premiumSubscriberRole() {
     return this.cache.find(role => role.tags?.premiumSubscriberRole) ?? null;
   }
 
-  /**
-   * The managed role this member created when joining the guild, if any
-   * <info>Only ever available on bots</info>
-   * @type {?Role}
-   * @readonly
-   */
+  
   get botRole() {
     if (!this.member.user.bot) return null;
     return this.cache.find(role => role.tags?.botId === this.member.user.id) ?? null;
   }
 
-  /**
-   * Adds a role (or multiple roles) to the member.
-   * @param {RoleResolvable|RoleResolvable[]|Collection<Snowflake, Role>} roleOrRoles The role or roles to add
-   * @param {string} [reason] Reason for adding the role(s)
-   * @returns {Promise<GuildMember>}
-   */
+  
   async add(roleOrRoles, reason) {
     if (roleOrRoles instanceof Collection || Array.isArray(roleOrRoles)) {
       const resolvedRoles = [];
@@ -136,12 +93,7 @@ class GuildMemberRoleManager extends DataManager {
     }
   }
 
-  /**
-   * Removes a role (or multiple roles) from the member.
-   * @param {RoleResolvable|RoleResolvable[]|Collection<Snowflake, Role>} roleOrRoles The role or roles to remove
-   * @param {string} [reason] Reason for removing the role(s)
-   * @returns {Promise<GuildMember>}
-   */
+  
   async remove(roleOrRoles, reason) {
     if (roleOrRoles instanceof Collection || Array.isArray(roleOrRoles)) {
       const resolvedRoles = [];
@@ -174,22 +126,7 @@ class GuildMemberRoleManager extends DataManager {
     }
   }
 
-  /**
-   * Sets the roles applied to the member.
-   * @param {Collection<Snowflake, Role>|RoleResolvable[]} roles The roles or role ids to apply
-   * @param {string} [reason] Reason for applying the roles
-   * @returns {Promise<GuildMember>}
-   * @example
-   * // Set the member's roles to a single role
-   * guildMember.roles.set(['391156570408615936'])
-   *   .then(console.log)
-   *   .catch(console.error);
-   * @example
-   * // Remove all the roles from a member
-   * guildMember.roles.set([])
-   *   .then(member => console.log(`Member roles is now of ${member.roles.cache.size} size`))
-   *   .catch(console.error);
-   */
+  
   set(roles, reason) {
     return this.member.edit({ roles, reason });
   }