@mswjs/socket.io-binding/build/index.js

Binding to mock Socket.IO connections with Mock Service Worker

// src/index.ts
import {
  encodePayload,
  decodePayload
} from "engine.io-parser";
import {
  Encoder,
  Decoder,
  PacketType as SocketIoPacketType
} from "socket.io-parser";
var encoder = new Encoder();
var decoder = new Decoder();
var SocketIoConnection = class {
  constructor(connection) {
    this.connection = connection;
  }
  on(event, listener) {
    const addEventListener = this.connection.addEventListener.bind(
      this.connection
    );
    addEventListener("message", function(messageEvent) {
      const binaryType = this.binaryType === "blob" ? this.binaryType : typeof Buffer === "undefined" ? "arraybuffer" : "nodebuffer";
      const rawData = messageEvent.data;
      if (typeof rawData !== "string") {
        return;
      }
      const engineIoPackets = decodePayload(rawData, binaryType);
      if (engineIoPackets.every((packet) => packet.type !== "message")) {
        return;
      }
      for (const packet of engineIoPackets) {
        decoder.once("decoded", (decodedSocketIoPacket) => {
          if (decodedSocketIoPacket.type !== SocketIoPacketType.EVENT) {
            return;
          }
          const [sentEvent, ...data] = decodedSocketIoPacket.data;
          if (sentEvent === event) {
            listener.call(void 0, messageEvent, ...data);
          }
        });
        decoder.add(packet.data);
      }
    });
  }
  send(...data) {
    this.emit("message", ...data);
  }
  emit(event, ...data) {
    const encodedSocketIoPacket = encoder.encode({
      type: SocketIoPacketType.EVENT,
      /**
       * @todo Support custom namespaces.
       */
      nsp: "/",
      data: [event].concat(data)
    });
    const engineIoPackets = encodedSocketIoPacket.map(
      (packet) => {
        return {
          type: "message",
          data: packet
        };
      }
    );
    encodePayload(engineIoPackets, (encodedPayload) => {
      this.connection.send(encodedPayload);
    });
  }
};
var SocketIoDuplexConnection = class {
  constructor(rawClient, rawServer) {
    this.rawClient = rawClient;
    this.rawServer = rawServer;
    queueMicrotask(() => {
      try {
        Reflect.get(this.rawServer, "socket").readyState;
        return;
      } catch {
        this.rawClient.send(
          "0" + JSON.stringify({
            sid: "test",
            upgrades: [],
            pingInterval: 25e3,
            pingTimeout: 5e3
          })
        );
        this.rawClient.send("40" + JSON.stringify({ sid: "test" }));
      }
    });
    this.client = new SocketIoConnection(this.rawClient);
    this.server = new SocketIoConnection(this.rawServer);
  }
  client;
  server;
};
function toSocketIo(connection) {
  return new SocketIoDuplexConnection(connection.client, connection.server);
}
export {
  toSocketIo
};
//# sourceMappingURL=index.js.map