@discordjs/ws 1.1.1 → 1.1.2-dev.1717589074-346d1be72

package/dist/defaultWorker.mjs

@@ -119,7 +119,6 @@ import { clearInterval, clearTimeout, setInterval, setTimeout } from "node:timer
 import { setTimeout as sleep2 } from "node:timers/promises";
 import { URLSearchParams } from "node:url";
 import { TextDecoder } from "node:util";
-import { inflate } from "node:zlib";
 import { Collection as Collection6 } from "@discordjs/collection";
 import { lazy as lazy2, shouldUseGlobalFetchAndWebSocket } from "@discordjs/util";
 import { AsyncQueue as AsyncQueue2 } from "@sapphire/async-queue";
@@ -274,14 +273,23 @@ 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 = lazy(() => new Collection5());
+var CompressionParameterMap = {
+  [0 /* ZlibNative */]: "zlib-stream",
+  [1 /* ZlibSync */]: "zlib-stream"
+};
 var DefaultWebSocketManagerOptions = {
   async buildIdentifyThrottler(manager) {
     const info = await manager.fetchGatewayInformation();
     return new SimpleIdentifyThrottler(info.session_start_limit.max_concurrency);
   },
-  buildStrategy: (manager) => new SimpleShardingStrategy(manager),
+  buildStrategy: /* @__PURE__ */ __name((manager) => new SimpleShardingStrategy(manager), "buildStrategy"),
   shardCount: null,
   shardIds: null,
   largeThreshold: null,
@@ -294,6 +302,7 @@ var DefaultWebSocketManagerOptions = {
   version: APIVersion,
   encoding: "json" /* JSON */,
   compression: null,
+  useIdentifyCompression: false,
   retrieveSessionInfo(shardId) {
     const store = getDefaultSessionStore();
     return store.get(shardId) ?? null;
@@ -325,6 +334,7 @@ __name(getInitialSendRateLimitState, "getInitialSendRateLimitState");
 
 // src/ws/WebSocketShard.ts
 var getZlibSync = lazy2(async () => import("zlib-sync").then((mod) => mod.default).catch(() => null));
+var getNativeZlib = lazy2(async () => import("node:zlib").then((mod) => mod).catch(() => null));
 var WebSocketShardEvents = /* @__PURE__ */ ((WebSocketShardEvents2) => {
   WebSocketShardEvents2["Closed"] = "closed";
   WebSocketShardEvents2["Debug"] = "debug";
@@ -347,8 +357,8 @@ var WebSocketShard = class extends AsyncEventEmitter {
     __name(this, "WebSocketShard");
   }
   connection = null;
-  useIdentifyCompress = false;
-  inflate = null;
+  nativeInflate = null;
+  zLibSyncInflate = null;
   textDecoder = new TextDecoder();
   replayedEvents = 0;
   isAck = true;
@@ -365,6 +375,16 @@ var WebSocketShard = class extends 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;
   }
@@ -396,21 +416,53 @@ var WebSocketShard = class extends 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 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);
@@ -604,24 +656,25 @@ var WebSocketShard = class extends 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: GatewayOpcodes2.Identify,
-      d
+      // eslint-disable-next-line id-length
+      d: data
     });
     await this.waitForEvent("ready" /* Ready */, this.strategy.options.readyTimeout);
   }
@@ -636,6 +689,7 @@ var WebSocketShard = class extends AsyncEventEmitter {
     this.replayedEvents = 0;
     return this.send({
       op: GatewayOpcodes2.Resume,
+      // eslint-disable-next-line id-length
       d: {
         token: this.strategy.options.token,
         seq: session.sequence,
@@ -650,11 +704,18 @@ var WebSocketShard = class extends AsyncEventEmitter {
     const session = await this.strategy.retrieveSessionInfo(this.id);
     await this.send({
       op: GatewayOpcodes2.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 {
@@ -664,9 +725,10 @@ var WebSocketShard = class extends AsyncEventEmitter {
       }
     }
     const decompressable = new Uint8Array(data);
-    if (this.useIdentifyCompress) {
-      return new Promise((resolve2, reject) => {
-        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;
@@ -675,30 +737,37 @@ var WebSocketShard = class extends 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(Buffer2.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 once2(this.nativeInflate, "data");
+        return this.parseInflateResult(result);
+      } else if (this.zLibSyncInflate) {
+        const zLibSync = await getZlibSync();
+        this.zLibSyncInflate.push(Buffer2.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;
   }
@@ -907,7 +976,7 @@ var WebSocketShard = class extends 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 });
   }
 };