cloudstorm 0.9.1 → 0.9.4

package/dist/index.d.ts

@@ -6,6 +6,9 @@ import { EventEmitter } from 'events';
 
 type IntentFlags = typeof flags;
 type IntentResolvable = number | Array<number> | keyof IntentFlags | Array<keyof IntentFlags>;
+/**
+ * Bit flags representing Discord intents.
+ */
 declare const flags: {
     GUILDS: number;
     GUILD_MEMBERS: number;
@@ -27,6 +30,11 @@ declare const flags: {
     AUTO_MODERATION_CONFIGURATION: number;
     AUTO_MODERATION_EXECUTION: number;
 };
+/**
+ * A function to resolve either bit number(s) or human readable string(s) to a bit collection number Discord can accept as client intents.
+ * @param bit Data representing intents that can be resolved to a bit collection number Discord can accept.
+ * @returns A bit collection number Discord can accept as the client intents.
+ */
 declare function resolve(bit?: IntentResolvable): number;
 declare const _default: {
     flags: {
@@ -93,12 +101,15 @@ declare class RatelimitBucket {
     limit: number;
     limitReset: number;
     defaultReset?: number | undefined;
+    /** Functions waiting to be executed. */
     fnQueue: Array<{
         fn: () => unknown;
         callback: () => unknown;
         error: Error;
     }>;
+    /** How many more functions can be executed before this bucket needs to wait to reset. */
     remaining: number;
+    /** The Timeout that when executed, will reset this bucket's remaining to the limit. Null if remaining is the limit. */
     resetTimeout: NodeJS.Timeout | null;
     /**
      * Create a new Bucket.
@@ -155,22 +166,85 @@ interface BetterWs {
 declare class BetterWs extends EventEmitter {
     address: string;
     options: IClientWSOptions;
+    /** The encoding to send/receive messages to/from the server with. */
     encoding: "etf" | "json";
+    /** If the messages sent/received are compressed with zlib. */
     compress: boolean;
+    /** The ratelimit bucket for how many packets this ws can send within a time frame. */
     wsBucket: RatelimitBucket;
+    /** The ratelimit bucket for how many presence update specific packets this ws can send within a time frame. Is still affected by the overall packet send bucket. */
     presenceBucket: RatelimitBucket;
+    /** The raw net.Socket retreived from upgrading the connection or null if not upgraded/closed. */
     private _socket;
+    /** Internal properties that need a funny way to be referenced. */
     private _internal;
+    /** If a request is going through to initiate a WebSocket connection and hasn't been upgraded by the server yet. */
     private _connecting;
+    /** Code received from frame op 8 */
+    private _lastCloseCode;
+    /** Reason received from frame op 8 */
+    private _lastCloseReason;
+    /**
+     * Creates a new lightweight WebSocket.
+     * @param address The http(s):// or ws(s):// URL cooresponding to the server to connect to.
+     * @param options Options specific to this WebSocket.
+     */
     constructor(address: string, options: IClientWSOptions);
+    /**
+     * The state this WebSocket is in. 1 is connected, 2 is connecting, 3 is closing, and 4 is closed.
+     */
     get status(): 1 | 2 | 3 | 4;
+    /**
+     * Initiates a WebSocket connection to the server.
+     */
     connect(): Promise<void>;
+    /**
+     * Disconnects from the server.
+     * @param code The close code.
+     * @param reason The reason for closing if any.
+     * @returns A Promise that resolves when the connection is fully closed.
+     */
     close(code: number, reason?: string): Promise<void>;
+    /**
+     * Sends a message to the server in the format of { op: number, d: any } (before any encoding/compression).
+     * @param data What to send to the server.
+     * @returns A Promise that resolves when the message passes the bucket queue(s) and is written to the socket's Buffer to send.
+     */
     sendMessage(data: GatewaySendPayload): Promise<void>;
+    /**
+     * Method to raw write messages to the server.
+     * @param packet Buffer containing the message to send.
+     * @param opcode WebSocket spec op code.
+     */
     private _write;
+    /**
+     * Handler for when requests from connect are upgraded to WebSockets.
+     * @param key The sec key from connect.
+     * @param req The HTTP request from connect.
+     * @param resolve Promise resolver from connect.
+     * @param reject Promise rejector from connect.
+     * @param res The HTTP response from the server from connect.
+     * @param socket The raw socket from upgrading the request from connect.
+     */
+    private _onUpgrade;
+    /**
+     * Handler for when the raw socket to the server encounters an error.
+     * @param error What happened.
+     */
     private _onError;
+    /**
+     * Handler for when the raw socket is fully closed and cleans up this WebSocket.
+     */
     private _onClose;
+    /**
+     * Handler for when there is data in the socket's Buffer to read.
+     */
     private _onReadable;
+    /**
+     * Transforms/reads raw messages from the server and emits the appropriate event.
+     * @param opcode WebSocket spec op code.
+     * @param message Buffer of data to transform/read.
+     */
     private _processFrame;
 }
 
@@ -208,25 +282,47 @@ declare class DiscordConnector extends EventEmitter {
             endpoint?: string;
         };
     };
+    /** The options used by the client */
     options: DiscordConnector["client"]["options"];
+    /** If this connector will attempt to automatically reconnect */
     reconnect: boolean;
+    /** The WebSocket this connector uses */
     betterWs: BetterWs;
+    /** A Timeout that, when triggered, will send an op 1 heartbeat. Is null if Discord hasn't told this connector how often to heartbeat */
     heartbeatTimeout: NodeJS.Timeout | null;
+    /** How often this connector should heartbeat if not 0 */
     heartbeatInterval: number;
+    /** The _trace as sent by the Discord READY and RESUMED payloads */
     _trace: string | null;
+    /** The sequence, which is the number of events received by Discord within the session if any session */
     seq: number;
+    /** The status of this connector */
     status: "connecting" | "identifying" | "resuming" | "ready" | "disconnected";
+    /** The session ID used for resuming or null if Discord hasn't sent one yet */
     sessionId: string | null;
+    /** The ms timestamp when this connector last received an op 11 heartbeat ack if not 0 */
     lastACKAt: number;
+    /** The ms timestamp when this connector last sent an op 1 heartbeat if not 0 */
     lastHeartbeatSend: number;
+    /** The time in milliseconds it took for Discord to send an op 11 heartbeat ack in response to an op 1 heartbeat */
     latency: number;
-    private _closing;
+    /** The address the WebSocket will use to connect to the Discord gateway if not resuming */
     identifyAddress: string;
+    /** The address the WebSocket will use to connect to the Discord gateway if resuming */
     resumeAddress: string | null;
+    /** If this connector is disconnected/disconnecting currently, but will reconnect eventually */
     reconnecting: boolean;
+    /** If this connector is waiting to be fully closed */
+    private _closing;
+    /** If the disconnect method on this class was called and the connect method hasn't been called yet */
+    private _closeCalled;
+    /** A Timeout that, when triggered, closes the connection because op HELLO hasn't been received and may never be received */
+    private _openToHeartbeatTimeout;
+    /** A Timeout that, when triggered, sends the first heartbeat */
+    private _initialHeartbeatTimeout;
     static readonly default: typeof DiscordConnector;
     /**
-     * Create a new Discord Connector.
+     * Creates a new Discord Connector.
      * @param id id of the shard that created this class.
      * @param client Main client instance.
      */
@@ -258,6 +354,9 @@ declare class DiscordConnector extends EventEmitter {
      * Hard reset this connector.
      */
     private reset;
+    /**
+     * Sets the this.heartbeatTimeout Interval.
+     */
     private setHeartBeat;
     /**
      * Clear the heart beat interval, set it to null and set the cached heartbeat_interval as 0.
@@ -360,7 +459,9 @@ declare class Shard extends EventEmitter {
             endpoint?: string;
         };
     };
+    /** If this shard has received the READY or RESUMED payload and isn't disconnected yet. */
     ready: boolean;
+    /** The connector that handles all of the Discord specific connection logic. */
     connector: DiscordConnector;
     /**
      * Create a new Shard.
@@ -414,11 +515,15 @@ declare class ShardManager {
             endpoint?: string;
         };
     };
+    /** The options used by the client */
     options: ShardManager["client"]["options"];
+    /** A Record of shards keyed by their ID */
     shards: {
         [id: number]: Shard;
     };
+    /** The bucket used to identify a certain number of shards within a day. */
     identifyBucket: RatelimitBucket;
+    /** The bucket used to identify x number of shards within 5 second intervals. Larger bots benefit from this, but doesn't change how many times per day any shards can identify. */
     concurrencyBucket: RatelimitBucket | null;
     /**
      * Create a new ShardManager.
@@ -508,17 +613,23 @@ interface Client {
  * Main class used for receiving events and interacting with the Discord gateway.
  */
 declare class Client extends EventEmitter {
+    /** The Discord auth token to connect with. */
     token: string;
+    /** User specific options filled in with defaults if not specified. */
     options: Omit<IClientOptions, "snowtransferInstance"> & {
         token: string;
         endpoint?: string;
     };
+    /** The manager of all of the shards used to connect to Discord. */
     shardManager: ShardManager;
+    /** The version string of CloudStorm. */
     version: string;
+    /** The SnowTransfer instance to use to make some requests to get connect info. */
     private _restClient;
     /**
      * Create a new Client to connect to the Discord gateway.
      * @param token Token received from creating a discord bot user, which will be used to connect to the gateway.
+     * @param options Baseline options to use. Will be filled with defaults if not specified.
      */
     constructor(token: string, options?: IClientOptions);
     /**