@velliajs/discord 1.0.2 → 1.0.4

package/src/client/websocket/WebSocketManager.js

@@ -22,7 +22,7 @@ let zlib;
 
 try {
   zlib = require('zlib-sync');
-} catch {} // eslint-disable-line no-empty
+} catch {} 
 
 const BeforeReadyWhitelist = [
   GatewayDispatchEvents.Ready,
@@ -46,81 +46,40 @@ const reasonIsDeprecated = 'the reason property is deprecated, use the code prop
 let deprecationEmittedForInvalidSessionEvent = false;
 let deprecationEmittedForDestroyedEvent = false;
 
-/**
- * The WebSocket manager for this client.
- * <info>This class forwards raw dispatch events,
- * read more about it here {@link https://discord.com/developers/docs/topics/gateway}</info>
- * @extends {EventEmitter}
- */
+
 class WebSocketManager extends EventEmitter {
   constructor(client) {
     super();
 
-    /**
-     * The client that instantiated this WebSocketManager
-     * @type {Client}
-     * @readonly
-     * @name WebSocketManager#client
-     */
+    
     Object.defineProperty(this, 'client', { value: client });
 
-    /**
-     * The gateway this manager uses
-     * @type {?string}
-     */
+    
     this.gateway = null;
 
-    /**
-     * A collection of all shards this manager handles
-     * @type {Collection<number, WebSocketShard>}
-     */
+    
     this.shards = new Collection();
 
-    /**
-     * An array of queued events before this WebSocketManager became ready
-     * @type {Object[]}
-     * @private
-     * @name WebSocketManager#packetQueue
-     */
+    
     Object.defineProperty(this, 'packetQueue', { value: [] });
 
-    /**
-     * The current status of this WebSocketManager
-     * @type {Status}
-     */
+    
     this.status = Status.Idle;
 
-    /**
-     * If this manager was destroyed. It will prevent shards from reconnecting
-     * @type {boolean}
-     * @private
-     */
+    
     this.destroyed = false;
 
-    /**
-     * The internal WebSocketManager from `@discordjs/ws`.
-     * @type {WSWebSocketManager}
-     * @private
-     */
+    
     this._ws = null;
   }
 
-  /**
-   * The average ping of all WebSocketShards
-   * @type {number}
-   * @readonly
-   */
+  
   get ping() {
     const sum = this.shards.reduce((a, b) => a + b.ping, 0);
     return sum / this.shards.size;
   }
 
-  /**
-   * Emits a debug message.
-   * @param {string} message The debug message
-   * @param {?number} [shardId] The id of the shard that emitted this message, if any
-   * @private
-   */
+  
   debug(message, shardId) {
     this.client.emit(
       Events.Debug,
@@ -128,10 +87,7 @@ class WebSocketManager extends EventEmitter {
     );
   }
 
-  /**
-   * Connects this manager to the gateway.
-   * @private
-   */
+  
   async connect() {
     const invalidToken = new DiscordjsError(ErrorCodes.TokenInvalid);
     const { shards, shardCount, intents, ws } = this.client.options;
@@ -189,12 +145,7 @@ class WebSocketManager extends EventEmitter {
         this.shards.set(id, shard);
 
         shard.on(WebSocketShardEvents.AllReady, unavailableGuilds => {
-          /**
-           * Emitted when a shard turns ready.
-           * @event Client#shardReady
-           * @param {number} id The shard id that turned ready
-           * @param {?Set<Snowflake>} unavailableGuilds Set of unavailable guild ids, if any
-           */
+          
           this.client.emit(Events.ShardReady, shard.id, unavailableGuilds);
 
           this.checkShardsReady();
@@ -225,10 +176,7 @@ class WebSocketManager extends EventEmitter {
     });
   }
 
-  /**
-   * Attaches event handlers to the internal WebSocketShardManager from `@discordjs/ws`.
-   * @private
-   */
+  
   attachEvents() {
     this._ws.on(WSWebSocketShardEvents.Debug, ({ message, shardId }) => this.debug(message, shardId));
     this._ws.on(WSWebSocketShardEvents.Dispatch, ({ data, shardId }) => {
@@ -250,23 +198,14 @@ class WebSocketManager extends EventEmitter {
       shard.emit(WebSocketShardEvents.Close, { code, reason: reasonIsDeprecated, wasClean: true });
       if (UNRESUMABLE_CLOSE_CODES.includes(code) && this.destroyed) {
         shard.status = Status.Disconnected;
-        /**
-         * Emitted when a shard's WebSocket disconnects and will no longer reconnect.
-         * @event Client#shardDisconnect
-         * @param {CloseEvent} event The WebSocket close event
-         * @param {number} id The shard id that disconnected
-         */
+        
         this.client.emit(Events.ShardDisconnect, { code, reason: reasonIsDeprecated, wasClean: true }, shardId);
         this.debug(GatewayCloseCodes[code], shardId);
         return;
       }
 
       this.shards.get(shardId).status = Status.Connecting;
-      /**
-       * Emitted when a shard is attempting to reconnect or re-identify.
-       * @event Client#shardReconnecting
-       * @param {number} id The shard id that is attempting to reconnect
-       */
+      
       this.client.emit(Events.ShardReconnecting, shardId);
     });
     this._ws.on(WSWebSocketShardEvents.Hello, ({ shardId }) => {
@@ -282,10 +221,7 @@ class WebSocketManager extends EventEmitter {
     this._ws.on(WSWebSocketShardEvents.Resumed, ({ shardId }) => {
       const shard = this.shards.get(shardId);
       shard.status = Status.Ready;
-      /**
-       * Emitted when the shard resumes successfully
-       * @event WebSocketShard#resumed
-       */
+      
       shard.emit(WebSocketShardEvents.Resumed);
     });
 
@@ -297,44 +233,26 @@ class WebSocketManager extends EventEmitter {
     });
 
     this._ws.on(WSWebSocketShardEvents.Error, ({ error, shardId }) => {
-      /**
-       * Emitted whenever a shard's WebSocket encounters a connection error.
-       * @event Client#shardError
-       * @param {Error} error The encountered error
-       * @param {number} shardId The shard that encountered this error
-       */
+      
       this.client.emit(Events.ShardError, error, shardId);
     });
   }
 
-  /**
-   * Broadcasts a packet to every shard this manager handles.
-   * @param {Object} packet The packet to send
-   * @private
-   */
+  
   broadcast(packet) {
     for (const shardId of this.shards.keys()) this._ws.send(shardId, packet);
   }
 
-  /**
-   * Destroys this manager and all its shards.
-   * @private
-   */
+  
   destroy() {
     if (this.destroyed) return;
-    // TODO: Make a util for getting a stack
+    
     this.debug(`Manager was destroyed. Called by:\n${new Error().stack}`);
     this.destroyed = true;
     this._ws.destroy({ code: CloseCodes.Normal });
   }
 
-  /**
-   * Processes a packet and queues it if this WebSocketManager is not ready.
-   * @param {Object} [packet] The packet to be handled
-   * @param {WebSocketShard} [shard] The shard that will handle this packet
-   * @returns {boolean}
-   * @private
-   */
+  
   handlePacket(packet, shard) {
     if (packet && this.status !== Status.Ready) {
       if (!BeforeReadyWhitelist.includes(packet.t)) {
@@ -357,10 +275,7 @@ class WebSocketManager extends EventEmitter {
     return true;
   }
 
-  /**
-   * Checks whether the client is ready to be marked as ready.
-   * @private
-   */
+  
   checkShardsReady() {
     if (this.status === Status.Ready) return;
     if (this.shards.size !== this.totalShards || this.shards.some(s => s.status !== Status.Ready)) {
@@ -370,20 +285,13 @@ class WebSocketManager extends EventEmitter {
     this.triggerClientReady();
   }
 
-  /**
-   * Causes the client to be marked as ready and emits the ready event.
-   * @private
-   */
+  
   triggerClientReady() {
     this.status = Status.Ready;
 
     this.client.readyTimestamp = Date.now();
 
-    /**
-     * Emitted when the client becomes ready to start working.
-     * @event Client#ready
-     * @param {Client} client The client
-     */
+    
     this.client.emit(Events.ClientReady, this.client);
 
     this.handlePacket();

package/src/client/websocket/WebSocketShard.js

@@ -8,101 +8,49 @@ const Status = require('../../util/Status');
 const WebSocketShardEvents = require('../../util/WebSocketShardEvents');
 
 let deprecationEmittedForImportant = false;
-/**
- * Represents a Shard's WebSocket connection
- * @extends {EventEmitter}
- */
+
 class WebSocketShard extends EventEmitter {
   constructor(manager, id) {
     super();
 
-    /**
-     * The WebSocketManager of the shard
-     * @type {WebSocketManager}
-     */
+    
     this.manager = manager;
 
-    /**
-     * The shard's id
-     * @type {number}
-     */
+    
     this.id = id;
 
-    /**
-     * The current status of the shard
-     * @type {Status}
-     */
+    
     this.status = Status.Idle;
 
-    /**
-     * The sequence of the shard after close
-     * @type {number}
-     * @private
-     */
+    
     this.closeSequence = 0;
 
-    /**
-     * The previous heartbeat ping of the shard
-     * @type {number}
-     */
+    
     this.ping = -1;
 
-    /**
-     * The last time a ping was sent (a timestamp)
-     * @type {number}
-     */
+    
     this.lastPingTimestamp = -1;
 
-    /**
-     * A set of guild ids this shard expects to receive
-     * @name WebSocketShard#expectedGuilds
-     * @type {?Set<string>}
-     * @private
-     */
+    
     Object.defineProperty(this, 'expectedGuilds', { value: null, writable: true });
 
-    /**
-     * The ready timeout
-     * @name WebSocketShard#readyTimeout
-     * @type {?NodeJS.Timeout}
-     * @private
-     */
+    
     Object.defineProperty(this, 'readyTimeout', { value: null, writable: true });
 
-    /**
-     * @external SessionInfo
-     * @see {@link https://discord.js.org/#/docs/ws/main/typedef/SessionInfo}
-     */
-
-    /**
-     * The session info used by `@discordjs/ws` package.
-     * @name WebSocketShard#sessionInfo
-     * @type {?SessionInfo}
-     * @private
-     */
+    
+
+    
     Object.defineProperty(this, 'sessionInfo', { value: null, writable: true });
   }
 
-  /**
-   * Emits a debug event.
-   * @param {string} message The debug message
-   * @private
-   */
+  
   debug(message) {
     this.manager.debug(message, this.id);
   }
 
-  /**
-   * @external CloseEvent
-   * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent}
-   */
-
-  /**
-   * This method is responsible to emit close event for this shard.
-   * This method helps the shard reconnect.
-   * @param {CloseEvent} [event] Close event that was received
-   * @deprecated
-   */
+  
+
+  
   emitClose(
     event = {
       code: 1011,
@@ -114,78 +62,51 @@ class WebSocketShard extends EventEmitter {
     Event Code: ${event.code}
     Clean     : ${event.wasClean}
     Reason    : ${event.reason ?? 'No reason received'}`);
-    /**
-     * Emitted when a shard's WebSocket closes.
-     * @private
-     * @event WebSocketShard#close
-     * @param {CloseEvent} event The received event
-     */
+    
     this.emit(WebSocketShardEvents.Close, event);
   }
 
-  /**
-   * Called when the shard receives the READY payload.
-   * @param {Object} packet The received packet
-   * @private
-   */
+  
   onReadyPacket(packet) {
     if (!packet) {
       this.debug(`Received broken packet: '${packet}'.`);
       return;
     }
 
-    /**
-     * Emitted when the shard receives the READY payload and is now waiting for guilds
-     * @event WebSocketShard#ready
-     */
+    
     this.emit(WebSocketShardEvents.Ready);
 
     this.expectedGuilds = new Set(packet.guilds.map(d => d.id));
     this.status = Status.WaitingForGuilds;
   }
 
-  /**
-   * Called when a GuildCreate or GuildDelete for this shard was sent after READY payload was received,
-   * but before we emitted the READY event.
-   * @param {Snowflake} guildId the id of the Guild sent in the payload
-   * @private
-   */
+  
   gotGuild(guildId) {
     this.expectedGuilds.delete(guildId);
     this.checkReady();
   }
 
-  /**
-   * Checks if the shard can be marked as ready
-   * @private
-   */
+  
   checkReady() {
-    // Step 0. Clear the ready timeout, if it exists
+    
     if (this.readyTimeout) {
       clearTimeout(this.readyTimeout);
       this.readyTimeout = null;
     }
-    // Step 1. If we don't have any other guilds pending, we are ready
+    
     if (!this.expectedGuilds.size) {
       this.debug('Shard received all its guilds. Marking as fully ready.');
       this.status = Status.Ready;
 
-      /**
-       * Emitted when the shard is fully ready.
-       * This event is emitted if:
-       * * all guilds were received by this shard
-       * * the ready timeout expired, and some guilds are unavailable
-       * @event WebSocketShard#allReady
-       * @param {?Set<string>} unavailableGuilds Set of unavailable guilds, if any
-       */
+      
       this.emit(WebSocketShardEvents.AllReady);
       return;
     }
     const hasGuildsIntent = this.manager.client.options.intents.has(GatewayIntentBits.Guilds);
-    // Step 2. Create a timeout that will mark the shard as ready if there are still unavailable guilds
-    // * The timeout is 15 seconds by default
-    // * This can be optionally changed in the client options via the `waitGuildTimeout` option
-    // * a timeout time of zero will skip this timeout, which potentially could cause the Client to miss guilds.
+    
+    
+    
+    
 
     const { waitGuildTimeout } = this.manager.client.options;
 
@@ -207,15 +128,7 @@ class WebSocketShard extends EventEmitter {
     ).unref();
   }
 
-  /**
-   * Adds a packet to the queue to be sent to the gateway.
-   * <warn>If you use this method, make sure you understand that you need to provide
-   * a full [Payload](https://discord.com/developers/docs/topics/gateway#commands-and-events-gateway-commands).
-   * Do not use this method if you don't know what you're doing.</warn>
-   * @param {Object} data The full packet to send
-   * @param {boolean} [important=false] If this packet should be added first in queue
-   * <warn>This parameter is **deprecated**. Important payloads are determined by their opcode instead.</warn>
-   */
+  
   send(data, important = false) {
     if (important && !deprecationEmittedForImportant) {
       process.emitWarning(

package/src/client/websocket/handlers/CHANNEL_PINS_UPDATE.js

@@ -7,16 +7,10 @@ module.exports = (client, { d: data }) => {
   const time = data.last_pin_timestamp ? Date.parse(data.last_pin_timestamp) : null;
 
   if (channel) {
-    // Discord sends null for last_pin_timestamp if the last pinned message was removed
+    
     channel.lastPinTimestamp = time;
 
-    /**
-     * Emitted whenever the pins of a channel are updated. Due to the nature of the WebSocket event,
-     * not much information can be provided easily here - you need to manually check the pins yourself.
-     * @event Client#channelPinsUpdate
-     * @param {TextBasedChannels} channel The channel that the pins update occurred in
-     * @param {Date} time The time of the pins update
-     */
+    
     client.emit(Events.ChannelPinsUpdate, channel, time);
   }
 };

package/src/client/websocket/handlers/CHANNEL_UPDATE.js

@@ -5,12 +5,7 @@ const Events = require('../../../util/Events');
 module.exports = (client, packet) => {
   const { old, updated } = client.actions.ChannelUpdate.handle(packet.d);
   if (old && updated) {
-    /**
-     * Emitted whenever a channel is updated - e.g. name change, topic change, channel type change.
-     * @event Client#channelUpdate
-     * @param {DMChannel|GuildChannel} oldChannel The channel before the update
-     * @param {DMChannel|GuildChannel} newChannel The channel after the update
-     */
+    
     client.emit(Events.ChannelUpdate, old, updated);
   }
 };

package/src/client/websocket/handlers/GUILD_CREATE.js

@@ -7,19 +7,15 @@ module.exports = (client, { d: data }, shard) => {
   let guild = client.guilds.cache.get(data.id);
   if (guild) {
     if (!guild.available && !data.unavailable) {
-      // A newly available guild
+      
       guild._patch(data);
     }
   } else {
-    // A new guild
+    
     data.shardId = shard.id;
     guild = client.guilds._add(data);
     if (client.ws.status === Status.Ready) {
-      /**
-       * Emitted whenever the client joins a guild.
-       * @event Client#guildCreate
-       * @param {Guild} guild The created guild
-       */
+      
       client.emit(Events.GuildCreate, guild);
     }
   }

package/src/client/websocket/handlers/GUILD_MEMBERS_CHUNK.js

@@ -13,23 +13,9 @@ module.exports = (client, { d: data }) => {
     for (const presence of data.presences) guild.presences._add(Object.assign(presence, { guild }));
   }
 
-  /**
-   * Represents the properties of a guild members chunk
-   * @typedef {Object} GuildMembersChunk
-   * @property {number} index Index of the received chunk
-   * @property {number} count Number of chunks the client should receive
-   * @property {Array<*>} notFound An array of whatever could not be found
-   * when using {@link GatewayOpcodes.RequestGuildMembers}
-   * @property {?string} nonce Nonce for this chunk
-   */
+  
 
-  /**
-   * Emitted whenever a chunk of guild members is received (all members come from the same guild).
-   * @event Client#guildMembersChunk
-   * @param {Collection<Snowflake, GuildMember>} members The members in the chunk
-   * @param {Guild} guild The guild related to the member chunk
-   * @param {GuildMembersChunk} chunk Properties of the received chunk
-   */
+  
   client.emit(Events.GuildMembersChunk, members, guild, {
     index: data.chunk_index,
     count: data.chunk_count,

package/src/client/websocket/handlers/GUILD_MEMBER_ADD.js

@@ -9,11 +9,7 @@ module.exports = (client, { d: data }, shard) => {
     guild.memberCount++;
     const member = guild.members._add(data);
     if (shard.status === Status.Ready) {
-      /**
-       * Emitted whenever a user joins a guild.
-       * @event Client#guildMemberAdd
-       * @param {GuildMember} member The member that has joined a guild
-       */
+      
       client.emit(Events.GuildMemberAdd, member);
     }
   }

package/src/client/websocket/handlers/MESSAGE_UPDATE.js

@@ -5,12 +5,7 @@ const Events = require('../../../util/Events');
 module.exports = (client, packet) => {
   const { old, updated } = client.actions.MessageUpdate.handle(packet.d);
   if (old && updated) {
-    /**
-     * Emitted whenever a message is updated - e.g. embed or content change.
-     * @event Client#messageUpdate
-     * @param {Message} oldMessage The message before the update
-     * @param {Message} newMessage The message after the update
-     */
+    
     client.emit(Events.MessageUpdate, old, updated);
   }
 };

package/src/client/websocket/handlers/RESUMED.js

@@ -4,11 +4,6 @@ const Events = require('../../../util/Events');
 
 module.exports = (client, packet, shard) => {
   const replayed = shard.sessionInfo.sequence - shard.closeSequence;
-  /**
-   * Emitted when a shard resumes successfully.
-   * @event Client#shardResume
-   * @param {number} id The shard id that resumed
-   * @param {number} replayedEvents The amount of replayed events
-   */
+  
   client.emit(Events.ShardResume, shard.id, replayed);
 };

package/src/client/websocket/handlers/THREAD_UPDATE.js

@@ -5,12 +5,7 @@ const Events = require('../../../util/Events');
 module.exports = (client, packet) => {
   const { old, updated } = client.actions.ChannelUpdate.handle(packet.d);
   if (old && updated) {
-    /**
-     * Emitted whenever a thread is updated - e.g. name change, archive state change, locked state change.
-     * @event Client#threadUpdate
-     * @param {ThreadChannel} oldThread The thread before the update
-     * @param {ThreadChannel} newThread The thread after the update
-     */
+    
     client.emit(Events.ThreadUpdate, old, updated);
   }
 };

package/src/errors/DJSError.js

@@ -1,15 +1,10 @@
 'use strict';
 
-// Heavily inspired by node's `internal/errors` module
+
 const ErrorCodes = require('./ErrorCodes');
 const Messages = require('./Messages');
 
-/**
- * Extend an error of some sort into a DiscordjsError.
- * @param {Error} Base Base error to extend
- * @returns {DiscordjsError}
- * @ignore
- */
+
 function makeDiscordjsError(Base) {
   return class DiscordjsError extends Base {
     constructor(code, ...args) {
@@ -24,13 +19,7 @@ function makeDiscordjsError(Base) {
   };
 }
 
-/**
- * Format the message for an error.
- * @param {string} code The error code
- * @param {Array<*>} args Arguments to pass for util format or as function args
- * @returns {string} Formatted string
- * @ignore
- */
+
 function message(code, args) {
   if (!(code in ErrorCodes)) throw new Error('Error code must be a valid DiscordjsErrorCodes');
   const msg = Messages[code];