feat: implement websockets

lib/websocket/connection.js

@@ -384,7 +384,7 @@ function receiveData (ws) {
         // - type indicates that the data is Binary and binary type is "blob"
         //      a new Blob object, created in the relevant Realm of the
         //      WebSocket object, that represents data as its raw data
-        dataForEvent = new Blob(frame.payloadData)
+        dataForEvent = new Blob([frame.payloadData])
       } else if (frame.opcode === opcodes.BINARY && ws[kBinaryType] === 'arraybuffer') {
         // - type indicates that the data is Binary and binary type is
         //   "arraybuffer"

lib/websocket/websocket.js

@@ -206,6 +206,23 @@ class WebSocket extends EventTarget {
     // https://datatracker.ietf.org/doc/html/rfc6455#section-6.1
     // https://datatracker.ietf.org/doc/html/rfc6455#section-5.2
 
+    if (!isEstablished(this) || isClosing(this)) {
+      return
+    }
+
+    /** @type {import('stream').Duplex} */
+    const { socket } = this[kResponse]
+
+    const frame = new WebsocketFrame()
+    // TODO: support fragmentation later.
+    frame.FIN = true
+    frame.isMasked = true
+    frame.maskKey = Buffer.allocUnsafe(4)
+
+    for (let i = 0; i < 4; i++) {
+      frame.maskKey[i] = Math.floor(Math.random() * 256)
+    }
+
     // If data is a string
     if (typeof data === 'string') {
       // If the WebSocket connection is established and the WebSocket
@@ -218,25 +235,72 @@ class WebSocket extends EventTarget {
       // string argument that does not throw an exception must increase
       // the bufferedAmount attribute by the number of bytes needed to
       // express the argument as UTF-8.
-      if (isEstablished(this) && !isClosing(this)) {
-        const socket = this[kResponse].socket
-        const frame = new WebsocketFrame()
-        // 1. set FIN to true. TODO: support fragmentation later.
-        frame.FIN = true
-        // 2. enable masking
-        frame.isMasked = true
-        // 3. set mask key
-        frame.maskKey = Buffer.alloc(4)
-        for (let i = 0; i < 4; i++) {
-          frame.maskKey[i] = Math.floor(Math.random() * 256)
-        }
-
-        // TODO: support BINARY data
-        frame.opcode = opcodes.TEXT
-        frame.payloadData = Buffer.from(data)
-
-        socket.write(frame.toBuffer())
-      }
+
+      frame.opcode = opcodes.TEXT
+      frame.payloadData = Buffer.from(data)
+
+      const buffer = frame.toBuffer()
+      this.#bufferedAmount += buffer.byteLength
+      socket.write(buffer)
+    } else if (types.isArrayBuffer(data)) {
+      // If the WebSocket connection is established, and the WebSocket
+      // closing handshake has not yet started, then the user agent must
+      // send a WebSocket Message comprised of data using a binary frame
+      // opcode; if the data cannot be sent, e.g. because it would need
+      // to be buffered but the buffer is full, the user agent must flag
+      // the WebSocket as full and then close the WebSocket connection.
+      // The data to be sent is the data stored in the buffer described
+      // by the ArrayBuffer object. Any invocation of this method with an
+      // ArrayBuffer argument that does not throw an exception must
+      // increase the bufferedAmount attribute by the length of the
+      // ArrayBuffer in bytes.
+
+      frame.opcode = opcodes.BINARY
+      frame.payloadData = Buffer.from(data)
+
+      const buffer = frame.toBuffer()
+      this.#bufferedAmount += buffer.byteLength
+      socket.write(buffer)
+    } else if (ArrayBuffer.isView(data)) {
+      // If the WebSocket connection is established, and the WebSocket
+      // closing handshake has not yet started, then the user agent must
+      // send a WebSocket Message comprised of data using a binary frame
+      // opcode; if the data cannot be sent, e.g. because it would need to
+      // be buffered but the buffer is full, the user agent must flag the
+      // WebSocket as full and then close the WebSocket connection. The
+      // data to be sent is the data stored in the section of the buffer
+      // described by the ArrayBuffer object that data references. Any
+      // invocation of this method with this kind of argument that does
+      // not throw an exception must increase the bufferedAmount attribute
+      // by the length of data’s buffer in bytes.
+
+      frame.opcode = opcodes.BINARY
+      frame.payloadData = Buffer.from(data)
+
+      const buffer = frame.toBuffer()
+      this.#bufferedAmount += buffer.byteLength
+      socket.write(buffer)
+    } else if (isBlobLike(data)) {
+      // If the WebSocket connection is established, and the WebSocket
+      // closing handshake has not yet started, then the user agent must
+      // send a WebSocket Message comprised of data using a binary frame
+      // opcode; if the data cannot be sent, e.g. because it would need to
+      // be buffered but the buffer is full, the user agent must flag the
+      // WebSocket as full and then close the WebSocket connection. The data
+      // to be sent is the raw data represented by the Blob object. Any
+      // invocation of this method with a Blob argument that does not throw
+      // an exception must increase the bufferedAmount attribute by the size
+      // of the Blob object’s raw data, in bytes.
+
+      frame.opcode = opcodes.BINARY
+
+      data.arrayBuffer().then((ab) => {
+        frame.payloadData = Buffer.from(ab)
+
+        const buffer = frame.toBuffer()
+        this.#bufferedAmount += buffer.byteLength
+        socket.write(buffer)
+      })
     }
   }