@laplace.live/ws 6.3.1 → 6.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@laplace.live/ws",
-  "version": "6.3.1",
+  "version": "6.3.3",
   "description": "Bilibili Live WebSocket/TCP API",
   "type": "module",
   "main": "./src/index.ts",
@@ -10,6 +10,8 @@
       "browser": "./src/browser.ts",
       "default": "./src/index.ts"
     },
+    "./server": "./src/index.ts",
+    "./client": "./src/browser.ts",
     "./browser": "./src/browser.ts"
   },
   "scripts": {
@@ -39,7 +41,6 @@
     "provenance": true
   },
   "dependencies": {
-    "isomorphic-ws": "^5.0.0",
     "ws": "^8.19.0"
   },
   "devDependencies": {

package/src/browser.ts

@@ -1,11 +1,11 @@
-import { KeepLive } from './common'
-import { inflates } from './inflate/browser'
-import { LiveWSBase, type WSOptions } from './ws'
+import { KeepLive } from './common.ts'
+import { inflates } from './inflate/browser.ts'
+import { LiveWSBase, type WSOptions } from './ws-client.ts'
 
-export type { LiveOptions } from './common'
-export type { WSOptions } from './ws'
+export type { LiveOptions } from './common.ts'
+export type { WSOptions } from './ws-client.ts'
 
-export { relayEvent } from './common'
+export { relayEvent } from './common.ts'
 
 export class LiveWS extends LiveWSBase {
   constructor(roomid: number, opts?: WSOptions) {

package/src/common.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'events'
 
-import { encoder, type Inflates, makeDecoder } from './buffer'
+import { encoder, type Inflates, makeDecoder } from './buffer.ts'
 
 export type LiveOptions = { protover?: 1 | 2 | 3; key?: string; authBody?: any; uid?: number; buvid?: string }
 

package/src/index.test.ts

@@ -1,8 +1,8 @@
 import { describe, expect, it } from 'bun:test'
 import { once } from 'events'
 
-import { KeepLiveWS as KeepLiveWSBrowser, LiveWS as LiveWSBrowser } from './browser'
-import { getConf, getRoomid, KeepLiveTCP, KeepLiveWS, LiveTCP, LiveWS } from './index'
+import { KeepLiveWS as KeepLiveWSBrowser, LiveWS as LiveWSBrowser } from './browser.ts'
+import { getConf, getRoomid, KeepLiveTCP, KeepLiveWS, LiveTCP, LiveWS } from './index.ts'
 
 const TIMEOUT = 1000 * 25
 const watch = (

package/src/index.ts

@@ -1,14 +1,14 @@
-import { KeepLive } from './common'
-import { inflates } from './inflate/node'
-import { LiveTCPBase, type TCPOptions } from './tcp'
-import { LiveWSBase, type WSOptions } from './ws'
+import { KeepLive } from './common.ts'
+import { inflates } from './inflate/node.ts'
+import { LiveTCPBase, type TCPOptions } from './tcp.ts'
+import { LiveWSBase, type WSOptions } from './ws-node.ts'
 
-export type { LiveOptions } from './common'
-export type { TCPOptions } from './tcp'
-export type { WSOptions } from './ws'
+export type { LiveOptions } from './common.ts'
+export type { TCPOptions } from './tcp.ts'
+export type { WSOptions } from './ws-node.ts'
 
-export { relayEvent } from './common'
-export { getConf, getRoomid } from './extra'
+export { relayEvent } from './common.ts'
+export { getConf, getRoomid } from './extra.ts'
 
 export class LiveWS extends LiveWSBase {
   constructor(roomid: number, opts?: WSOptions) {

package/src/inflate/browser.ts

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

package/src/tcp.ts

@@ -1,16 +1,21 @@
-import net, { Socket } from 'net'
+import net, { type Socket } from 'node:net'
 
-import { Inflates } from './buffer'
-import { LiveOptions, Live } from './common'
+import type { Inflates } from './buffer.ts'
 
-export type TCPOptions = LiveOptions & { host?: string, port?: number }
+import { Live, type LiveOptions } from './common.ts'
+
+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 = {}) {
+  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)

package/src/ws-client.ts

@@ -0,0 +1,63 @@
+import { EventEmitter } from 'events'
+
+import type { Inflates } from './buffer.ts'
+
+import { Live, type LiveOptions } from './common.ts'
+
+export type WSOptions = LiveOptions & { address?: string }
+
+class WSWrapper extends EventEmitter {
+  ws: WebSocket
+
+  constructor(address: string, inflates: Inflates) {
+    super()
+
+    const ws = new WebSocket(address)
+    this.ws = ws
+
+    ws.binaryType = 'arraybuffer'
+    ws.onopen = () => this.emit('open')
+    ws.onmessage = ({ data }) => this.emit('message', inflates.Buffer.from(data as 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, reason?: string) {
+    this.ws.close(code, reason)
+  }
+}
+
+export class LiveWSBase extends Live {
+  ws: WSWrapper
+
+  constructor(
+    inflates: Inflates,
+    roomid: number,
+    { address = 'wss://broadcastlv.chat.bilibili.com/sub', ...options }: WSOptions = {}
+  ) {
+    const ws = new WSWrapper(address, inflates)
+    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
+  }
+}

package/src/ws-node.ts

@@ -0,0 +1,64 @@
+import type { Agent } from 'node:http'
+import { EventEmitter } from 'events'
+import WS from 'ws'
+
+import type { Inflates } from './buffer.ts'
+
+import { Live, type LiveOptions } from './common.ts'
+
+export type WSOptions = LiveOptions & { address?: string; agent?: Agent }
+
+class WSWrapper extends EventEmitter {
+  ws: WS
+
+  constructor(address: string, ...args: any[]) {
+    super()
+
+    const ws = new WS(address, ...args)
+    this.ws = ws
+
+    ws.onopen = () => this.emit('open')
+    ws.onmessage = ({ data }) => this.emit('message', data)
+    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: WSWrapper
+
+  constructor(
+    inflates: Inflates,
+    roomid: number,
+    { address = 'wss://broadcastlv.chat.bilibili.com/sub', agent, ...options }: WSOptions = {}
+  ) {
+    const ws = new WSWrapper(address, { 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
+  }
+}

package/src/ws.ts

@@ -1,61 +0,0 @@
-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
-  }
-}