bare-ws 2.0.1 → 2.0.3

package/index.d.ts

@@ -0,0 +1,4 @@
+import WebSocket from './lib/socket'
+import WebSocketServer from './lib/server'
+
+export { WebSocket as Socket, WebSocketServer as Server }

package/lib/constants.d.ts

@@ -0,0 +1,17 @@
+import Buffer from 'bare-buffer'
+
+export const EOL: string
+export const EOF: string
+
+export const GUID: Buffer
+
+export const opcode: {
+  CONTINUATION: number
+  TEXT: number
+  BINARY: number
+  CLOSE: number
+  PING: number
+  PONG: number
+}
+
+export const status: { PROTOCOL_ERROR: number; MESSAGE_TOO_LARGE: number }

package/lib/constants.js

@@ -1,6 +1,5 @@
-const EOL = (exports.EOL = '\r\n')
-
-exports.EOF = EOL.repeat(2)
+exports.EOL = '\r\n'
+exports.EOF = exports.EOL.repeat(2)
 
 exports.GUID = Buffer.from('258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
 

package/lib/errors.d.ts

@@ -0,0 +1,29 @@
+declare class WebSocketError extends Error {
+  constructor(
+    msg: string,
+    code: string,
+    status: number,
+    fn?: WebSocketError,
+    cause?: unknown
+  )
+
+  static NETWORK_ERROR(msg: string, cause?: unknown): WebSocketError
+  static NOT_CONNECTED(msg?: string): WebSocketError
+  static UNEXPECTED_RSV1(msg?: string): WebSocketError
+  static UNEXPECTED_RSV2(msg?: string): WebSocketError
+  static UNEXPECTED_RSV3(msg?: string): WebSocketError
+  static EXPECTED_MASK(msg?: string): WebSocketError
+  static EXPECTED_CONTINUATION(msg?: string): WebSocketError
+  static UNEXPECTED_CONTINUATION(msg?: string): WebSocketError
+  static UNEXPECTED_CONTROL(msg?: string): WebSocketError
+  static INVALID_ENCODING(msg?: string): WebSocketError
+  static INVALID_UPGRADE_HEADER(msg?: string): WebSocketError
+  static INVALID_VERSION_HEADER(msg?: string): WebSocketError
+  static INVALID_KEY_HEADER(msg?: string): WebSocketError
+  static INVALID_ACCEPT_HEADER(msg?: string): WebSocketError
+  static INVALID_OPCODE(msg?: string): WebSocketError
+  static INVALID_PAYLOAD_LENGTH(msg?: string): WebSocketError
+  static INCOMPLETE_FRAME(msg?: string, length?: number): WebSocketError
+}
+
+export = WebSocketError

package/lib/errors.js

@@ -168,4 +168,13 @@ module.exports = class WebSocketError extends Error {
       WebSocketError.INVALID_PAYLOAD_LENGTH
     )
   }
+
+  static INCOMPLETE_FRAME(msg = 'Incomplete frame', length = -1) {
+    return new WebSocketError(
+      msg,
+      'INCOMPLETE_FRAME',
+      length,
+      WebSocketError.INCOMPLETE_FRAME
+    )
+  }
 }

package/lib/frame.js

@@ -104,13 +104,13 @@ exports.encode = function encode(state, f) {
 
       const high = Math.floor(length / 0x100000000)
 
-      v.setUint16(i, high, false)
+      v.setUint32(i, high, false)
 
       i += 4
 
       const low = length & 0xffffffff
 
-      v.setUint16(i, low, false)
+      v.setUint32(i, low, false)
 
       i += 4
     }
@@ -136,12 +136,13 @@ exports.encode = function encode(state, f) {
 }
 
 exports.decode = function decode(state) {
+  const s = state.start
   const b = state.buffer
 
-  let i = state.start
-  let n = b.length
+  let i = s
+  let n = b.byteLength
 
-  if (n < 2) return null
+  if (n < 2) throw errors.INCOMPLETE_FRAME()
 
   const view = new DataView(b.buffer, b.byteOffset, b.byteLength)
 
@@ -164,14 +165,14 @@ exports.decode = function decode(state) {
   n--
 
   if (length === 0x7e) {
-    if (n < 2) return null
+    if (n < 2) throw errors.INCOMPLETE_FRAME()
 
     length = view.getUint16(i, false)
 
     i += 2
     n -= 2
   } else if (length === 0x7f) {
-    if (n < 8) return null
+    if (n < 8) throw errors.INCOMPLETE_FRAME()
 
     const high = view.getUint32(i, false)
 
@@ -191,7 +192,7 @@ exports.decode = function decode(state) {
   let mask = null
 
   if (masked) {
-    if (n < 4) return null
+    if (n < 4) throw errors.INCOMPLETE_FRAME()
 
     mask = b.subarray(i, i + 4)
 
@@ -199,7 +200,9 @@ exports.decode = function decode(state) {
     n -= 4
   }
 
-  if (n < length) return null
+  if (n < length) {
+    throw errors.INCOMPLETE_FRAME('Incomplete frame', i - s + length)
+  }
 
   const payload = b.subarray(i, i + length)
 

package/lib/server.d.ts

@@ -0,0 +1,63 @@
+import { type HTTPSServerConnectionOptions } from 'bare-https'
+import { HTTPClientRequest, type HTTPServerConnectionOptions } from 'bare-http1'
+import { Socket as TCPSocket, type TCPSocketAddress } from 'bare-tcp'
+import { type DuplexEvents } from 'bare-stream'
+import EventEmitter from 'bare-events'
+import Buffer from 'bare-buffer'
+import WebSocket from './socket'
+import WebSocketError from './errors'
+
+interface WebSocketServerOptions
+  extends HTTPServerConnectionOptions,
+    HTTPSServerConnectionOptions {
+  secure?: boolean
+}
+
+interface WebSocketServerEvents extends DuplexEvents {
+  connection: [socket: WebSocket, req: HTTPClientRequest]
+  listening: []
+}
+
+interface WebSocketServer<
+  M extends WebSocketServerEvents = WebSocketServerEvents
+> extends EventEmitter<M> {
+  readonly listening: boolean
+
+  address(): TCPSocketAddress
+  close(cb?: (err: WebSocketError | null) => void): void
+  ref(): void
+  unref(): void
+}
+
+declare class WebSocketServer {
+  constructor(onconnection: (socket: WebSocket, req: HTTPClientRequest) => void)
+
+  constructor(
+    opts?: WebSocketServerOptions,
+    onconnection?: (socket: WebSocket, req: HTTPClientRequest) => void
+  )
+}
+
+declare namespace WebSocketServer {
+  export { type WebSocketServerOptions, type WebSocketServerEvents }
+
+  export function handshake(
+    req: HTTPClientRequest,
+    cb: (err: WebSocketError | null) => void
+  ): void
+
+  export function handshake(
+    req: HTTPClientRequest,
+    socket: TCPSocket,
+    cb?: (err: WebSocketError | null) => void
+  ): void
+
+  export function handshake(
+    req: HTTPClientRequest,
+    socket?: TCPSocket,
+    head?: Buffer,
+    cb?: (err: WebSocketError | null) => void
+  ): void
+}
+
+export = WebSocketServer

package/lib/server.js

@@ -71,7 +71,7 @@ module.exports = exports = class WebSocketServer extends EventEmitter {
   }
 
   _onupgrade(req, socket, head) {
-    handshake(req, socket, head, (err) => {
+    exports.handshake(req, socket, head, (err) => {
       if (err) return socket.destroy(err)
 
       this.emit('connection', new WebSocket({ socket, isServer: true }), req)
@@ -80,7 +80,7 @@ module.exports = exports = class WebSocketServer extends EventEmitter {
 }
 
 // https://datatracker.ietf.org/doc/html/rfc6455#section-4.2
-const handshake = (exports.handshake = function handshake(
+exports.handshake = function handshake(
   req,
   socket = req.socket,
   head = EMPTY,
@@ -131,4 +131,4 @@ const handshake = (exports.handshake = function handshake(
   if (head.byteLength) socket.unshift(head)
 
   cb(null)
-})
+}

package/lib/socket.d.ts

@@ -0,0 +1,41 @@
+import { HTTPClientRequest } from 'bare-http1'
+import { Socket as TCPSocket } from 'bare-tcp'
+import { Duplex, type DuplexEvents } from 'bare-stream'
+import URL from 'bare-url'
+import WebSocketError from './errors'
+
+interface WebSocketOptions {
+  host?: string
+  hostname?: string
+  path?: string
+  port?: string | number
+  secure?: boolean
+  socket?: TCPSocket
+}
+
+interface WebSocketEvents extends DuplexEvents {
+  ping: [payload: unknown]
+  pong: [payload: unknown]
+}
+
+interface WebSocket<M extends WebSocketEvents = WebSocketEvents>
+  extends Duplex<M> {
+  ping(data: unknown): void
+  pong(data: unknown): void
+}
+
+declare class WebSocket {
+  constructor(opts: WebSocketOptions)
+  constructor(url: URL | string, opts?: WebSocketOptions)
+}
+
+declare namespace WebSocket {
+  export { type WebSocketOptions, type WebSocketEvents }
+
+  export function handshake(
+    req: HTTPClientRequest,
+    cb: (error: WebSocketError | null) => void
+  ): void
+}
+
+export = WebSocket

package/lib/socket.js

@@ -40,7 +40,9 @@ module.exports = exports = class WebSocket extends Duplex {
     this._pendingOpen = null
     this._pendingWrite = null
 
-    this._buffer = null
+    this._buffer = []
+    this._buffered = 0
+    this._frame = -1
 
     if (socket !== null) this._attach(socket)
     else this._connect(opts)
@@ -81,7 +83,7 @@ module.exports = exports = class WebSocket extends Duplex {
 
     const req = request(opts)
 
-    handshake(req, (err) => {
+    exports.handshake(req, (err) => {
       const cb = this._pendingOpen
       this._pendingOpen = null
 
@@ -101,29 +103,30 @@ module.exports = exports = class WebSocket extends Duplex {
   }
 
   _ondata(data) {
-    if (this._buffer === null) this._buffer = data
-    else this._buffer = Buffer.concat([this._buffer, data])
+    this._buffer.push(data)
+    this._buffered += data.byteLength
 
-    while (this._buffer !== null) {
-      const state = { start: 0, end: this._buffer.length, buffer: this._buffer }
+    while (this._frame === -1 || this._frame <= this._buffered) {
+      const buffer =
+        this._buffer.length === 1
+          ? this._buffer[0]
+          : Buffer.concat(this._buffer)
 
-      let frame
-      try {
-        frame = Frame.decode(state)
-      } catch (err) {
-        return this.destroy(err)
-      }
-
-      if (frame === null) return
+      this._buffer = [buffer]
 
-      this._buffer =
-        state.start === state.end ? null : this._buffer.subarray(state.start)
+      const state = { start: 0, end: buffer.length, buffer }
 
       try {
-        this._onframe(frame)
+        this._onframe(Frame.decode(state))
       } catch (err) {
-        return this.destroy(err)
+        if (err.code === 'INCOMPLETE_FRAME') this._frame = err.status
+        else this.destroy(err)
+        return
       }
+
+      this._buffered -= state.start
+      this._buffer = this._buffered > 0 ? [buffer.subarray(state.start)] : []
+      this._frame = -1
     }
   }
 
@@ -141,16 +144,20 @@ module.exports = exports = class WebSocket extends Duplex {
     if (frame.fin === false) {
       if (this._fragments.push(frame) === 1) {
         // First frame
-        if (frame.opcode === opcode.CONTINUATION)
+        if (frame.opcode === opcode.CONTINUATION) {
           throw errors.UNEXPECTED_CONTINUATION()
+        }
 
-        if (frame.opcode >= opcode.CLOSE) throw errors.UNEXPECTED_CONTROL()
+        if (frame.opcode >= opcode.CLOSE) {
+          throw errors.UNEXPECTED_CONTROL()
+        }
 
         return
       }
 
-      if (frame.opcode !== opcode.CONTINUATION)
+      if (frame.opcode !== opcode.CONTINUATION) {
         throw errors.EXPECTED_CONTINUATION()
+      }
 
       return
     }
@@ -240,7 +247,7 @@ module.exports = exports = class WebSocket extends Duplex {
 }
 
 // https://datatracker.ietf.org/doc/html/rfc6455#section-4.1
-const handshake = (exports.handshake = function handshake(req, cb) {
+exports.handshake = function handshake(req, cb) {
   const key = crypto.randomBytes(16).toString('base64')
 
   req.headers = {
@@ -276,7 +283,7 @@ const handshake = (exports.handshake = function handshake(req, cb) {
   })
 
   req.end()
-})
+}
 
 // https://url.spec.whatwg.org/#default-port
 function defaultPort(url) {

package/package.json

@@ -1,15 +1,25 @@
 {
   "name": "bare-ws",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "WebSocket library for JavaScript",
   "exports": {
-    ".": "./index.js",
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
     "./package": "./package.json",
-    "./constants": "./lib/constants.js",
-    "./errors": "./lib/errors.js"
+    "./constants": {
+      "types": "./lib/constants.d.ts",
+      "default": "./lib/constants.js"
+    },
+    "./errors": {
+      "types": "./lib/errors.d.ts",
+      "default": "./lib/errors.js"
+    }
   },
   "files": [
     "index.js",
+    "index.d.ts",
     "lib"
   ],
   "scripts": {
@@ -33,9 +43,23 @@
     "bare-stream": "^2.1.2"
   },
   "devDependencies": {
+    "bare-buffer": "^3.0.2",
     "bare-fs": "^4.0.0",
+    "bare-url": "^2.1.3",
     "brittle": "^3.3.0",
     "prettier": "^3.4.1",
     "prettier-config-standard": "^7.0.0"
+  },
+  "peerDependencies": {
+    "bare-buffer": "*",
+    "bare-url": "*"
+  },
+  "peerDependenciesMeta": {
+    "bare-buffer": {
+      "optional": true
+    },
+    "bare-url": {
+      "optional": true
+    }
   }
 }