bare-ws 2.0.0 → 2.0.2

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,28 @@
+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, cause?: unknown): WebSocketError
+  static UNEXPECTED_RSV1(msg?: string, cause?: unknown): WebSocketError
+  static UNEXPECTED_RSV2(msg?: string, cause?: unknown): WebSocketError
+  static UNEXPECTED_RSV3(msg?: string, cause?: unknown): WebSocketError
+  static EXPECTED_MASK(msg?: string, cause?: unknown): WebSocketError
+  static EXPECTED_CONTINUATION(msg?: string, cause?: unknown): WebSocketError
+  static UNEXPECTED_CONTINUATION(msg?: string, cause?: unknown): WebSocketError
+  static UNEXPECTED_CONTROL(msg?: string, cause?: unknown): WebSocketError
+  static INVALID_ENCODING(msg?: string, cause?: unknown): WebSocketError
+  static INVALID_UPGRADE_HEADER(msg?: string, cause?: unknown): WebSocketError
+  static INVALID_VERSION_HEADER(msg?: string, cause?: unknown): WebSocketError
+  static INVALID_KEY_HEADER(msg?: string, cause?: unknown): WebSocketError
+  static INVALID_ACCEPT_HEADER(msg?: string, cause?: unknown): WebSocketError
+  static INVALID_OPCODE(msg?: string, cause?: unknown): WebSocketError
+  static INVALID_PAYLOAD_LENGTH(msg?: string, cause?: unknown): WebSocketError
+}
+
+export = WebSocketError

package/lib/errors.js

@@ -1,8 +1,8 @@
 const { status } = require('./constants')
 
 module.exports = class WebSocketError extends Error {
-  constructor(msg, code, status, fn = WebSocketError) {
-    super(`${code}: ${msg}`)
+  constructor(msg, code, status, fn = WebSocketError, cause) {
+    super(`${code}: ${msg}`, { cause })
     this.code = code
     this.status = status
 
@@ -15,6 +15,16 @@ module.exports = class WebSocketError extends Error {
     return 'WebSocketError'
   }
 
+  static NETWORK_ERROR(msg, cause) {
+    return new WebSocketError(
+      msg,
+      'NETWORK_ERROR',
+      0,
+      WebSocketError.NETWORK_ERROR,
+      cause
+    )
+  }
+
   static NOT_CONNECTED(msg = 'Socket is not connected') {
     return new WebSocketError(
       msg,

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
     }

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

@@ -81,7 +81,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
 
@@ -141,16 +141,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
     }
@@ -234,12 +238,13 @@ module.exports = exports = class WebSocket extends Duplex {
   }
 
   _predestroy() {
+    if (!this._socket) return
     this._socket.destroy()
   }
 }
 
 // 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 = {
@@ -270,8 +275,12 @@ const handshake = (exports.handshake = function handshake(req, cb) {
     cb(null)
   })
 
+  req.on('error', (err) => {
+    cb(errors.NETWORK_ERROR('Network error', err))
+  })
+
   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.0",
+  "version": "2.0.2",
   "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
+    }
   }
 }