@laplace.live/ws 6.3.1

package/src/inflate/browser.ts

@@ -0,0 +1,9 @@
+import { Buffer } from 'buffer'
+import { inflate } from 'pako'
+
+import { BrotliDecode } from './brotli'
+
+const inflateAsync = (d: Buffer) => Buffer.from(inflate(d))
+const brotliDecompressAsync = (d: Buffer) => Buffer.from(BrotliDecode(Int8Array.from(d)))
+
+export const inflates = { inflateAsync, brotliDecompressAsync, Buffer }

package/src/inflate/node.ts

@@ -0,0 +1,11 @@
+import { promisify } from 'node:util'
+import { brotliDecompress, inflate } from 'node:zlib'
+import { Buffer } from 'buffer'
+
+const inflateAsync = promisify<Parameters<typeof inflate>[0], Parameters<Parameters<typeof inflate>[2]>[1]>(inflate)
+const brotliDecompressAsync = promisify<
+  Parameters<typeof brotliDecompress>[0],
+  Parameters<Parameters<typeof brotliDecompress>[1]>[1]
+>(brotliDecompress)
+
+export const inflates = { inflateAsync, brotliDecompressAsync, Buffer }

package/src/tcp.ts

@@ -0,0 +1,48 @@
+import net, { Socket } from 'net'
+
+import { Inflates } from './buffer'
+import { LiveOptions, Live } from './common'
+
+export type TCPOptions = LiveOptions & { host?: string, port?: number }
+
+export class LiveTCPBase extends Live {
+  socket: Socket
+  buffer: Buffer
+  i: number
+
+  constructor(inflates: Inflates, roomid: number, { host = 'broadcastlv.chat.bilibili.com', port = 2243, ...options}: TCPOptions = {}) {
+    const socket = net.connect(port, host)
+    const send = (data: Buffer) => {
+      socket.write(data)
+    }
+    const close = () => this.socket.end()
+
+    super(inflates, roomid, { send, close, ...options })
+
+    this.i = 0
+    this.buffer = Buffer.alloc(0)
+
+    socket.on('ready', () => this.emit('open'))
+    socket.on('close', () => this.emit('close'))
+    socket.on('error', (...params) => this.emit('_error', ...params))
+    socket.on('data', buffer => {
+      this.buffer = Buffer.concat([this.buffer, buffer])
+      this.splitBuffer()
+    })
+    this.socket = socket
+  }
+
+  splitBuffer() {
+    while (this.buffer.length >= 4 && this.buffer.readInt32BE(0) <= this.buffer.length) {
+      const size = this.buffer.readInt32BE(0)
+      const pack = this.buffer.slice(0, size)
+      this.buffer = this.buffer.slice(size)
+      this.i++
+      if (this.i > 5) {
+        this.i = 0
+        this.buffer = Buffer.from(this.buffer)
+      }
+      this.emit('message', pack)
+    }
+  }
+}

package/src/ws.ts

@@ -0,0 +1,61 @@
+import { EventEmitter } from 'events'
+import { Agent } from 'http'
+import IsomorphicWebSocket from 'isomorphic-ws'
+
+import { Inflates } from './buffer'
+import { LiveOptions, Live } from './common'
+
+export type WSOptions = LiveOptions & { address?: string, agent?: Agent }
+
+export const isNode = !!IsomorphicWebSocket.Server
+
+class WebSocket extends EventEmitter {
+  ws: IsomorphicWebSocket
+
+  constructor(address: string, inflates: Inflates, ...args: any[]) {
+    super()
+
+    const ws = new IsomorphicWebSocket(address, ...(isNode ? args : []))
+    this.ws = ws
+
+    ws.onopen = () => this.emit('open')
+    ws.onmessage = isNode ? ({ data }) => this.emit('message', data) : async ({ data }) => this.emit('message', inflates.Buffer.from(await new Response(data as unknown as InstanceType<typeof Blob>).arrayBuffer()))
+    ws.onerror = () => this.emit('error')
+    ws.onclose = () => this.emit('close')
+  }
+
+  get readyState() {
+    return this.ws.readyState
+  }
+
+  send(data: Buffer) {
+    this.ws.send(data)
+  }
+
+  close(code?: number, data?: string) {
+    this.ws.close(code, data)
+  }
+}
+
+export class LiveWSBase extends Live {
+  ws: InstanceType<typeof WebSocket>
+
+  constructor(inflates: Inflates, roomid: number, { address = 'wss://broadcastlv.chat.bilibili.com/sub', agent, ...options }: WSOptions = {}) {
+    const ws = new WebSocket(address, inflates, { agent })
+    const send = (data: Buffer) => {
+      if (ws.readyState === 1) {
+        ws.send(data)
+      }
+    }
+    const close = () => this.ws.close()
+
+    super(inflates, roomid, { send, close, ...options })
+
+    ws.on('open', (...params) => this.emit('open', ...params))
+    ws.on('message', data => this.emit('message', data as Buffer))
+    ws.on('close', (code, reason) => this.emit('close', code, reason))
+    ws.on('error', error => this.emit('_error', error))
+
+    this.ws = ws
+  }
+}