@discordjs/ws 1.1.1 → 1.1.2-dev.1717373416-94cc02a25

package/README.md

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

package/dist/defaultWorker.js

@@ -141,7 +141,6 @@ 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");
@@ -292,8 +291,17 @@ 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();
@@ -312,6 +320,7 @@ var DefaultWebSocketManagerOptions = {
   version: import_v10.APIVersion,
   encoding: "json" /* JSON */,
   compression: null,
+  useIdentifyCompression: false,
   retrieveSessionInfo(shardId) {
     const store = getDefaultSessionStore();
     return store.get(shardId) ?? null;
@@ -343,6 +352,7 @@ __name(getInitialSendRateLimitState, "getInitialSendRateLimitState");
 
 // 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";
@@ -365,8 +375,8 @@ var WebSocketShard = class extends import_async_event_emitter.AsyncEventEmitter
     __name(this, "WebSocketShard");
   }
   connection = null;
-  useIdentifyCompress = false;
-  inflate = null;
+  nativeInflate = null;
+  zLibSyncInflate = null;
   textDecoder = new import_node_util.TextDecoder();
   replayedEvents = 0;
   isAck = true;
@@ -383,6 +393,16 @@ 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;
   }
@@ -414,21 +434,53 @@ 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 } = this.strategy.options;
+    const { version, encoding, compression, useIdentifyCompression } = this.strategy.options;
+    this.identifyCompressionEnabled = useIdentifyCompression;
     const params = new import_node_url.URLSearchParams({ v: version, encoding });
-    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"
-        );
+    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;
       }
     }
     const session = await this.strategy.retrieveSessionInfo(this.id);
@@ -622,24 +674,25 @@ 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.inflate ? "zlib-stream" : this.useIdentifyCompress ? "identify" : "none"}`
+      `compression: ${this.transportCompressionEnabled ? CompressionParameterMap[this.strategy.options.compression] : this.identifyCompressionEnabled ? "identify" : "none"}`
     ]);
-    const d = {
+    const data = {
       token: this.strategy.options.token,
       properties: this.strategy.options.identifyProperties,
       intents: this.strategy.options.intents,
-      compress: this.useIdentifyCompress,
+      compress: this.identifyCompressionEnabled,
       shard: [this.id, this.strategy.options.shardCount]
     };
     if (this.strategy.options.largeThreshold) {
-      d.large_threshold = this.strategy.options.largeThreshold;
+      data.large_threshold = this.strategy.options.largeThreshold;
     }
     if (this.strategy.options.initialPresence) {
-      d.presence = this.strategy.options.initialPresence;
+      data.presence = this.strategy.options.initialPresence;
     }
     await this.send({
       op: import_v102.GatewayOpcodes.Identify,
-      d
+      // eslint-disable-next-line id-length
+      d: data
     });
     await this.waitForEvent("ready" /* Ready */, this.strategy.options.readyTimeout);
   }
@@ -654,6 +707,7 @@ 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,
@@ -668,11 +722,18 @@ 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 {
@@ -682,9 +743,10 @@ var WebSocketShard = class extends import_async_event_emitter.AsyncEventEmitter
       }
     }
     const decompressable = new Uint8Array(data);
-    if (this.useIdentifyCompress) {
-      return new Promise((resolve2, reject) => {
-        (0, import_node_zlib.inflate)(decompressable, { chunkSize: 65535 }, (err, result) => {
+    if (this.identifyCompressionEnabled) {
+      return new Promise(async (resolve2, reject) => {
+        const zlib = await getNativeZlib();
+        zlib.inflate(decompressable, { chunkSize: 65535 }, (err, result) => {
           if (err) {
             reject(err);
             return;
@@ -693,30 +755,37 @@ var WebSocketShard = class extends import_async_event_emitter.AsyncEventEmitter
         });
       });
     }
-    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;
+    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);
       }
-      return JSON.parse(typeof result === "string" ? result : this.textDecoder.decode(result));
     }
     this.debug([
       "Received a message we were unable to decompress",
       `isBinary: ${isBinary.toString()}`,
-      `useIdentifyCompress: ${this.useIdentifyCompress.toString()}`,
-      `inflate: ${Boolean(this.inflate).toString()}`
+      `identifyCompressionEnabled: ${this.identifyCompressionEnabled.toString()}`,
+      `inflate: ${this.transportCompressionEnabled ? CompressionMethod[this.strategy.options.compression] : "none"}`
     ]);
     return null;
   }
@@ -925,7 +994,7 @@ var WebSocketShard = class extends import_async_event_emitter.AsyncEventEmitter
   }
   debug(messages) {
     const message = `${messages[0]}${messages.length > 1 ? `
-${messages.slice(1).map((m) => `	${m}`).join("\n")}` : ""}`;
+${messages.slice(1).map((message2) => `	${message2}`).join("\n")}` : ""}`;
     this.emit("debug" /* Debug */, { message });
   }
 };