@kohost/api-client 3.0.0-beta.65 → 3.0.0-beta.68

package/dist/esm/SocketIoClient.js

@@ -215,18 +215,16 @@ var require_cjs = __commonJS({
   "node_modules/engine.io-parser/build/cjs/index.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.decodePayload = exports.decodePacket = exports.encodePayload = exports.encodePacketToBinary = exports.encodePacket = exports.protocol = exports.decodePacketFromBinary = void 0;
+    exports.decodePayload = exports.decodePacket = exports.encodePayload = exports.encodePacket = exports.protocol = exports.createPacketDecoderStream = exports.createPacketEncoderStream = void 0;
     var encodePacket_js_1 = require_encodePacket_browser();
     Object.defineProperty(exports, "encodePacket", { enumerable: true, get: function() {
       return encodePacket_js_1.encodePacket;
     } });
-    Object.defineProperty(exports, "encodePacketToBinary", { enumerable: true, get: function() {
-      return encodePacket_js_1.encodePacketToBinary;
-    } });
     var decodePacket_js_1 = require_decodePacket_browser();
     Object.defineProperty(exports, "decodePacket", { enumerable: true, get: function() {
       return decodePacket_js_1.decodePacket;
     } });
+    var commons_js_1 = require_commons();
     var SEPARATOR = String.fromCharCode(30);
     var encodePayload = /* @__PURE__ */ __name((packets, callback) => {
       const length = packets.length;
@@ -255,16 +253,125 @@ var require_cjs = __commonJS({
       return packets;
     }, "decodePayload");
     exports.decodePayload = decodePayload;
+    function createPacketEncoderStream() {
+      return new TransformStream({
+        transform(packet, controller) {
+          (0, encodePacket_js_1.encodePacketToBinary)(packet, (encodedPacket) => {
+            const payloadLength = encodedPacket.length;
+            let header;
+            if (payloadLength < 126) {
+              header = new Uint8Array(1);
+              new DataView(header.buffer).setUint8(0, payloadLength);
+            } else if (payloadLength < 65536) {
+              header = new Uint8Array(3);
+              const view = new DataView(header.buffer);
+              view.setUint8(0, 126);
+              view.setUint16(1, payloadLength);
+            } else {
+              header = new Uint8Array(9);
+              const view = new DataView(header.buffer);
+              view.setUint8(0, 127);
+              view.setBigUint64(1, BigInt(payloadLength));
+            }
+            if (packet.data && typeof packet.data !== "string") {
+              header[0] |= 128;
+            }
+            controller.enqueue(header);
+            controller.enqueue(encodedPacket);
+          });
+        }
+      });
+    }
+    __name(createPacketEncoderStream, "createPacketEncoderStream");
+    exports.createPacketEncoderStream = createPacketEncoderStream;
     var TEXT_DECODER;
-    function decodePacketFromBinary(data, isBinary, binaryType) {
+    function totalLength(chunks) {
+      return chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+    }
+    __name(totalLength, "totalLength");
+    function concatChunks(chunks, size) {
+      if (chunks[0].length === size) {
+        return chunks.shift();
+      }
+      const buffer = new Uint8Array(size);
+      let j = 0;
+      for (let i = 0; i < size; i++) {
+        buffer[i] = chunks[0][j++];
+        if (j === chunks[0].length) {
+          chunks.shift();
+          j = 0;
+        }
+      }
+      if (chunks.length && j < chunks[0].length) {
+        chunks[0] = chunks[0].slice(j);
+      }
+      return buffer;
+    }
+    __name(concatChunks, "concatChunks");
+    function createPacketDecoderStream(maxPayload, binaryType) {
       if (!TEXT_DECODER) {
         TEXT_DECODER = new TextDecoder();
       }
-      const isPlainBinary = isBinary || data[0] < 48 || data[0] > 54;
-      return (0, decodePacket_js_1.decodePacket)(isPlainBinary ? data : TEXT_DECODER.decode(data), binaryType);
+      const chunks = [];
+      let state = 0;
+      let expectedLength = -1;
+      let isBinary = false;
+      return new TransformStream({
+        transform(chunk, controller) {
+          chunks.push(chunk);
+          while (true) {
+            if (state === 0) {
+              if (totalLength(chunks) < 1) {
+                break;
+              }
+              const header = concatChunks(chunks, 1);
+              isBinary = (header[0] & 128) === 128;
+              expectedLength = header[0] & 127;
+              if (expectedLength < 126) {
+                state = 3;
+              } else if (expectedLength === 126) {
+                state = 1;
+              } else {
+                state = 2;
+              }
+            } else if (state === 1) {
+              if (totalLength(chunks) < 2) {
+                break;
+              }
+              const headerArray = concatChunks(chunks, 2);
+              expectedLength = new DataView(headerArray.buffer, headerArray.byteOffset, headerArray.length).getUint16(0);
+              state = 3;
+            } else if (state === 2) {
+              if (totalLength(chunks) < 8) {
+                break;
+              }
+              const headerArray = concatChunks(chunks, 8);
+              const view = new DataView(headerArray.buffer, headerArray.byteOffset, headerArray.length);
+              const n = view.getUint32(0);
+              if (n > Math.pow(2, 53 - 32) - 1) {
+                controller.enqueue(commons_js_1.ERROR_PACKET);
+                break;
+              }
+              expectedLength = n * Math.pow(2, 32) + view.getUint32(4);
+              state = 3;
+            } else {
+              if (totalLength(chunks) < expectedLength) {
+                break;
+              }
+              const data = concatChunks(chunks, expectedLength);
+              controller.enqueue((0, decodePacket_js_1.decodePacket)(isBinary ? data : TEXT_DECODER.decode(data), binaryType));
+              state = 0;
+            }
+            if (expectedLength === 0 || expectedLength > maxPayload) {
+              controller.enqueue(commons_js_1.ERROR_PACKET);
+              break;
+            }
+          }
+        }
+      });
     }
-    __name(decodePacketFromBinary, "decodePacketFromBinary");
-    exports.decodePacketFromBinary = decodePacketFromBinary;
+    __name(createPacketDecoderStream, "createPacketDecoderStream");
+    exports.createPacketDecoderStream = createPacketDecoderStream;
     exports.protocol = 4;
   }
 });
@@ -1639,7 +1746,7 @@ var require_websocket = __commonJS({
         } catch (err) {
           return this.emitReserved("error", err);
         }
-        this.ws.binaryType = this.socket.binaryType || websocket_constructor_js_1.defaultBinaryType;
+        this.ws.binaryType = this.socket.binaryType;
         this.addEventListeners();
       }
       /**
@@ -1750,10 +1857,6 @@ var require_webtransport = __commonJS({
     var engine_io_parser_1 = require_cjs();
     var debug_1 = __importDefault(require_browser());
     var debug = (0, debug_1.default)("engine.io-client:webtransport");
-    function shouldIncludeBinaryHeader(packet, encoded) {
-      return packet.type === "message" && typeof packet.data !== "string" && encoded[0] >= 48 && encoded[0] <= 54;
-    }
-    __name(shouldIncludeBinaryHeader, "shouldIncludeBinaryHeader");
     var WT = class extends transport_js_1.Transport {
       static {
         __name(this, "WT");
@@ -1775,9 +1878,11 @@ var require_webtransport = __commonJS({
         });
         this.transport.ready.then(() => {
           this.transport.createBidirectionalStream().then((stream) => {
-            const reader = stream.readable.getReader();
-            this.writer = stream.writable.getWriter();
-            let binaryFlag;
+            const decoderStream = (0, engine_io_parser_1.createPacketDecoderStream)(Number.MAX_SAFE_INTEGER, this.socket.binaryType);
+            const reader = stream.readable.pipeThrough(decoderStream).getReader();
+            const encoderStream = (0, engine_io_parser_1.createPacketEncoderStream)();
+            encoderStream.readable.pipeTo(stream.writable);
+            this.writer = encoderStream.writable.getWriter();
             const read = /* @__PURE__ */ __name(() => {
               reader.read().then(({ done, value }) => {
                 if (done) {
@@ -1785,20 +1890,18 @@ var require_webtransport = __commonJS({
                   return;
                 }
                 debug("received chunk: %o", value);
-                if (!binaryFlag && value.byteLength === 1 && value[0] === 54) {
-                  binaryFlag = true;
-                } else {
-                  this.onPacket((0, engine_io_parser_1.decodePacketFromBinary)(value, binaryFlag, "arraybuffer"));
-                  binaryFlag = false;
-                }
+                this.onPacket(value);
                 read();
               }).catch((err) => {
                 debug("an error occurred while reading: %s", err);
               });
             }, "read");
             read();
-            const handshake = this.query.sid ? `0{"sid":"${this.query.sid}"}` : "0";
-            this.writer.write(new TextEncoder().encode(handshake)).then(() => this.onOpen());
+            const packet = { type: "open" };
+            if (this.query.sid) {
+              packet.data = `{"sid":"${this.query.sid}"}`;
+            }
+            this.writer.write(packet).then(() => this.onOpen());
           });
         });
       }
@@ -1807,20 +1910,13 @@ var require_webtransport = __commonJS({
         for (let i = 0; i < packets.length; i++) {
           const packet = packets[i];
           const lastPacket = i === packets.length - 1;
-          (0, engine_io_parser_1.encodePacketToBinary)(packet, (data) => {
-            if (shouldIncludeBinaryHeader(packet, data)) {
-              debug("writing binary header");
-              this.writer.write(Uint8Array.of(54));
+          this.writer.write(packet).then(() => {
+            if (lastPacket) {
+              (0, websocket_constructor_js_1.nextTick)(() => {
+                this.writable = true;
+                this.emitReserved("drain");
+              }, this.setTimeoutFn);
             }
-            debug("writing chunk: %o", data);
-            this.writer.write(data).then(() => {
-              if (lastPacket) {
-                (0, websocket_constructor_js_1.nextTick)(() => {
-                  this.writable = true;
-                  this.emitReserved("drain");
-                }, this.setTimeoutFn);
-              }
-            });
           });
         }
       }
@@ -1934,6 +2030,7 @@ var require_socket = __commonJS({
     var debug_1 = __importDefault(require_browser());
     var component_emitter_1 = require_component_emitter();
     var engine_io_parser_1 = require_cjs();
+    var websocket_constructor_js_1 = require_websocket_constructor_browser();
     var debug = (0, debug_1.default)("engine.io-client:socket");
     var Socket = class _Socket extends component_emitter_1.Emitter {
       static {
@@ -1947,6 +2044,7 @@ var require_socket = __commonJS({
        */
       constructor(uri, opts = {}) {
         super();
+        this.binaryType = websocket_constructor_js_1.defaultBinaryType;
         this.writeBuffer = [];
         if (uri && "object" === typeof uri) {
           opts = uri;
@@ -2220,12 +2318,12 @@ var require_socket = __commonJS({
           debug('socket receive: type "%s", data "%s"', packet.type, packet.data);
           this.emitReserved("packet", packet);
           this.emitReserved("heartbeat");
+          this.resetPingTimeout();
           switch (packet.type) {
             case "open":
               this.onHandshake(JSON.parse(packet.data));
               break;
             case "ping":
-              this.resetPingTimeout();
               this.sendPacket("pong");
               this.emitReserved("ping");
               this.emitReserved("pong");