@discordjs/ws 1.2.0-dev.1721822666-fcd35ea2e → 1.2.0

package/README.md

@@ -50,10 +50,7 @@ const manager = new WebSocketManager({
 	intents: 0, // for no intents
 	rest,
 	// uncomment if you have zlib-sync installed and want to use compression
-	// compression: CompressionMethod.ZlibSync,
-
-	// alternatively, we support compression using node's native `node:zlib` module:
-	// compression: CompressionMethod.ZlibNative,
+	// compression: CompressionMethod.ZlibStream,
 });
 
 manager.on(WebSocketShardEvents.Dispatch, (event) => {

package/dist/defaultWorker.js

@@ -141,6 +141,7 @@ var import_node_timers = require("timers");
 var import_promises2 = require("timers/promises");
 var import_node_url = require("url");
 var import_node_util = require("util");
+var import_node_zlib = require("zlib");
 var import_collection6 = require("@discordjs/collection");
 var import_util2 = require("@discordjs/util");
 var import_async_queue2 = require("@sapphire/async-queue");
@@ -279,7 +280,7 @@ var SimpleIdentifyThrottler = class {
     await state.queue.wait({ signal });
     try {
       const diff = state.resetsAt - Date.now();
-      if (diff <= 5e3) {
+      if (diff > 0 && diff <= 5e3) {
         const time = diff + Math.random() * 1500;
         await (0, import_promises.setTimeout)(time);
       }
@@ -291,17 +292,8 @@ var SimpleIdentifyThrottler = class {
 };
 
 // src/utils/constants.ts
-var CompressionMethod = /* @__PURE__ */ ((CompressionMethod2) => {
-  CompressionMethod2[CompressionMethod2["ZlibNative"] = 0] = "ZlibNative";
-  CompressionMethod2[CompressionMethod2["ZlibSync"] = 1] = "ZlibSync";
-  return CompressionMethod2;
-})(CompressionMethod || {});
 var DefaultDeviceProperty = `@discordjs/ws [VI]{{inject}}[/VI]`;
 var getDefaultSessionStore = (0, import_util.lazy)(() => new import_collection5.Collection());
-var CompressionParameterMap = {
-  [0 /* ZlibNative */]: "zlib-stream",
-  [1 /* ZlibSync */]: "zlib-stream"
-};
 var DefaultWebSocketManagerOptions = {
   async buildIdentifyThrottler(manager) {
     const info = await manager.fetchGatewayInformation();
@@ -320,7 +312,6 @@ var DefaultWebSocketManagerOptions = {
   version: import_v10.APIVersion,
   encoding: "json" /* JSON */,
   compression: null,
-  useIdentifyCompression: false,
   retrieveSessionInfo(shardId) {
     const store = getDefaultSessionStore();
     return store.get(shardId) ?? null;
@@ -353,7 +344,6 @@ var KnownNetworkErrorCodes = /* @__PURE__ */ new Set(["ECONNRESET", "ECONNREFUSE
 
 // src/ws/WebSocketShard.ts
 var getZlibSync = (0, import_util2.lazy)(async () => import("zlib-sync").then((mod) => mod.default).catch(() => null));
-var getNativeZlib = (0, import_util2.lazy)(async () => import("zlib").then((mod) => mod).catch(() => null));
 var WebSocketShardEvents = /* @__PURE__ */ ((WebSocketShardEvents2) => {
   WebSocketShardEvents2["Closed"] = "closed";
   WebSocketShardEvents2["Debug"] = "debug";
@@ -376,8 +366,8 @@ var WebSocketShard = class extends import_async_event_emitter.AsyncEventEmitter
     __name(this, "WebSocketShard");
   }
   connection = null;
-  nativeInflate = null;
-  zLibSyncInflate = null;
+  useIdentifyCompress = false;
+  inflate = null;
   textDecoder = new import_node_util.TextDecoder();
   replayedEvents = 0;
   isAck = true;
@@ -394,16 +384,6 @@ var WebSocketShard = class extends import_async_event_emitter.AsyncEventEmitter
   strategy;
   id;
   #status = 0 /* Idle */;
-  identifyCompressionEnabled = false;
-  /**
-   * @privateRemarks
-   *
-   * This is needed because `this.strategy.options.compression` is not an actual reflection of the compression method
-   * used, but rather the compression method that the user wants to use. This is because the libraries could just be missing.
-   */
-  get transportCompressionEnabled() {
-    return this.strategy.options.compression !== null && (this.nativeInflate ?? this.zLibSyncInflate) !== null;
-  }
   get status() {
     return this.#status;
   }
@@ -435,53 +415,21 @@ var WebSocketShard = class extends import_async_event_emitter.AsyncEventEmitter
     if (this.#status !== 0 /* Idle */) {
       throw new Error("Tried to connect a shard that wasn't idle");
     }
-    const { version, encoding, compression, useIdentifyCompression } = this.strategy.options;
-    this.identifyCompressionEnabled = useIdentifyCompression;
+    const { version, encoding, compression } = this.strategy.options;
     const params = new import_node_url.URLSearchParams({ v: version, encoding });
-    if (compression !== null) {
-      if (useIdentifyCompression) {
-        console.warn("WebSocketShard: transport compression is enabled, disabling identify compression");
-        this.identifyCompressionEnabled = false;
-      }
-      params.append("compress", CompressionParameterMap[compression]);
-      switch (compression) {
-        case 0 /* ZlibNative */: {
-          const zlib = await getNativeZlib();
-          if (zlib) {
-            const inflate = zlib.createInflate({
-              chunkSize: 65535,
-              flush: zlib.constants.Z_SYNC_FLUSH
-            });
-            inflate.on("error", (error) => {
-              this.emit("error" /* Error */, { error });
-            });
-            this.nativeInflate = inflate;
-          } else {
-            console.warn("WebSocketShard: Compression is set to native but node:zlib is not available.");
-            params.delete("compress");
-          }
-          break;
-        }
-        case 1 /* ZlibSync */: {
-          const zlib = await getZlibSync();
-          if (zlib) {
-            this.zLibSyncInflate = new zlib.Inflate({
-              chunkSize: 65535,
-              to: "string"
-            });
-          } else {
-            console.warn("WebSocketShard: Compression is set to zlib-sync, but it is not installed.");
-            params.delete("compress");
-          }
-          break;
-        }
-      }
-    }
-    if (this.identifyCompressionEnabled) {
-      const zlib = await getNativeZlib();
-      if (!zlib) {
-        console.warn("WebSocketShard: Identify compression is enabled, but node:zlib is not available.");
-        this.identifyCompressionEnabled = false;
+    if (compression) {
+      const zlib = await getZlibSync();
+      if (zlib) {
+        params.append("compress", compression);
+        this.inflate = new zlib.Inflate({
+          chunkSize: 65535,
+          to: "string"
+        });
+      } else if (!this.useIdentifyCompress) {
+        this.useIdentifyCompress = true;
+        console.warn(
+          "WebSocketShard: Compression is enabled but zlib-sync is not installed, falling back to identify compress"
+        );
       }
     }
     const session = await this.strategy.retrieveSessionInfo(this.id);
@@ -675,25 +623,24 @@ var WebSocketShard = class extends import_async_event_emitter.AsyncEventEmitter
       `shard id: ${this.id.toString()}`,
       `shard count: ${this.strategy.options.shardCount}`,
       `intents: ${this.strategy.options.intents}`,
-      `compression: ${this.transportCompressionEnabled ? CompressionParameterMap[this.strategy.options.compression] : this.identifyCompressionEnabled ? "identify" : "none"}`
+      `compression: ${this.inflate ? "zlib-stream" : this.useIdentifyCompress ? "identify" : "none"}`
     ]);
-    const data = {
+    const d = {
       token: this.strategy.options.token,
       properties: this.strategy.options.identifyProperties,
       intents: this.strategy.options.intents,
-      compress: this.identifyCompressionEnabled,
+      compress: this.useIdentifyCompress,
       shard: [this.id, this.strategy.options.shardCount]
     };
     if (this.strategy.options.largeThreshold) {
-      data.large_threshold = this.strategy.options.largeThreshold;
+      d.large_threshold = this.strategy.options.largeThreshold;
     }
     if (this.strategy.options.initialPresence) {
-      data.presence = this.strategy.options.initialPresence;
+      d.presence = this.strategy.options.initialPresence;
     }
     await this.send({
       op: import_v102.GatewayOpcodes.Identify,
-      // eslint-disable-next-line id-length
-      d: data
+      d
     });
     await this.waitForEvent("ready" /* Ready */, this.strategy.options.readyTimeout);
   }
@@ -708,7 +655,6 @@ var WebSocketShard = class extends import_async_event_emitter.AsyncEventEmitter
     this.replayedEvents = 0;
     return this.send({
       op: import_v102.GatewayOpcodes.Resume,
-      // eslint-disable-next-line id-length
       d: {
         token: this.strategy.options.token,
         seq: session.sequence,
@@ -723,18 +669,11 @@ var WebSocketShard = class extends import_async_event_emitter.AsyncEventEmitter
     const session = await this.strategy.retrieveSessionInfo(this.id);
     await this.send({
       op: import_v102.GatewayOpcodes.Heartbeat,
-      // eslint-disable-next-line id-length
       d: session?.sequence ?? null
     });
     this.lastHeartbeatAt = Date.now();
     this.isAck = false;
   }
-  parseInflateResult(result) {
-    if (!result) {
-      return null;
-    }
-    return JSON.parse(typeof result === "string" ? result : this.textDecoder.decode(result));
-  }
   async unpackMessage(data, isBinary) {
     if (!isBinary) {
       try {
@@ -744,10 +683,9 @@ var WebSocketShard = class extends import_async_event_emitter.AsyncEventEmitter
       }
     }
     const decompressable = new Uint8Array(data);
-    if (this.identifyCompressionEnabled) {
-      return new Promise(async (resolve2, reject) => {
-        const zlib = await getNativeZlib();
-        zlib.inflate(decompressable, { chunkSize: 65535 }, (err, result) => {
+    if (this.useIdentifyCompress) {
+      return new Promise((resolve2, reject) => {
+        (0, import_node_zlib.inflate)(decompressable, { chunkSize: 65535 }, (err, result) => {
           if (err) {
             reject(err);
             return;
@@ -756,37 +694,30 @@ var WebSocketShard = class extends import_async_event_emitter.AsyncEventEmitter
         });
       });
     }
-    if (this.transportCompressionEnabled) {
-      const flush = decompressable.length >= 4 && decompressable.at(-4) === 0 && decompressable.at(-3) === 0 && decompressable.at(-2) === 255 && decompressable.at(-1) === 255;
-      if (this.nativeInflate) {
-        this.nativeInflate.write(decompressable, "binary");
-        if (!flush) {
-          return null;
-        }
-        const [result] = await (0, import_node_events2.once)(this.nativeInflate, "data");
-        return this.parseInflateResult(result);
-      } else if (this.zLibSyncInflate) {
-        const zLibSync = await getZlibSync();
-        this.zLibSyncInflate.push(import_node_buffer.Buffer.from(decompressable), flush ? zLibSync.Z_SYNC_FLUSH : zLibSync.Z_NO_FLUSH);
-        if (this.zLibSyncInflate.err) {
-          this.emit("error" /* Error */, {
-            error: new Error(
-              `${this.zLibSyncInflate.err}${this.zLibSyncInflate.msg ? `: ${this.zLibSyncInflate.msg}` : ""}`
-            )
-          });
-        }
-        if (!flush) {
-          return null;
-        }
-        const { result } = this.zLibSyncInflate;
-        return this.parseInflateResult(result);
+    if (this.inflate) {
+      const l = decompressable.length;
+      const flush = l >= 4 && decompressable[l - 4] === 0 && decompressable[l - 3] === 0 && decompressable[l - 2] === 255 && decompressable[l - 1] === 255;
+      const zlib = await getZlibSync();
+      this.inflate.push(import_node_buffer.Buffer.from(decompressable), flush ? zlib.Z_SYNC_FLUSH : zlib.Z_NO_FLUSH);
+      if (this.inflate.err) {
+        this.emit("error" /* Error */, {
+          error: new Error(`${this.inflate.err}${this.inflate.msg ? `: ${this.inflate.msg}` : ""}`)
+        });
+      }
+      if (!flush) {
+        return null;
+      }
+      const { result } = this.inflate;
+      if (!result) {
+        return null;
       }
+      return JSON.parse(typeof result === "string" ? result : this.textDecoder.decode(result));
     }
     this.debug([
       "Received a message we were unable to decompress",
       `isBinary: ${isBinary.toString()}`,
-      `identifyCompressionEnabled: ${this.identifyCompressionEnabled.toString()}`,
-      `inflate: ${this.transportCompressionEnabled ? CompressionMethod[this.strategy.options.compression] : "none"}`
+      `useIdentifyCompress: ${this.useIdentifyCompress.toString()}`,
+      `inflate: ${Boolean(this.inflate).toString()}`
     ]);
     return null;
   }