@velliajs/discord 1.0.3 → 1.0.4

package/src/sharding/Shard.js

@@ -11,12 +11,7 @@ const { makeError, makePlainError } = require('../util/Util');
 let childProcess = null;
 let Worker = null;
 
-/**
- * A self-contained shard created by the {@link ShardingManager}. Each one has a {@link ChildProcess} that contains
- * an instance of the bot and its {@link Client}. When its child process/worker exits for any reason, the shard will
- * spawn a new one to replace it as necessary.
- * @extends {EventEmitter}
- */
+
 class Shard extends EventEmitter {
   constructor(manager, id) {
     super();
@@ -30,34 +25,19 @@ class Shard extends EventEmitter {
         break;
     }
 
-    /**
-     * Manager that created the shard
-     * @type {ShardingManager}
-     */
+    
     this.manager = manager;
 
-    /**
-     * The shard's id in the manager
-     * @type {number}
-     */
+    
     this.id = id;
 
-    /**
-     * Arguments for the shard's process (only when {@link ShardingManager#mode} is `process`)
-     * @type {string[]}
-     */
+    
     this.args = manager.shardArgs ?? [];
 
-    /**
-     * Arguments for the shard's process executable (only when {@link ShardingManager#mode} is `process`)
-     * @type {string[]}
-     */
+    
     this.execArgv = manager.execArgv;
 
-    /**
-     * Environment variables for the shard's process, or workerData for the shard's worker
-     * @type {Object}
-     */
+    
     this.env = Object.assign({}, process.env, {
       SHARDING_MANAGER: true,
       SHARDS: this.id,
@@ -65,53 +45,26 @@ class Shard extends EventEmitter {
       DISCORD_TOKEN: this.manager.token,
     });
 
-    /**
-     * Whether the shard's {@link Client} is ready
-     * @type {boolean}
-     */
+    
     this.ready = false;
 
-    /**
-     * Process of the shard (if {@link ShardingManager#mode} is `process`)
-     * @type {?ChildProcess}
-     */
+    
     this.process = null;
 
-    /**
-     * Worker of the shard (if {@link ShardingManager#mode} is `worker`)
-     * @type {?Worker}
-     */
+    
     this.worker = null;
 
-    /**
-     * Ongoing promises for calls to {@link Shard#eval}, mapped by the `script` they were called with
-     * @type {Map<string, Promise>}
-     * @private
-     */
+    
     this._evals = new Map();
 
-    /**
-     * Ongoing promises for calls to {@link Shard#fetchClientValue}, mapped by the `prop` they were called with
-     * @type {Map<string, Promise>}
-     * @private
-     */
+    
     this._fetches = new Map();
 
-    /**
-     * Listener function for the {@link ChildProcess}' `exit` event
-     * @type {Function}
-     * @private
-     */
+    
     this._exitListener = null;
   }
 
-  /**
-   * Forks a child process or creates a worker thread for the shard.
-   * <warn>You should not need to call this manually.</warn>
-   * @param {number} [timeout=30000] The amount in milliseconds to wait until the {@link Client} has become ready
-   * before resolving (`-1` or `Infinity` for no wait)
-   * @returns {Promise<ChildProcess>}
-   */
+  
   spawn(timeout = 30_000) {
     if (this.process) throw new DiscordjsError(ErrorCodes.ShardingProcessExists, this.id);
     if (this.worker) throw new DiscordjsError(ErrorCodes.ShardingWorkerExists, this.id);
@@ -140,11 +93,7 @@ class Shard extends EventEmitter {
 
     const child = this.process ?? this.worker;
 
-    /**
-     * Emitted upon the creation of the shard's child process/worker.
-     * @event Shard#spawn
-     * @param {ChildProcess|Worker} process Child process/worker that was created
-     */
+    
     this.emit(ShardEvents.Spawn, child);
 
     if (timeout === -1 || timeout === Infinity) return Promise.resolve(child);
@@ -183,9 +132,7 @@ class Shard extends EventEmitter {
     });
   }
 
-  /**
-   * Immediately kills the shard's process/worker and does not restart it.
-   */
+  
   kill() {
     if (this.process) {
       this.process.removeListener('exit', this._exitListener);
@@ -198,31 +145,16 @@ class Shard extends EventEmitter {
     this._handleExit(false);
   }
 
-  /**
-   * Options used to respawn a shard.
-   * @typedef {Object} ShardRespawnOptions
-   * @property {number} [delay=500] How long to wait between killing the process/worker and
-   * restarting it (in milliseconds)
-   * @property {number} [timeout=30000] The amount in milliseconds to wait until the {@link Client}
-   * has become ready before resolving (`-1` or `Infinity` for no wait)
-   */
-
-  /**
-   * Kills and restarts the shard's process/worker.
-   * @param {ShardRespawnOptions} [options] Options for respawning the shard
-   * @returns {Promise<ChildProcess>}
-   */
+  
+
+  
   async respawn({ delay = 500, timeout = 30_000 } = {}) {
     this.kill();
     if (delay > 0) await sleep(delay);
     return this.spawn(timeout);
   }
 
-  /**
-   * Sends a message to the shard's process/worker.
-   * @param {*} message Message to send to the shard
-   * @returns {Promise<Shard>}
-   */
+  
   send(message) {
     return new Promise((resolve, reject) => {
       if (this.process) {
@@ -237,22 +169,14 @@ class Shard extends EventEmitter {
     });
   }
 
-  /**
-   * Fetches a client property value of the shard.
-   * @param {string} prop Name of the client property to get, using periods for nesting
-   * @returns {Promise<*>}
-   * @example
-   * shard.fetchClientValue('guilds.cache.size')
-   *   .then(count => console.log(`${count} guilds in shard ${shard.id}`))
-   *   .catch(console.error);
-   */
+  
   fetchClientValue(prop) {
-    // Shard is dead (maybe respawning), don't cache anything and error immediately
+    
     if (!this.process && !this.worker) {
       return Promise.reject(new DiscordjsError(ErrorCodes.ShardingNoChildExists, this.id));
     }
 
-    // Cached promise from previous call
+    
     if (this._fetches.has(prop)) return this._fetches.get(prop);
 
     const promise = new Promise((resolve, reject) => {
@@ -282,22 +206,17 @@ class Shard extends EventEmitter {
     return promise;
   }
 
-  /**
-   * Evaluates a script or function on the shard, in the context of the {@link Client}.
-   * @param {string|Function} script JavaScript to run on the shard
-   * @param {*} [context] The context for the eval
-   * @returns {Promise<*>} Result of the script execution
-   */
+  
   eval(script, context) {
-    // Stringify the script if it's a Function
+    
     const _eval = typeof script === 'function' ? `(${script})(this, ${JSON.stringify(context)})` : script;
 
-    // Shard is dead (maybe respawning), don't cache anything and error immediately
+    
     if (!this.process && !this.worker) {
       return Promise.reject(new DiscordjsError(ErrorCodes.ShardingNoChildExists, this.id));
     }
 
-    // Cached promise from previous call
+    
     if (this._evals.has(_eval)) return this._evals.get(_eval);
 
     const promise = new Promise((resolve, reject) => {
@@ -327,47 +246,34 @@ class Shard extends EventEmitter {
     return promise;
   }
 
-  /**
-   * Handles a message received from the child process/worker.
-   * @param {*} message Message received
-   * @private
-   */
+  
   _handleMessage(message) {
     if (message) {
-      // Shard is ready
+      
       if (message._ready) {
         this.ready = true;
-        /**
-         * Emitted upon the shard's {@link Client#event:shardReady} event.
-         * @event Shard#ready
-         */
+        
         this.emit(ShardEvents.Ready);
         return;
       }
 
-      // Shard has disconnected
+      
       if (message._disconnect) {
         this.ready = false;
-        /**
-         * Emitted upon the shard's {@link Client#event:shardDisconnect} event.
-         * @event Shard#disconnect
-         */
+        
         this.emit(ShardEvents.Disconnect);
         return;
       }
 
-      // Shard is attempting to reconnect
+      
       if (message._reconnecting) {
         this.ready = false;
-        /**
-         * Emitted upon the shard's {@link Client#event:shardReconnecting} event.
-         * @event Shard#reconnecting
-         */
+        
         this.emit(ShardEvents.Reconnecting);
         return;
       }
 
-      // Shard is requesting a property fetch
+      
       if (message._sFetchProp) {
         const resp = { _sFetchProp: message._sFetchProp, _sFetchPropShard: message._sFetchPropShard };
         this.manager.fetchClientValues(message._sFetchProp, message._sFetchPropShard).then(
@@ -377,7 +283,7 @@ class Shard extends EventEmitter {
         return;
       }
 
-      // Shard is requesting an eval broadcast
+      
       if (message._sEval) {
         const resp = { _sEval: message._sEval, _sEvalShard: message._sEvalShard };
         this.manager._performOnShards('eval', [message._sEval], message._sEvalShard).then(
@@ -387,37 +293,23 @@ class Shard extends EventEmitter {
         return;
       }
 
-      // Shard is requesting a respawn of all shards
+      
       if (message._sRespawnAll) {
         const { shardDelay, respawnDelay, timeout } = message._sRespawnAll;
         this.manager.respawnAll({ shardDelay, respawnDelay, timeout }).catch(() => {
-          // Do nothing
+          
         });
         return;
       }
     }
 
-    /**
-     * Emitted upon receiving a message from the child process/worker.
-     * @event Shard#message
-     * @param {*} message Message that was received
-     */
+    
     this.emit(ShardEvents.Message, message);
   }
 
-  /**
-   * Handles the shard's process/worker exiting.
-   * @param {boolean} [respawn=this.manager.respawn] Whether to spawn the shard again
-   * @param {number} [timeout] The amount in milliseconds to wait until the {@link Client}
-   * has become ready (`-1` or `Infinity` for no wait)
-   * @private
-   */
+  
   _handleExit(respawn = this.manager.respawn, timeout) {
-    /**
-     * Emitted upon the shard's child process/worker exiting.
-     * @event Shard#death
-     * @param {ChildProcess|Worker} process Child process/worker that exited
-     */
+    
     this.emit(ShardEvents.Death, this.process ?? this.worker);
 
     this.ready = false;
@@ -429,11 +321,7 @@ class Shard extends EventEmitter {
     if (respawn) this.spawn(timeout).catch(err => this.emit(ShardEvents.Error, err));
   }
 
-  /**
-   * Increments max listeners by one for a given emitter, if they are not zero.
-   * @param {EventEmitter|process} emitter The emitter that emits the events.
-   * @private
-   */
+  
   incrementMaxListeners(emitter) {
     const maxListeners = emitter.getMaxListeners();
     if (maxListeners !== 0) {
@@ -441,11 +329,7 @@ class Shard extends EventEmitter {
     }
   }
 
-  /**
-   * Decrements max listeners by one for a given emitter, if they are not zero.
-   * @param {EventEmitter|process} emitter The emitter that emits the events.
-   * @private
-   */
+  
   decrementMaxListeners(emitter) {
     const maxListeners = emitter.getMaxListeners();
     if (maxListeners !== 0) {

package/src/sharding/ShardClientUtil.js

@@ -6,28 +6,16 @@ const { DiscordjsError, DiscordjsTypeError, ErrorCodes } = require('../errors');
 const Events = require('../util/Events');
 const { makeError, makePlainError } = require('../util/Util');
 
-/**
- * Helper class for sharded clients spawned as a child process/worker, such as from a {@link ShardingManager}.
- * Utilises IPC to send and receive data to/from the master process and other shards.
- */
+
 class ShardClientUtil {
   constructor(client, mode) {
-    /**
-     * Client for the shard
-     * @type {Client}
-     */
+    
     this.client = client;
 
-    /**
-     * Mode the shard was spawned with
-     * @type {ShardingManagerMode}
-     */
+    
     this.mode = mode;
 
-    /**
-     * Message port for the master process (only when {@link ShardClientUtil#mode} is `worker`)
-     * @type {?MessagePort}
-     */
+    
     this.parentPort = null;
 
     switch (mode) {
@@ -59,30 +47,17 @@ class ShardClientUtil {
     }
   }
 
-  /**
-   * Array of shard ids of this client
-   * @type {number[]}
-   * @readonly
-   */
+  
   get ids() {
     return this.client.options.shards;
   }
 
-  /**
-   * Total number of shards
-   * @type {number}
-   * @readonly
-   */
+  
   get count() {
     return this.client.options.shardCount;
   }
 
-  /**
-   * Sends a message to the master process.
-   * @param {*} message Message to send
-   * @returns {Promise<void>}
-   * @emits Shard#message
-   */
+  
   send(message) {
     return new Promise((resolve, reject) => {
       switch (this.mode) {
@@ -100,17 +75,7 @@ class ShardClientUtil {
     });
   }
 
-  /**
-   * Fetches a client property value of each shard, or a given shard.
-   * @param {string} prop Name of the client property to get, using periods for nesting
-   * @param {number} [shard] Shard to fetch property from, all if undefined
-   * @returns {Promise<*|Array<*>>}
-   * @example
-   * client.shard.fetchClientValues('guilds.cache.size')
-   *   .then(results => console.log(`${results.reduce((prev, val) => prev + val, 0)} total guilds`))
-   *   .catch(console.error);
-   * @see {@link ShardingManager#fetchClientValues}
-   */
+  
   fetchClientValues(prop, shard) {
     return new Promise((resolve, reject) => {
       const parent = this.parentPort ?? process;
@@ -133,17 +98,7 @@ class ShardClientUtil {
     });
   }
 
-  /**
-   * Evaluates a script or function on all shards, or a given shard, in the context of the {@link Client}s.
-   * @param {Function} script JavaScript to run on each shard
-   * @param {BroadcastEvalOptions} [options={}] The options for the broadcast
-   * @returns {Promise<*|Array<*>>} Results of the script execution
-   * @example
-   * client.shard.broadcastEval(client => client.guilds.cache.size)
-   *   .then(results => console.log(`${results.reduce((prev, val) => prev + val, 0)} total guilds`))
-   *   .catch(console.error);
-   * @see {@link ShardingManager#broadcastEval}
-   */
+  
   broadcastEval(script, options = {}) {
     return new Promise((resolve, reject) => {
       const parent = this.parentPort ?? process;
@@ -170,21 +125,12 @@ class ShardClientUtil {
     });
   }
 
-  /**
-   * Requests a respawn of all shards.
-   * @param {MultipleShardRespawnOptions} [options] Options for respawning shards
-   * @returns {Promise<void>} Resolves upon the message being sent
-   * @see {@link ShardingManager#respawnAll}
-   */
+  
   respawnAll({ shardDelay = 5_000, respawnDelay = 500, timeout = 30_000 } = {}) {
     return this.send({ _sRespawnAll: { shardDelay, respawnDelay, timeout } });
   }
 
-  /**
-   * Handles an IPC message.
-   * @param {*} message Message received
-   * @private
-   */
+  
   async _handleMessage(message) {
     if (!message) return;
     if (message._fetchProp) {
@@ -205,34 +151,17 @@ class ShardClientUtil {
     }
   }
 
-  /**
-   * Sends a message to the master process, emitting an error from the client upon failure.
-   * @param {string} type Type of response to send
-   * @param {*} message Message to send
-   * @private
-   */
+  
   _respond(type, message) {
     this.send(message).catch(err => {
       const error = new Error(`Error when sending ${type} response to master process: ${err.message}`);
       error.stack = err.stack;
-      /**
-       * Emitted when the client encounters an error.
-       * <warn>Errors thrown within this event do not have a catch handler, it is
-       * recommended to not use async functions as `error` event handlers. See the
-       * [Node.js docs](https://nodejs.org/api/events.html#capture-rejections-of-promises) for details.</warn>
-       * @event Client#error
-       * @param {Error} error The error encountered
-       */
+      
       this.client.emit(Events.Error, error);
     });
   }
 
-  /**
-   * Creates/gets the singleton of this class.
-   * @param {Client} client The client to use
-   * @param {ShardingManagerMode} mode Mode the shard was spawned with
-   * @returns {ShardClientUtil}
-   */
+  
   static singleton(client, mode) {
     if (!this._singleton) {
       this._singleton = new this(client, mode);
@@ -245,23 +174,14 @@ class ShardClientUtil {
     return this._singleton;
   }
 
-  /**
-   * Get the shard id for a given guild id.
-   * @param {Snowflake} guildId Snowflake guild id to get shard id for
-   * @param {number} shardCount Number of shards
-   * @returns {number}
-   */
+  
   static shardIdForGuildId(guildId, shardCount) {
     const shard = calculateShardId(guildId, shardCount);
     if (shard < 0) throw new DiscordjsError(ErrorCodes.ShardingShardMiscalculation, shard, guildId, shardCount);
     return shard;
   }
 
-  /**
-   * Increments max listeners by one for a given emitter, if they are not zero.
-   * @param {EventEmitter|process} emitter The emitter that emits the events.
-   * @private
-   */
+  
   incrementMaxListeners(emitter) {
     const maxListeners = emitter.getMaxListeners();
     if (maxListeners !== 0) {
@@ -269,11 +189,7 @@ class ShardClientUtil {
     }
   }
 
-  /**
-   * Decrements max listeners by one for a given emitter, if they are not zero.
-   * @param {EventEmitter|process} emitter The emitter that emits the events.
-   * @private
-   */
+  
   decrementMaxListeners(emitter) {
     const maxListeners = emitter.getMaxListeners();
     if (maxListeners !== 0) {