@velliajs/discord 1.0.2 → 1.0.4

package/src/managers/CategoryChannelChildManager.js

@@ -3,69 +3,27 @@
 const DataManager = require('./DataManager');
 const GuildChannel = require('../structures/GuildChannel');
 
-/**
- * Manages API methods for CategoryChannels' children.
- * @extends {DataManager}
- */
+
 class CategoryChannelChildManager extends DataManager {
   constructor(channel) {
     super(channel.client, GuildChannel);
-    /**
-     * The category channel this manager belongs to
-     * @type {CategoryChannel}
-     */
+    
     this.channel = channel;
   }
 
-  /**
-   * The channels that are a part of this category
-   * @type {Collection<Snowflake, GuildChannel>}
-   * @readonly
-   */
+  
   get cache() {
     return this.guild.channels.cache.filter(c => c.parentId === this.channel.id);
   }
 
-  /**
-   * The guild this manager belongs to
-   * @type {Guild}
-   * @readonly
-   */
+  
   get guild() {
     return this.channel.guild;
   }
 
-  /**
-   * Options for creating a channel using {@link CategoryChannel#createChannel}.
-   * @typedef {Object} CategoryCreateChannelOptions
-   * @property {string} name The name for the new channel
-   * @property {ChannelType} [type=ChannelType.GuildText] The type of the new channel.
-   * @property {string} [topic] The topic for the new channel
-   * @property {boolean} [nsfw] Whether the new channel is NSFW
-   * @property {number} [bitrate] Bitrate of the new channel in bits (only voice)
-   * @property {number} [userLimit] Maximum amount of users allowed in the new channel (only voice)
-   * @property {OverwriteResolvable[]|Collection<Snowflake, OverwriteResolvable>} [permissionOverwrites]
-   * Permission overwrites of the new channel
-   * @property {number} [position] Position of the new channel
-   * @property {number} [rateLimitPerUser] The rate limit per user (slowmode) for the new channel in seconds
-   * @property {string} [rtcRegion] The specific region of the new channel.
-   * @property {VideoQualityMode} [videoQualityMode] The camera video quality mode of the voice channel
-   * @property {GuildForumTagData[]} [availableTags] The tags that can be used in this channel (forum only).
-   * @property {DefaultReactionEmoji} [defaultReactionEmoji]
-   * The emoji to show in the add reaction button on a thread in a guild forum channel.
-   * @property {ThreadAutoArchiveDuration} [defaultAutoArchiveDuration]
-   * The default auto archive duration for all new threads in this channel
-   * @property {SortOrderType} [defaultSortOrder] The default sort order mode used to order posts (forum only).
-   * @property {ForumLayoutType} [defaultForumLayout] The default layout used to display posts (forum only).
-   * @property {string} [reason] Reason for creating the new channel
-   */
+  
 
-  /**
-   * Creates a new channel within this category.
-   * <info>You cannot create a channel of type {@link ChannelType.GuildCategory} inside a CategoryChannel.</info>
-   * @param {CategoryCreateChannelOptions} options Options for creating the new channel
-   * @returns {Promise<GuildChannel>}
-   */
+  
   create(options) {
     return this.guild.channels.create({
       ...options,

package/src/managers/ChannelManager.js

@@ -10,10 +10,7 @@ const Events = require('../util/Events');
 
 let cacheWarningEmitted = false;
 
-/**
- * A manager of channels belonging to a client
- * @extends {CachedManager}
- */
+
 class ChannelManager extends CachedManager {
   constructor(client, iterable) {
     super(client, BaseChannel, iterable);
@@ -30,11 +27,7 @@ class ChannelManager extends CachedManager {
     }
   }
 
-  /**
-   * The cache of Channels
-   * @type {Collection<Snowflake, BaseChannel>}
-   * @name ChannelManager#cache
-   */
+  
 
   _add(data, guild, { cache = true, allowUnknownGuild = false } = {}) {
     const existing = this.cache.get(data.id);
@@ -71,49 +64,15 @@ class ChannelManager extends CachedManager {
     this.cache.delete(id);
   }
 
-  /**
-   * Data that can be resolved to give a Channel object. This can be:
-   * * A Channel object
-   * * A Snowflake
-   * @typedef {BaseChannel|Snowflake} ChannelResolvable
-   */
-
-  /**
-   * Resolves a ChannelResolvable to a Channel object.
-   * @method resolve
-   * @memberof ChannelManager
-   * @instance
-   * @param {ChannelResolvable} channel The channel resolvable to resolve
-   * @returns {?BaseChannel}
-   */
-
-  /**
-   * Resolves a ChannelResolvable to a channel id string.
-   * @method resolveId
-   * @memberof ChannelManager
-   * @instance
-   * @param {ChannelResolvable} channel The channel resolvable to resolve
-   * @returns {?Snowflake}
-   */
-
-  /**
-   * Options for fetching a channel from Discord
-   * @typedef {BaseFetchOptions} FetchChannelOptions
-   * @property {boolean} [allowUnknownGuild=false] Allows the channel to be returned even if the guild is not in cache,
-   * it will not be cached. <warn>Many of the properties and methods on the returned channel will throw errors</warn>
-   */
-
-  /**
-   * Obtains a channel from Discord, or the channel cache if it's already available.
-   * @param {Snowflake} id The channel's id
-   * @param {FetchChannelOptions} [options] Additional options for this fetch
-   * @returns {Promise<?BaseChannel>}
-   * @example
-   * // Fetch a channel by its id
-   * client.channels.fetch('222109930545610754')
-   *   .then(channel => console.log(channel.name))
-   *   .catch(console.error);
-   */
+  
+
+  
+
+  
+
+  
+
+  
   async fetch(id, { allowUnknownGuild = false, cache = true, force = false } = {}) {
     if (!force) {
       const existing = this.cache.get(id);

package/src/managers/DataManager.js

@@ -3,50 +3,28 @@
 const BaseManager = require('./BaseManager');
 const { DiscordjsError, ErrorCodes } = require('../errors');
 
-/**
- * Manages the API methods of a data model along with a collection of instances.
- * @extends {BaseManager}
- * @abstract
- */
+
 class DataManager extends BaseManager {
   constructor(client, holds) {
     super(client);
 
-    /**
-     * The data structure belonging to this manager.
-     * @name DataManager#holds
-     * @type {Function}
-     * @private
-     * @readonly
-     */
+    
     Object.defineProperty(this, 'holds', { value: holds });
   }
 
-  /**
-   * The cache of items for this manager.
-   * @type {Collection}
-   * @abstract
-   */
+  
   get cache() {
     throw new DiscordjsError(ErrorCodes.NotImplemented, 'get cache', this.constructor.name);
   }
 
-  /**
-   * Resolves a data entry to a data Object.
-   * @param {string|Object} idOrInstance The id or instance of something in this Manager
-   * @returns {?Object} An instance from this Manager
-   */
+  
   resolve(idOrInstance) {
     if (idOrInstance instanceof this.holds) return idOrInstance;
     if (typeof idOrInstance === 'string') return this.cache.get(idOrInstance) ?? null;
     return null;
   }
 
-  /**
-   * Resolves a data entry to an instance id.
-   * @param {string|Object} idOrInstance The id or instance of something in this Manager
-   * @returns {?Snowflake}
-   */
+  
   resolveId(idOrInstance) {
     if (idOrInstance instanceof this.holds) return idOrInstance.id;
     if (typeof idOrInstance === 'string') return idOrInstance;

package/src/managers/GuildApplicationCommandManager.js

@@ -3,24 +3,15 @@
 const ApplicationCommandManager = require('./ApplicationCommandManager');
 const ApplicationCommandPermissionsManager = require('./ApplicationCommandPermissionsManager');
 
-/**
- * An extension for guild-specific application commands.
- * @extends {ApplicationCommandManager}
- */
+
 class GuildApplicationCommandManager extends ApplicationCommandManager {
   constructor(guild, iterable) {
     super(guild.client, iterable);
 
-    /**
-     * The guild that this manager belongs to
-     * @type {Guild}
-     */
+    
     this.guild = guild;
 
-    /**
-     * The manager for permissions of arbitrary commands on this guild
-     * @type {ApplicationCommandPermissionsManager}
-     */
+    
     this.permissions = new ApplicationCommandPermissionsManager(this);
   }
 }

package/src/managers/GuildBanManager.js

@@ -11,92 +11,33 @@ const { GuildMember } = require('../structures/GuildMember');
 
 let deprecationEmittedForDeleteMessageDays = false;
 
-/**
- * Manages API methods for guild bans and stores their cache.
- * @extends {CachedManager}
- */
+
 class GuildBanManager extends CachedManager {
   constructor(guild, iterable) {
     super(guild.client, GuildBan, iterable);
 
-    /**
-     * The guild this Manager belongs to
-     * @type {Guild}
-     */
+    
     this.guild = guild;
   }
 
-  /**
-   * The cache of this Manager
-   * @type {Collection<Snowflake, GuildBan>}
-   * @name GuildBanManager#cache
-   */
+  
 
   _add(data, cache) {
     return super._add(data, cache, { id: data.user.id, extras: [this.guild] });
   }
 
-  /**
-   * Data that resolves to give a GuildBan object. This can be:
-   * * A GuildBan object
-   * * A User resolvable
-   * @typedef {GuildBan|UserResolvable} GuildBanResolvable
-   */
-
-  /**
-   * Resolves a GuildBanResolvable to a GuildBan object.
-   * @param {GuildBanResolvable} ban The ban that is in the guild
-   * @returns {?GuildBan}
-   */
+  
+
+  
   resolve(ban) {
     return super.resolve(ban) ?? super.resolve(this.client.users.resolveId(ban));
   }
 
-  /**
-   * Options used to fetch a single ban from a guild.
-   * @typedef {BaseFetchOptions} FetchBanOptions
-   * @property {UserResolvable} user The ban to fetch
-   */
-
-  /**
-   * Options used to fetch multiple bans from a guild.
-   * @typedef {Object} FetchBansOptions
-   * @property {number} [limit] The maximum number of bans to return
-   * @property {Snowflake} [before] Consider only bans before this id
-   * @property {Snowflake} [after] Consider only bans after this id
-   * @property {boolean} [cache] Whether to cache the fetched bans
-   */
-
-  /**
-   * Fetches ban(s) from Discord.
-   * @param {UserResolvable|FetchBanOptions|FetchBansOptions} [options] Options for fetching guild ban(s)
-   * @returns {Promise<GuildBan|Collection<Snowflake, GuildBan>>}
-   * @example
-   * // Fetch multiple bans from a guild
-   * guild.bans.fetch()
-   *   .then(console.log)
-   *   .catch(console.error);
-   * @example
-   * // Fetch a maximum of 5 bans from a guild without caching
-   * guild.bans.fetch({ limit: 5, cache: false })
-   *   .then(console.log)
-   *   .catch(console.error);
-   * @example
-   * // Fetch a single ban
-   * guild.bans.fetch('351871113346809860')
-   *   .then(console.log)
-   *   .catch(console.error);
-   * @example
-   * // Fetch a single ban without checking cache
-   * guild.bans.fetch({ user, force: true })
-   *   .then(console.log)
-   *   .catch(console.error)
-   * @example
-   * // Fetch a single ban without caching
-   * guild.bans.fetch({ user, cache: false })
-   *   .then(console.log)
-   *   .catch(console.error);
-   */
+  
+
+  
+
+  
   fetch(options) {
     if (!options) return this._fetchMany();
     const { user, cache, force, limit, before, after } = options;
@@ -128,29 +69,9 @@ class GuildBanManager extends CachedManager {
     return data.reduce((col, ban) => col.set(ban.user.id, this._add(ban, options.cache)), new Collection());
   }
 
-  /**
-   * Options used to ban a user from a guild.
-   * @typedef {Object} BanOptions
-   * @property {number} [deleteMessageDays] Number of days of messages to delete, must be between 0 and 7, inclusive
-   * <warn>This property is deprecated. Use `deleteMessageSeconds` instead.</warn>
-   * @property {number} [deleteMessageSeconds] Number of seconds of messages to delete,
-   * must be between 0 and 604800 (7 days), inclusive
-   * @property {string} [reason] The reason for the ban
-   */
-
-  /**
-   * 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.
-   * @example
-   * // Ban a user by id (or with a user/guild member object)
-   * guild.bans.create('84484653687267328')
-   *   .then(banInfo => console.log(`Banned ${banInfo.user?.tag ?? banInfo.tag ?? banInfo}`))
-   *   .catch(console.error);
-   */
+  
+
+  
   async create(user, options = {}) {
     if (typeof options !== 'object') throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'options', 'object', true);
     const id = this.client.users.resolveId(user);
@@ -158,7 +79,7 @@ class GuildBanManager extends CachedManager {
 
     if (options.deleteMessageDays !== undefined && !deprecationEmittedForDeleteMessageDays) {
       process.emitWarning(
-        // eslint-disable-next-line max-len
+        
         'The deleteMessageDays option for GuildBanManager#create() is deprecated. Use the deleteMessageSeconds option instead.',
         'DeprecationWarning',
       );
@@ -182,17 +103,7 @@ class GuildBanManager extends CachedManager {
     return id;
   }
 
-  /**
-   * Unbans a user from the guild.
-   * @param {UserResolvable} user The user to unban
-   * @param {string} [reason] Reason for unbanning user
-   * @returns {Promise<?User>}
-   * @example
-   * // Unban a user by id (or with a user/guild member object)
-   * guild.bans.remove('84484653687267328')
-   *   .then(user => console.log(`Unbanned ${user.username} from ${guild.name}`))
-   *   .catch(console.error);
-   */
+  
   async remove(user, reason) {
     const id = this.client.users.resolveId(user);
     if (!id) throw new DiscordjsError(ErrorCodes.BanResolveId);