@velliajs/discord 1.0.2 → 1.0.4

package/src/managers/StageInstanceManager.js

@@ -5,56 +5,22 @@ const CachedManager = require('./CachedManager');
 const { DiscordjsTypeError, DiscordjsError, ErrorCodes } = require('../errors');
 const { StageInstance } = require('../structures/StageInstance');
 
-/**
- * Manages API methods for {@link StageInstance} objects and holds their cache.
- * @extends {CachedManager}
- */
+
 class StageInstanceManager extends CachedManager {
   constructor(guild, iterable) {
     super(guild.client, StageInstance, iterable);
 
-    /**
-     * The guild this manager belongs to
-     * @type {Guild}
-     */
+    
     this.guild = guild;
   }
 
-  /**
-   * The cache of this Manager
-   * @type {Collection<Snowflake, StageInstance>}
-   * @name StageInstanceManager#cache
-   */
-
-  /**
-   * Options used to create a stage instance.
-   * @typedef {Object} StageInstanceCreateOptions
-   * @property {string} topic The topic of the stage instance
-   * @property {StageInstancePrivacyLevel} [privacyLevel] The privacy level of the stage instance
-   * @property {boolean} [sendStartNotification] Whether to notify `@everyone` that the stage instance has started
-   */
-
-  /**
-   * Data that can be resolved to a Stage Channel object. This can be:
-   * * A StageChannel
-   * * A Snowflake
-   * @typedef {StageChannel|Snowflake} StageChannelResolvable
-   */
-
-  /**
-   * Creates a new stage instance.
-   * @param {StageChannelResolvable} channel The stage channel to associate the created stage instance to
-   * @param {StageInstanceCreateOptions} options The options to create the stage instance
-   * @returns {Promise<StageInstance>}
-   * @example
-   * // Create a stage instance
-   * guild.stageInstances.create('1234567890123456789', {
-   *  topic: 'A very creative topic',
-   *  privacyLevel: GuildPrivacyLevel.GuildOnly
-   * })
-   *  .then(stageInstance => console.log(stageInstance))
-   *  .catch(console.error);
-   */
+  
+
+  
+
+  
+
+  
   async create(channel, options) {
     const channelId = this.guild.channels.resolveId(channel);
     if (!channelId) throw new DiscordjsError(ErrorCodes.StageChannelResolve);
@@ -73,17 +39,7 @@ class StageInstanceManager extends CachedManager {
     return this._add(data);
   }
 
-  /**
-   * Fetches the stage instance associated with a stage channel, if it exists.
-   * @param {StageChannelResolvable} channel The stage channel whose associated stage instance is to be fetched
-   * @param {BaseFetchOptions} [options] Additional options for this fetch
-   * @returns {Promise<StageInstance>}
-   * @example
-   * // Fetch a stage instance
-   * guild.stageInstances.fetch('1234567890123456789')
-   *  .then(stageInstance => console.log(stageInstance))
-   *  .catch(console.error);
-   */
+  
   async fetch(channel, { cache = true, force = false } = {}) {
     const channelId = this.guild.channels.resolveId(channel);
     if (!channelId) throw new DiscordjsError(ErrorCodes.StageChannelResolve);
@@ -97,24 +53,9 @@ class StageInstanceManager extends CachedManager {
     return this._add(data, cache);
   }
 
-  /**
-   * Options used to edit an existing stage instance.
-   * @typedef {Object} StageInstanceEditOptions
-   * @property {string} [topic] The new topic of the stage instance
-   * @property {StageInstancePrivacyLevel} [privacyLevel] The new privacy level of the stage instance
-   */
-
-  /**
-   * Edits an existing stage instance.
-   * @param {StageChannelResolvable} channel The stage channel whose associated stage instance is to be edited
-   * @param {StageInstanceEditOptions} options The options to edit the stage instance
-   * @returns {Promise<StageInstance>}
-   * @example
-   * // Edit a stage instance
-   * guild.stageInstances.edit('1234567890123456789', { topic: 'new topic' })
-   *  .then(stageInstance => console.log(stageInstance))
-   *  .catch(console.error);
-   */
+  
+
+  
   async edit(channel, options) {
     if (typeof options !== 'object') throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'options', 'object', true);
     const channelId = this.guild.channels.resolveId(channel);
@@ -138,11 +79,7 @@ class StageInstanceManager extends CachedManager {
     return this._add(data);
   }
 
-  /**
-   * Deletes an existing stage instance.
-   * @param {StageChannelResolvable} channel The stage channel whose associated stage instance is to be deleted
-   * @returns {Promise<void>}
-   */
+  
   async delete(channel) {
     const channelId = this.guild.channels.resolveId(channel);
     if (!channelId) throw new DiscordjsError(ErrorCodes.StageChannelResolve);

package/src/managers/ThreadManager.js

@@ -7,33 +7,18 @@ const CachedManager = require('./CachedManager');
 const { DiscordjsTypeError, ErrorCodes } = require('../errors');
 const ThreadChannel = require('../structures/ThreadChannel');
 
-/**
- * Manages API methods for thread-based channels and stores their cache.
- * @extends {CachedManager}
- */
+
 class ThreadManager extends CachedManager {
   constructor(channel, iterable) {
     super(channel.client, ThreadChannel, iterable);
 
-    /**
-     * The channel this Manager belongs to
-     * @type {TextChannel|NewsChannel|ForumChannel}
-     */
+    
     this.channel = channel;
   }
 
-  /**
-   * Data that can be resolved to a Thread Channel object. This can be:
-   * * A ThreadChannel object
-   * * A Snowflake
-   * @typedef {ThreadChannel|Snowflake} ThreadChannelResolvable
-   */
+  
 
-  /**
-   * The cache of this Manager
-   * @type {Collection<Snowflake, ThreadChannel>}
-   * @name ThreadManager#cache
-   */
+  
 
   _add(thread) {
     const existing = this.cache.get(thread.id);
@@ -42,58 +27,15 @@ class ThreadManager extends CachedManager {
     return thread;
   }
 
-  /**
-   * Resolves a {@link ThreadChannelResolvable} to a {@link ThreadChannel} object.
-   * @method resolve
-   * @memberof ThreadManager
-   * @instance
-   * @param {ThreadChannelResolvable} thread The ThreadChannel resolvable to resolve
-   * @returns {?ThreadChannel}
-   */
-
-  /**
-   * Resolves a {@link ThreadChannelResolvable} to a {@link ThreadChannel} id.
-   * @method resolveId
-   * @memberof ThreadManager
-   * @instance
-   * @param {ThreadChannelResolvable} thread The ThreadChannel resolvable to resolve
-   * @returns {?Snowflake}
-   */
-
-  /**
-   * Options for creating a thread. <warn>Only one of `startMessage` or `type` can be defined.</warn>
-   * @typedef {StartThreadOptions} ThreadCreateOptions
-   * @property {MessageResolvable} [startMessage] The message to start a thread from. <warn>If this is defined then type
-   * of thread gets automatically defined and cannot be changed. The provided `type` field will be ignored</warn>
-   * @property {ChannelType.AnnouncementThread|ChannelType.PublicThread|ChannelType.PrivateThread} [type]
-   * The type of thread to create.
-   * Defaults to {@link ChannelType.PublicThread} if created in a {@link TextChannel}
-   * <warn>When creating threads in a {@link NewsChannel} this is ignored and is always
-   * {@link ChannelType.AnnouncementThread}</warn>
-   * @property {boolean} [invitable] Whether non-moderators can add other non-moderators to the thread
-   * <info>Can only be set when type will be {@link ChannelType.PrivateThread}</info>
-   */
-
-  /**
-   * Options for fetching multiple threads.
-   * @typedef {Object} FetchThreadsOptions
-   * @property {FetchArchivedThreadOptions} [archived] Options used to fetch archived threads
-   */
-
-  /**
-   * Obtains a thread from Discord, or the channel cache if it's already available.
-   * @param {ThreadChannelResolvable|FetchThreadsOptions} [options] The options to fetch threads. If it is a
-   * ThreadChannelResolvable then the specified thread will be fetched. Fetches all active threads if `undefined`
-   * @param {BaseFetchOptions} [cacheOptions] Additional options for this fetch. <warn>The `force` field gets ignored
-   * if `options` is not a {@link ThreadChannelResolvable}</warn>
-   * @returns {Promise<?(ThreadChannel|FetchedThreads|FetchedThreadsMore)>}
-   * {@link FetchedThreads} if active & {@link FetchedThreadsMore} if archived.
-   * @example
-   * // Fetch a thread by its id
-   * channel.threads.fetch('831955138126104859')
-   *   .then(channel => console.log(channel.name))
-   *   .catch(console.error);
-   */
+  
+
+  
+
+  
+
+  
+
+  
   fetch(options, { cache, force } = {}) {
     if (!options) return this.fetchActive(cache);
     const channel = this.client.channels.resolveId(options);
@@ -104,40 +46,13 @@ class ThreadManager extends CachedManager {
     return this.fetchActive(cache);
   }
 
-  /**
-   * Data that can be resolved to a Date object. This can be:
-   * * A Date object
-   * * A number representing a timestamp
-   * * An [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) string
-   * @typedef {Date|number|string} DateResolvable
-   */
-
-  /**
-   * The options used to fetch archived threads.
-   * @typedef {Object} FetchArchivedThreadOptions
-   * @property {string} [type='public'] The type of threads to fetch (`public` or `private`)
-   * @property {boolean} [fetchAll=false] Whether to fetch **all** archived threads when `type` is `private`
-   * <info>This property requires the {@link PermissionFlagsBits.ManageThreads} permission if `true`.</info>
-   * @property {DateResolvable|ThreadChannelResolvable} [before] Only return threads that were archived before this Date
-   * or Snowflake
-   * <warn>Must be a {@link ThreadChannelResolvable} when `type` is `private` and `fetchAll` is `false`.</warn>
-   * @property {number} [limit] Maximum number of threads to return
-   */
-
-  /**
-   * Data returned from fetching multiple threads.
-   * @typedef {FetchedThreads} FetchedThreadsMore
-   * @property {?boolean} hasMore Whether there are potentially additional threads that require a subsequent call
-   */
-
-  /**
-   * Obtains a set of archived threads from Discord.
-   * <info>This method requires the {@link PermissionFlagsBits.ReadMessageHistory} permission
-   * in the parent channel.</info>
-   * @param {FetchArchivedThreadOptions} [options] The options to fetch archived threads
-   * @param {boolean} [cache=true] Whether to cache the new thread objects if they aren't already
-   * @returns {Promise<FetchedThreadsMore>}
-   */
+  
+
+  
+
+  
+
+  
   async fetchArchived({ type = 'public', fetchAll = false, before, limit } = {}, cache = true) {
     let path = Routes.channelThreads(this.channel.id, type);
     if (type === 'private' && !fetchAll) {
@@ -170,12 +85,7 @@ class ThreadManager extends CachedManager {
     return this.constructor._mapThreads(raw, this.client, { parent: this.channel, cache });
   }
 
-  /**
-   * Obtains all active thread channels in the guild.
-   * This internally calls {@link GuildChannelManager#fetchActiveThreads}.
-   * @param {boolean} [cache=true] Whether to cache the fetched data
-   * @returns {Promise<FetchedThreads>}
-   */
+  
   fetchActive(cache = true) {
     return this.channel.guild.channels.fetchActiveThreads(cache);
   }
@@ -187,7 +97,7 @@ class ThreadManager extends CachedManager {
       return coll.set(thread.id, thread);
     }, new Collection());
 
-    // Discord sends the thread id as id in this object
+    
     const threadMembers = rawThreads.members.reduce(
       (coll, raw) => coll.set(raw.user_id, threads.get(raw.id).members._add(raw)),
       new Collection(),
@@ -195,7 +105,7 @@ class ThreadManager extends CachedManager {
 
     const response = { threads, members: threadMembers };
 
-    // The GET `/guilds/{guild.id}/threads/active` route does not return `has_more`.
+    
     if ('has_more' in rawThreads) response.hasMore = rawThreads.has_more;
     return response;
   }

package/src/managers/ThreadMemberManager.js

@@ -7,26 +7,16 @@ const CachedManager = require('./CachedManager');
 const { DiscordjsTypeError, ErrorCodes } = require('../errors');
 const ThreadMember = require('../structures/ThreadMember');
 
-/**
- * Manages API methods for GuildMembers and stores their cache.
- * @extends {CachedManager}
- */
+
 class ThreadMemberManager extends CachedManager {
   constructor(thread, iterable) {
     super(thread.client, ThreadMember, iterable);
 
-    /**
-     * The thread this manager belongs to
-     * @type {ThreadChannel}
-     */
+    
     this.thread = thread;
   }
 
-  /**
-   * The cache of this Manager
-   * @type {Collection<Snowflake, ThreadMember>}
-   * @name ThreadMemberManager#cache
-   */
+  
 
   _add(data, cache = true) {
     const existing = this.cache.get(data.user_id);
@@ -38,36 +28,19 @@ class ThreadMemberManager extends CachedManager {
     return member;
   }
 
-  /**
-   * Fetches the client user as a ThreadMember of the thread.
-   * @param {BaseFetchOptions} [options] The options for fetching the member
-   * @returns {Promise<ThreadMember>}
-   */
+  
   fetchMe(options) {
     return this.fetch({ ...options, member: this.client.user.id });
   }
 
-  /**
-   * The client user as a ThreadMember of this ThreadChannel
-   * @type {?ThreadMember}
-   * @readonly
-   */
+  
   get me() {
     return this.resolve(this.client.user.id);
   }
 
-  /**
-   * Data that resolves to give a ThreadMember object. This can be:
-   * * A ThreadMember object
-   * * A User resolvable
-   * @typedef {ThreadMember|UserResolvable} ThreadMemberResolvable
-   */
-
-  /**
-   * Resolves a {@link ThreadMemberResolvable} to a {@link ThreadMember} object.
-   * @param {ThreadMemberResolvable} member The user that is part of the thread
-   * @returns {?GuildMember}
-   */
+  
+
+  
   resolve(member) {
     const memberResolvable = super.resolve(member);
     if (memberResolvable) return memberResolvable;
@@ -76,11 +49,7 @@ class ThreadMemberManager extends CachedManager {
     return null;
   }
 
-  /**
-   * Resolves a {@link ThreadMemberResolvable} to a {@link ThreadMember} id string.
-   * @param {ThreadMemberResolvable} member The user that is part of the guild
-   * @returns {?Snowflake}
-   */
+  
   resolveId(member) {
     const memberResolvable = super.resolveId(member);
     if (memberResolvable) return memberResolvable;
@@ -88,12 +57,7 @@ class ThreadMemberManager extends CachedManager {
     return this.cache.has(userResolvable) ? userResolvable : null;
   }
 
-  /**
-   * Adds a member to the thread.
-   * @param {UserResolvable|'@me'} member The member to add
-   * @param {string} [reason] The reason for adding this member
-   * @returns {Promise<Snowflake>}
-   */
+  
   async add(member, reason) {
     const id = member === '@me' ? member : this.client.users.resolveId(member);
     if (!id) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'member', 'UserResolvable');
@@ -101,54 +65,21 @@ class ThreadMemberManager extends CachedManager {
     return id;
   }
 
-  /**
-   * Remove a user from the thread.
-   * @param {Snowflake|'@me'} id The id of the member to remove
-   * @param {string} [reason] The reason for removing this member from the thread
-   * @returns {Promise<Snowflake>}
-   */
+  
   async remove(id, reason) {
     await this.client.rest.delete(Routes.threadMembers(this.thread.id, id), { reason });
     return id;
   }
 
-  /**
-   * Options used to fetch a thread member.
-   * @typedef {BaseFetchOptions} FetchThreadMemberOptions
-   * @property {ThreadMemberResolvable} member The thread member to fetch
-   * @property {boolean} [withMember] Whether to also return the guild member associated with this thread member
-   */
-
-  /**
-   * Options used to fetch multiple thread members with guild member data.
-   * <info>With `withMember` set to `true`, pagination is enabled.</info>
-   * @typedef {Object} FetchThreadMembersWithGuildMemberDataOptions
-   * @property {true} withMember Whether to also return the guild member data
-   * @property {Snowflake} [after] Consider only thread members after this id
-   * @property {number} [limit] The maximum number of thread members to return
-   * @property {boolean} [cache] Whether to cache the fetched thread members and guild members
-   */
-
-  /**
-   * Options used to fetch multiple thread members without guild member data.
-   * @typedef {Object} FetchThreadMembersWithoutGuildMemberDataOptions
-   * @property {false} [withMember] Whether to also return the guild member data
-   * @property {boolean} [cache] Whether to cache the fetched thread members
-   */
-
-  /**
-   * Options used to fetch multiple thread members.
-   * @typedef {FetchThreadMembersWithGuildMemberDataOptions|
-   * FetchThreadMembersWithoutGuildMemberDataOptions} FetchThreadMembersOptions
-   */
-
-  /**
-   * Fetches thread member(s) from Discord.
-   * <info>This method requires the {@link GatewayIntentBits.GuildMembers} privileged gateway intent.</info>
-   * @param {ThreadMemberResolvable|FetchThreadMemberOptions|FetchThreadMembersOptions} [options]
-   * Options for fetching thread member(s)
-   * @returns {Promise<ThreadMember|Collection<Snowflake, ThreadMember>>}
-   */
+  
+
+  
+
+  
+
+  
+
+  
   fetch(options) {
     if (!options) return this._fetchMany();
     const { member, withMember, cache, force } = options;

package/src/managers/UserManager.js

@@ -8,47 +8,22 @@ const { Message } = require('../structures/Message');
 const ThreadMember = require('../structures/ThreadMember');
 const User = require('../structures/User');
 
-/**
- * Manages API methods for users and stores their cache.
- * @extends {CachedManager}
- */
+
 class UserManager extends CachedManager {
   constructor(client, iterable) {
     super(client, User, iterable);
   }
 
-  /**
-   * The cache of this manager
-   * @type {Collection<Snowflake, User>}
-   * @name UserManager#cache
-   */
-
-  /**
-   * Data that resolves to give a User object. This can be:
-   * * A User object
-   * * A Snowflake
-   * * A Message object (resolves to the message author)
-   * * A GuildMember object
-   * * A ThreadMember object
-   * @typedef {User|Snowflake|Message|GuildMember|ThreadMember} UserResolvable
-   */
-
-  /**
-   * The DM between the client's user and a user
-   * @param {Snowflake} userId The user id
-   * @returns {?DMChannel}
-   * @private
-   */
+  
+
+  
+
+  
   dmChannel(userId) {
     return this.client.channels.cache.find(c => c.type === ChannelType.DM && c.recipientId === userId) ?? null;
   }
 
-  /**
-   * Creates a {@link DMChannel} between the client and a user.
-   * @param {UserResolvable} user The UserResolvable to identify
-   * @param {BaseFetchOptions} [options] Additional options for this fetch
-   * @returns {Promise<DMChannel>}
-   */
+  
   async createDM(user, { cache = true, force = false } = {}) {
     const id = this.resolveId(user);
 
@@ -61,11 +36,7 @@ class UserManager extends CachedManager {
     return this.client.channels._add(data, null, { cache });
   }
 
-  /**
-   * Deletes a {@link DMChannel} (if one exists) between the client and a user. Resolves with the channel if successful.
-   * @param {UserResolvable} user The UserResolvable to identify
-   * @returns {Promise<DMChannel>}
-   */
+  
   async deleteDM(user) {
     const id = this.resolveId(user);
     const dmChannel = this.dmChannel(id);
@@ -75,12 +46,7 @@ class UserManager extends CachedManager {
     return dmChannel;
   }
 
-  /**
-   * Obtains a user from Discord, or the user cache if it's already available.
-   * @param {UserResolvable} user The user to fetch
-   * @param {BaseFetchOptions} [options] Additional options for this fetch
-   * @returns {Promise<User>}
-   */
+  
   async fetch(user, { cache = true, force = false } = {}) {
     const id = this.resolveId(user);
     if (!force) {
@@ -92,42 +58,24 @@ class UserManager extends CachedManager {
     return this._add(data, cache);
   }
 
-  /**
-   * Fetches a user's flags.
-   * @param {UserResolvable} user The UserResolvable to identify
-   * @param {BaseFetchOptions} [options] Additional options for this fetch
-   * @returns {Promise<UserFlagsBitField>}
-   */
+  
   async fetchFlags(user, options) {
     return (await this.fetch(user, options)).flags;
   }
 
-  /**
-   * Sends a message to a user.
-   * @param {UserResolvable} user The UserResolvable to identify
-   * @param {string|MessagePayload|MessageCreateOptions} options The options to provide
-   * @returns {Promise<Message>}
-   */
+  
   async send(user, options) {
     return (await this.createDM(user)).send(options);
   }
 
-  /**
-   * Resolves a {@link UserResolvable} to a {@link User} object.
-   * @param {UserResolvable} user The UserResolvable to identify
-   * @returns {?User}
-   */
+  
   resolve(user) {
     if (user instanceof GuildMember || user instanceof ThreadMember) return user.user;
     if (user instanceof Message) return user.author;
     return super.resolve(user);
   }
 
-  /**
-   * Resolves a {@link UserResolvable} to a {@link User} id.
-   * @param {UserResolvable} user The UserResolvable to identify
-   * @returns {?Snowflake}
-   */
+  
   resolveId(user) {
     if (user instanceof ThreadMember) return user.id;
     if (user instanceof GuildMember) return user.user.id;

package/src/managers/VoiceStateManager.js

@@ -3,26 +3,16 @@
 const CachedManager = require('./CachedManager');
 const VoiceState = require('../structures/VoiceState');
 
-/**
- * Manages API methods for VoiceStates and stores their cache.
- * @extends {CachedManager}
- */
+
 class VoiceStateManager extends CachedManager {
   constructor(guild, iterable) {
     super(guild.client, VoiceState, iterable);
 
-    /**
-     * The guild this manager belongs to
-     * @type {Guild}
-     */
+    
     this.guild = guild;
   }
 
-  /**
-   * The cache of this manager
-   * @type {Collection<Snowflake, VoiceState>}
-   * @name VoiceStateManager#cache
-   */
+  
 
   _add(data, cache = true) {
     const existing = this.cache.get(data.user_id);