cognova 0.2.2 → 0.2.4

package/.output/server/node_modules/discord.js/src/client/websocket/WebSocketManager.js

@@ -0,0 +1,407 @@
+'use strict';
+
+const EventEmitter = require('node:events');
+const process = require('node:process');
+const { setImmediate } = require('node:timers');
+const { Collection } = require('@discordjs/collection');
+const {
+  WebSocketManager: WSWebSocketManager,
+  WebSocketShardEvents: WSWebSocketShardEvents,
+  CompressionMethod,
+  CloseCodes,
+} = require('@discordjs/ws');
+const { GatewayCloseCodes, GatewayDispatchEvents } = require('discord-api-types/v10');
+const WebSocketShard = require('./WebSocketShard');
+const PacketHandlers = require('./handlers');
+const { DiscordjsError, ErrorCodes } = require('../../errors');
+const Events = require('../../util/Events');
+const Status = require('../../util/Status');
+const WebSocketShardEvents = require('../../util/WebSocketShardEvents');
+
+let zlib;
+let deprecationEmitted = false;
+
+try {
+  zlib = require('zlib-sync');
+} catch {} // eslint-disable-line no-empty
+
+const BeforeReadyWhitelist = [
+  GatewayDispatchEvents.Ready,
+  GatewayDispatchEvents.Resumed,
+  GatewayDispatchEvents.GuildCreate,
+  GatewayDispatchEvents.GuildDelete,
+  GatewayDispatchEvents.GuildMembersChunk,
+  GatewayDispatchEvents.GuildMemberAdd,
+  GatewayDispatchEvents.GuildMemberRemove,
+];
+
+const WaitingForGuildEvents = [GatewayDispatchEvents.GuildCreate, GatewayDispatchEvents.GuildDelete];
+
+const UNRECOVERABLE_CLOSE_CODES = [
+  GatewayCloseCodes.AuthenticationFailed,
+  GatewayCloseCodes.InvalidShard,
+  GatewayCloseCodes.ShardingRequired,
+  GatewayCloseCodes.InvalidAPIVersion,
+  GatewayCloseCodes.InvalidIntents,
+  GatewayCloseCodes.DisallowedIntents,
+];
+
+const reasonIsDeprecated = 'the reason property is deprecated, use the code property to determine the reason';
+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[]} messages The debug message
+   * @param {?number} [shardId] The id of the shard that emitted this message, if any
+   * @private
+   */
+  debug(messages, shardId) {
+    this.client.emit(
+      Events.Debug,
+      `[WS => ${typeof shardId === 'number' ? `Shard ${shardId}` : 'Manager'}] ${messages.join('\n\t')}`,
+    );
+  }
+
+  /**
+   * Connects this manager to the gateway.
+   * @private
+   */
+  async connect() {
+    const invalidToken = new DiscordjsError(ErrorCodes.TokenInvalid);
+    const { shards, shardCount, intents, ws } = this.client.options;
+    if (this._ws && this._ws.options.token !== this.client.token) {
+      await this._ws.destroy({ code: CloseCodes.Normal, reason: 'Login with differing token requested' });
+      this._ws = null;
+    }
+    if (!this._ws) {
+      const wsOptions = {
+        intents: intents.bitfield,
+        rest: this.client.rest,
+        token: this.client.token,
+        largeThreshold: ws.large_threshold,
+        version: ws.version,
+        shardIds: shards === 'auto' ? null : shards,
+        shardCount: shards === 'auto' ? null : shardCount,
+        initialPresence: ws.presence,
+        retrieveSessionInfo: shardId => this.shards.get(shardId).sessionInfo,
+        updateSessionInfo: (shardId, sessionInfo) => {
+          this.shards.get(shardId).sessionInfo = sessionInfo;
+        },
+        compression: zlib ? CompressionMethod.ZlibStream : null,
+      };
+      if (ws.buildIdentifyThrottler) wsOptions.buildIdentifyThrottler = ws.buildIdentifyThrottler;
+      if (ws.buildStrategy) wsOptions.buildStrategy = ws.buildStrategy;
+      this._ws = new WSWebSocketManager(wsOptions);
+      this.attachEvents();
+    }
+
+    const {
+      url: gatewayURL,
+      shards: recommendedShards,
+      session_start_limit: sessionStartLimit,
+    } = await this._ws.fetchGatewayInformation().catch(error => {
+      throw error.status === 401 ? invalidToken : error;
+    });
+
+    const { total, remaining } = sessionStartLimit;
+    this.debug(['Fetched Gateway Information', `URL: ${gatewayURL}`, `Recommended Shards: ${recommendedShards}`]);
+    this.debug(['Session Limit Information', `Total: ${total}`, `Remaining: ${remaining}`]);
+    this.gateway = `${gatewayURL}/`;
+
+    this.client.options.shardCount = await this._ws.getShardCount();
+    this.client.options.shards = await this._ws.getShardIds();
+    this.totalShards = this.client.options.shards.length;
+    for (const id of this.client.options.shards) {
+      if (!this.shards.has(id)) {
+        const shard = new WebSocketShard(this, id);
+        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();
+        });
+        shard.status = Status.Connecting;
+      }
+    }
+
+    await this._ws.connect();
+
+    this.shards.forEach(shard => {
+      if (shard.listenerCount(WebSocketShardEvents.InvalidSession) > 0 && !deprecationEmittedForInvalidSessionEvent) {
+        process.emitWarning(
+          'The WebSocketShard#invalidSession event is deprecated and will never emit.',
+          'DeprecationWarning',
+        );
+
+        deprecationEmittedForInvalidSessionEvent = true;
+      }
+      if (shard.listenerCount(WebSocketShardEvents.Destroyed) > 0 && !deprecationEmittedForDestroyedEvent) {
+        process.emitWarning(
+          'The WebSocketShard#destroyed event is deprecated and will never emit.',
+          'DeprecationWarning',
+        );
+
+        deprecationEmittedForDestroyedEvent = true;
+      }
+    });
+  }
+
+  /**
+   * 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 }) => {
+      this.client.emit(Events.Raw, data, shardId);
+      this.emit(data.t, data.d, shardId);
+      const shard = this.shards.get(shardId);
+      this.handlePacket(data, shard);
+      if (shard.status === Status.WaitingForGuilds && WaitingForGuildEvents.includes(data.t)) {
+        shard.gotGuild(data.d.id);
+      }
+    });
+
+    this._ws.on(WSWebSocketShardEvents.Ready, ({ data, shardId }) => {
+      this.shards.get(shardId).onReadyPacket(data);
+    });
+
+    this._ws.on(WSWebSocketShardEvents.Closed, ({ code, shardId }) => {
+      const shard = this.shards.get(shardId);
+      shard.emit(WebSocketShardEvents.Close, { code, reason: reasonIsDeprecated, wasClean: true });
+      if (UNRECOVERABLE_CLOSE_CODES.includes(code)) {
+        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([`Shard not recoverable: ${code} (${GatewayCloseCodes[code] ?? CloseCodes[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 }) => {
+      const shard = this.shards.get(shardId);
+      if (shard.sessionInfo) {
+        shard.closeSequence = shard.sessionInfo.sequence;
+        shard.status = Status.Resuming;
+      } else {
+        shard.status = Status.Identifying;
+      }
+    });
+
+    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);
+    });
+
+    this._ws.on(WSWebSocketShardEvents.HeartbeatComplete, ({ heartbeatAt, latency, shardId }) => {
+      this.debug([`Heartbeat acknowledged, latency of ${latency}ms.`], shardId);
+      const shard = this.shards.get(shardId);
+      shard.lastPingTimestamp = heartbeatAt;
+      shard.ping = latency;
+    });
+
+    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
+   */
+  async destroy() {
+    if (this.destroyed) return;
+    // TODO: Make a util for getting a stack
+    this.debug([Object.assign(new Error(), { name: 'Manager was destroyed:' }).stack]);
+    this.destroyed = true;
+    await this._ws?.destroy({ code: CloseCodes.Normal, reason: 'Manager was destroyed' });
+  }
+
+  /**
+   * 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)) {
+        this.packetQueue.push({ packet, shard });
+        return false;
+      }
+    }
+
+    if (this.packetQueue.length) {
+      const item = this.packetQueue.shift();
+      setImmediate(() => {
+        this.handlePacket(item.packet, item.shard);
+      }).unref();
+    }
+
+    if (packet && PacketHandlers[packet.t]) {
+      PacketHandlers[packet.t](this.client, packet, shard);
+    }
+
+    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(shard => shard.status !== Status.Ready)) {
+      return;
+    }
+
+    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
+     * @deprecated Use {@link Client#event:clientReady} instead.
+     * @param {Client} client The client
+     */
+    if (this.client.emit('ready', this.client) && !deprecationEmitted) {
+      deprecationEmitted = true;
+
+      process.emitWarning(
+        // eslint-disable-next-line max-len
+        'The ready event has been renamed to clientReady to distinguish it from the gateway READY event and will only emit under that name in v15. Please use clientReady instead.',
+        'DeprecationWarning',
+      );
+    }
+
+    /**
+     * Emitted when the client becomes ready to start working.
+     * @event Client#clientReady
+     * @param {Client} client The client
+     */
+    this.client.emit(Events.ClientReady, this.client);
+
+    this.handlePacket();
+  }
+}
+
+module.exports = WebSocketManager;

package/.output/server/node_modules/discord.js/src/client/websocket/WebSocketShard.js

@@ -0,0 +1,234 @@
+'use strict';
+
+const EventEmitter = require('node:events');
+const process = require('node:process');
+const { setTimeout, clearTimeout } = require('node:timers');
+const { GatewayIntentBits } = require('discord-api-types/v10');
+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/packages/ws/stable/SessionInfo:Interface}
+     */
+
+    /**
+     * 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[]} messages The debug message
+   * @private
+   */
+  debug(messages) {
+    this.manager.debug(messages, 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,
+      reason: 'INTERNAL_ERROR',
+      wasClean: false,
+    },
+  ) {
+    this.debug([
+      '[CLOSE]',
+      `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(guild => guild.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;
+
+    this.readyTimeout = setTimeout(
+      () => {
+        this.debug([
+          hasGuildsIntent
+            ? `Shard did not receive any guild packets in ${waitGuildTimeout} ms.`
+            : 'Shard will not receive anymore guild packets.',
+          `Unavailable guild count: ${this.expectedGuilds.size}`,
+        ]);
+
+        this.readyTimeout = null;
+        this.status = Status.Ready;
+
+        this.emit(WebSocketShardEvents.AllReady, this.expectedGuilds);
+      },
+      hasGuildsIntent ? waitGuildTimeout : 0,
+    ).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(
+        'Sending important payloads explicitly is deprecated. They are determined by their opcode implicitly now.',
+        'DeprecationWarning',
+      );
+      deprecationEmittedForImportant = true;
+    }
+    this.manager._ws.send(this.id, data);
+  }
+}
+
+module.exports = WebSocketShard;

package/.output/server/node_modules/discord.js/src/client/websocket/handlers/APPLICATION_COMMAND_PERMISSIONS_UPDATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.ApplicationCommandPermissionsUpdate.handle(packet.d);
+};

package/.output/server/node_modules/discord.js/src/client/websocket/handlers/AUTO_MODERATION_ACTION_EXECUTION.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.AutoModerationActionExecution.handle(packet.d);
+};

package/.output/server/node_modules/discord.js/src/client/websocket/handlers/AUTO_MODERATION_RULE_CREATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.AutoModerationRuleCreate.handle(packet.d);
+};

package/.output/server/node_modules/discord.js/src/client/websocket/handlers/AUTO_MODERATION_RULE_DELETE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.AutoModerationRuleDelete.handle(packet.d);
+};

package/.output/server/node_modules/discord.js/src/client/websocket/handlers/AUTO_MODERATION_RULE_UPDATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.AutoModerationRuleUpdate.handle(packet.d);
+};

package/.output/server/node_modules/discord.js/src/client/websocket/handlers/CHANNEL_CREATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.ChannelCreate.handle(packet.d);
+};

package/.output/server/node_modules/discord.js/src/client/websocket/handlers/CHANNEL_DELETE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.ChannelDelete.handle(packet.d);
+};