cloudstorm 0.5.8 → 0.6.1

package/dist/ShardManager.js

@@ -1,153 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-const Shard_1 = __importDefault(require("./Shard"));
-const RatelimitBucket_1 = __importDefault(require("./structures/RatelimitBucket"));
-/**
- * Class used for managing shards for the user.
- *
- * This class is automatically instantiated by the library and is documented for reference.
- */
-class ShardManager {
-    /**
-     * Create a new ShardManager.
-     */
-    constructor(client) {
-        this.concurrencyBucket = null;
-        this.client = client;
-        this.options = client.options;
-        this.shards = {};
-        this.identifyBucket = new RatelimitBucket_1.default(1000, 1000 * 60 * 60 * 24, 1000 * 60 * 60 * 24);
-    }
-    /**
-     * Create shard instances and add them to the connection queue.
-     */
-    spawn() {
-        if (!this.concurrencyBucket)
-            throw new Error("Trying to spawn shards without calling Client.connect()");
-        for (const id of (this.options.shards === "auto" ? Array(this.options.totalShards).fill(0).map((_, index) => index) : this.options.shards || [0])) {
-            this.client.emit("debug", `Spawned shard ${id}`);
-            this.shards[id] = new Shard_1.default(id, this.client);
-            this._addListener(this.shards[id]);
-            this.shards[id].connector.connect();
-        }
-    }
-    /**
-     * Disconnect all shards facilitated by this manager.
-     */
-    disconnect() {
-        for (const shardKey in this.shards) {
-            this.shards[shardKey].disconnect();
-        }
-    }
-    /**
-     * Add event listeners to a shard to that the manager can act on received events.
-     * @param shard Shard to add the event listeners to.
-     */
-    _addListener(shard) {
-        shard.on("ready", (resume) => {
-            shard.ready = true;
-            this.client.emit("debug", `Shard ${shard.id} ${resume ? "has resumed" : "is ready"}`);
-            this.client.emit("shardReady", { id: shard.id, ready: !resume });
-            this._checkReady();
-        });
-        shard.on("queueIdentify", (shardId) => {
-            var _a;
-            if (!this.shards[shardId])
-                return this.client.emit("debug", `Received a queueIdentify event for shard ${shardId} but it does not exist. Was it removed?`);
-            this.client.emit("debug", `Shard ${shardId} is ready to identify`);
-            (_a = this.concurrencyBucket) === null || _a === void 0 ? void 0 : _a.queue(() => {
-                this.identifyBucket.queue(() => this.shards[shardId].connector.identify());
-            });
-        });
-        shard.on("disconnect", (code, reason, gracefulClose) => {
-            this.client.emit("debug", `Websocket of shard ${shard.id} closed with code ${code} and reason: ${reason ? reason : "None"}`);
-            if (code === 1000 && gracefulClose)
-                return this._checkDisconnect();
-        });
-    }
-    /**
-     * Checks if all shards spawned by this manager are ready.
-     */
-    _checkReady() {
-        for (const shardId in this.shards) {
-            if (this.shards[shardId]) {
-                if (!this.shards[shardId].ready)
-                    return;
-            }
-        }
-        this.client.emit("ready");
-    }
-    /**
-     * Checks if all shards spawned by this manager are disconnected.
-     */
-    _checkDisconnect() {
-        for (const shardId in this.shards) {
-            if (this.shards[shardId]) {
-                if (this.shards[shardId].connector.status !== "disconnected")
-                    return;
-            }
-        }
-        this.client.emit("disconnected");
-    }
-    /**
-     * Update the status of all currently connected shards which have been spawned by this manager.
-     * @param data Data to send.
-     */
-    async presenceUpdate(data) {
-        for (const shardKey in this.shards) {
-            if (this.shards[shardKey]) {
-                const shard = this.shards[shardKey];
-                this.shardPresenceUpdate(shard.id, data);
-            }
-        }
-    }
-    /**
-     * Update the status of a single connected shard which has been spawned by this manager.
-     * @param shardId id of the shard.
-     * @param data Data to send.
-     */
-    shardPresenceUpdate(shardId, data) {
-        return new Promise((res, rej) => {
-            const shard = this.shards[shardId];
-            if (!shard)
-                rej(new Error(`Shard ${shardId} does not exist`));
-            if (!shard.ready)
-                shard.once("ready", () => shard.presenceUpdate(data).then(result => res(result)).catch(e => rej(e)));
-            shard.presenceUpdate(data).then(result => res(result)).catch(e => rej(e));
-        });
-    }
-    /**
-     * Send an OP 4 VOICE_STATE_UPDATE with a certain shard.
-     * @param shardId id of the shard.
-     * @param data Data to send.
-     */
-    voiceStateUpdate(shardId, data) {
-        return new Promise((res, rej) => {
-            const shard = this.shards[shardId];
-            if (!shard)
-                rej(new Error(`Shard ${shardId} does not exist`));
-            if (!shard.ready)
-                shard.once("ready", () => shard.voiceStateUpdate(data).then(result => res(result)).catch(e => rej(e)));
-            shard.voiceStateUpdate(data).then(result => res(result)).catch(e => rej(e));
-        });
-    }
-    /**
-     * Send an OP 8 REQUEST_GUILD_MEMBERS with a certain shard.
-     * @param shardId id of the shard.
-     * @param data Data to send.
-     */
-    requestGuildMembers(shardId, data) {
-        return new Promise((res, rej) => {
-            const shard = this.shards[shardId];
-            if (!shard)
-                rej(new Error(`Shard ${shardId} does not exist`));
-            if (!shard.ready)
-                shard.once("ready", () => shard.requestGuildMembers(data).then(result => res(result)).catch(e => rej(e)));
-            shard.requestGuildMembers(data).then(result => res(result)).catch(e => rej(e));
-        });
-    }
-}
-ShardManager.default = ShardManager;
-module.exports = ShardManager;

package/dist/Types.d.ts

@@ -1,34 +0,0 @@
-export declare type IntentFlags = (typeof import("./Intents"))["flags"];
-export declare type IntentResolvable = number | Array<number> | keyof IntentFlags | Array<keyof IntentFlags>;
-export interface IWSMessage {
-    op: import("discord-typings").GatewayOpcode;
-    d?: any;
-    s?: number;
-    t?: import("discord-typings").GatewayEvent;
-}
-export interface IGatewayMessage extends IWSMessage {
-    shard_id: number;
-}
-export interface IClientOptions {
-    largeGuildThreshold?: number;
-    /**
-     * A note on "auto" sharding:
-     * "auto" will always start at 0 as there is no way to know the next available shard id.
-     * If you have more than one "cluster", you must specify an Array of shard ids. along with totalShards
-     */
-    shards?: "auto" | Array<number>;
-    /**
-     * Ignored and overwrote if using "auto" sharding.
-     * The total number of shards expected across all clusters.
-     */
-    totalShards?: number;
-    reconnect?: boolean;
-    initialPresence?: import("discord-typings").GatewayPresenceUpdate;
-    intents?: IntentResolvable;
-    snowtransferInstance?: import("snowtransfer").SnowTransfer;
-    ws?: IClientWSOptions;
-}
-export interface IClientWSOptions {
-    compress?: boolean;
-    encoding?: "etf" | "json";
-}

package/dist/Types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/connector/DiscordConnector.d.ts

@@ -1,146 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { EventEmitter } from "events";
-import BetterWs from "../structures/BetterWs";
-interface ConnectorEvents {
-    queueIdentify: [number];
-    event: [import("../Types").IWSMessage];
-    ready: [boolean];
-    disconnect: [number, string, boolean];
-    stateChange: ["connecting" | "identifying" | "resuming" | "ready" | "disconnected"];
-}
-interface DiscordConnector {
-    addListener<E extends keyof ConnectorEvents>(event: E, listener: (...args: ConnectorEvents[E]) => any): this;
-    emit<E extends keyof ConnectorEvents>(event: E, ...args: ConnectorEvents[E]): boolean;
-    eventNames(): Array<keyof ConnectorEvents>;
-    listenerCount(event: keyof ConnectorEvents): number;
-    listeners(event: keyof ConnectorEvents): Array<(...args: Array<any>) => any>;
-    off<E extends keyof ConnectorEvents>(event: E, listener: (...args: ConnectorEvents[E]) => any): this;
-    on<E extends keyof ConnectorEvents>(event: E, listener: (...args: ConnectorEvents[E]) => any): this;
-    once<E extends keyof ConnectorEvents>(event: E, listener: (...args: ConnectorEvents[E]) => any): this;
-    prependListener<E extends keyof ConnectorEvents>(event: E, listener: (...args: ConnectorEvents[E]) => any): this;
-    prependOnceListener<E extends keyof ConnectorEvents>(event: E, listener: (...args: ConnectorEvents[E]) => any): this;
-    rawListeners(event: keyof ConnectorEvents): Array<(...args: Array<any>) => any>;
-    removeAllListeners(event?: keyof ConnectorEvents): this;
-    removeListener<E extends keyof ConnectorEvents>(event: E, listener: (...args: ConnectorEvents[E]) => any): this;
-}
-/**
- * Class used for acting based on received events.
- *
- * This class is automatically instantiated by the library and is documented for reference.
- */
-declare class DiscordConnector extends EventEmitter {
-    id: number;
-    client: import("../Client");
-    options: import("../Client")["options"];
-    reconnect: boolean;
-    betterWs: BetterWs;
-    heartbeatTimeout: NodeJS.Timeout | null;
-    heartbeatInterval: number;
-    _trace: string | null;
-    seq: number;
-    status: "connecting" | "identifying" | "resuming" | "ready" | "disconnected";
-    sessionId: string | null;
-    lastACKAt: number;
-    lastHeartbeatSend: number;
-    latency: number;
-    private _closing;
-    identifyAddress: string;
-    resumeAddress: string | null;
-    static readonly default: typeof DiscordConnector;
-    /**
-     * Create a new Discord Connector.
-     * @param id id of the shard that created this class.
-     * @param client Main client instance.
-     */
-    constructor(id: number, client: import("../Client"));
-    /**
-     * Connect to Discord.
-     */
-    connect(): Promise<void>;
-    /**
-     * Close the websocket connection and disconnect.
-     */
-    disconnect(): Promise<void>;
-    /**
-     * Called with a parsed Websocket message to execute further actions.
-     * @param message Message that was received.
-     */
-    private messageAction;
-    /**
-     * Reset this connector to be ready to resume or hard reconnect, then connect.
-     * @param resume Whether or not the client intends to send an OP 6 RESUME later.
-     */
-    private _reconnect;
-    /**
-     * Hard reset this connector.
-     */
-    private reset;
-    /**
-     * Clear the heart beat interval, set it to null and set the cached heartbeat_interval as 0.
-     */
-    private clearHeartBeat;
-    /**
-     * Send an OP 2 IDENTIFY to the gateway or an OP 6 RESUME if forceful identify is falsy.
-     * @param force Whether CloudStorm should send an OP 2 IDENTIFY even if there's a session that could be resumed.
-     */
-    identify(force?: boolean): Promise<void>;
-    /**
-     * Send an OP 6 RESUME to the gateway.
-     */
-    private resume;
-    /**
-     * Send an OP 1 HEARTBEAT to the gateway.
-     */
-    private heartbeat;
-    /**
-     * Handle dispatch events.
-     * @param message Message received from the websocket.
-     */
-    private handleDispatch;
-    /**
-     * Handle a close from the underlying websocket.
-     * @param code Websocket close code.
-     * @param reason Close reason if any.
-     */
-    private handleWsClose;
-    /**
-     * Send an OP 3 PRESENCE_UPDATE to the gateway.
-     * @param data Presence data to send.
-     */
-    presenceUpdate(data: import("discord-typings").GatewayPresenceUpdate): Promise<void>;
-    /**
-     * Send an OP 4 VOICE_STATE_UPDATE to the gateway.
-     * @param data Voice state update data to send.
-     */
-    voiceStateUpdate(data: import("discord-typings").VoiceStateUpdatePayload & {
-        self_deaf?: boolean;
-        self_mute?: boolean;
-    }): Promise<void>;
-    /**
-     * Send an OP 8 REQUEST_GUILD_MEMBERS to the gateway.
-     * @param data Data to send.
-     */
-    requestGuildMembers(data: import("discord-typings").GuildRequestMembersPayload & {
-        limit?: number;
-    }): Promise<void>;
-    /**
-     * Checks presence data and fills in missing elements.
-     * @param data Data to send.
-     * @returns Data after it's fixed/checked.
-     */
-    private _checkPresenceData;
-    /**
-     * Checks voice state update data and fills in missing elements.
-     * @param data Data to send.
-     * @returns Data after it's fixed/checked.
-     */
-    private _checkVoiceStateUpdateData;
-    /**
-     * Checks request guild members data and fills in missing elements.
-     * @param data Data to send.
-     * @returns Data after it's fixed/checked.
-     */
-    private _checkRequestGuildMembersData;
-}
-export = DiscordConnector;