@laplace.live/ws 6.3.3 → 6.3.5

package/src/common.ts

@@ -1,216 +0,0 @@
-import { EventEmitter } from 'events'
-
-import { encoder, type Inflates, makeDecoder } from './buffer.ts'
-
-export type LiveOptions = { protover?: 1 | 2 | 3; key?: string; authBody?: any; uid?: number; buvid?: string }
-
-export const relayEvent = Symbol('relay')
-
-class NiceEventEmitter extends EventEmitter {
-  emit(eventName: string | symbol, ...params: any[]) {
-    super.emit(eventName, ...params)
-    super.emit(relayEvent, eventName, ...params)
-    return true
-  }
-}
-
-export class Live extends NiceEventEmitter {
-  roomid: number
-  online: number
-  live: boolean
-  closed: boolean
-  timeout: ReturnType<typeof setTimeout>
-
-  inflates: Inflates
-
-  send: (data: Buffer) => void
-  close: () => void
-
-  constructor(
-    inflates: Inflates,
-    roomid: number,
-    {
-      send,
-      close,
-      protover = 3,
-      key,
-      authBody,
-      uid = 0,
-      buvid,
-    }: { send: (data: Buffer) => void; close: () => void } & LiveOptions
-  ) {
-    if (typeof roomid !== 'number' || Number.isNaN(roomid)) {
-      throw new Error(`roomid ${roomid} must be Number not NaN`)
-    }
-
-    super()
-    this.inflates = inflates
-    this.roomid = roomid
-    this.online = 0
-    this.live = false
-    this.closed = false
-    this.timeout = setTimeout(() => {}, 0)
-
-    this.send = send
-    this.close = () => {
-      this.closed = true
-      close()
-    }
-
-    this.on('message', async buffer => {
-      const packs = await makeDecoder(inflates)(buffer)
-      packs.forEach(({ type, data }) => {
-        if (type === 'welcome') {
-          this.live = true
-          this.emit('live')
-          this.send(encoder('heartbeat', inflates))
-        }
-        if (type === 'heartbeat') {
-          this.online = data
-          clearTimeout(this.timeout)
-          this.timeout = setTimeout(() => this.heartbeat(), 1000 * 30)
-          this.emit('heartbeat', this.online)
-        }
-        if (type === 'message') {
-          this.emit('msg', data)
-          const cmd = data.cmd || (data.msg && data.msg.cmd)
-          if (cmd) {
-            if (cmd.includes('DANMU_MSG')) {
-              this.emit('DANMU_MSG', data)
-            } else {
-              this.emit(cmd, data)
-            }
-          }
-        }
-      })
-    })
-
-    this.on('open', () => {
-      if (authBody) {
-        if (typeof authBody === 'object') {
-          authBody = encoder('join', inflates, authBody)
-        }
-        this.send(authBody)
-      } else {
-        const hi: {
-          uid: number
-          roomid: number
-          protover: number
-          platform: string
-          type: number
-          key?: string
-          buvid?: string
-        } = { uid: uid, roomid, protover, platform: 'web', type: 2 }
-        if (key) {
-          hi.key = key
-        }
-        if (buvid) {
-          hi.buvid = buvid
-        }
-        const buf = encoder('join', inflates, hi)
-        this.send(buf)
-      }
-    })
-
-    this.on('close', () => {
-      clearTimeout(this.timeout)
-    })
-
-    this.on('_error', error => {
-      this.close()
-      this.emit('error', error)
-    })
-  }
-
-  heartbeat() {
-    this.send(encoder('heartbeat', this.inflates))
-  }
-
-  getOnline() {
-    this.heartbeat()
-    return new Promise<number>(resolve => this.once('heartbeat', resolve))
-  }
-}
-
-export class KeepLive<Base extends typeof Live> extends EventEmitter {
-  params: ConstructorParameters<Base>
-  closed: boolean
-  interval: number
-  timeout: number
-  connection: InstanceType<Base>
-  Base: Base
-
-  constructor(Base: Base, ...params: ConstructorParameters<Base>) {
-    super()
-    this.params = params
-    this.closed = false
-    this.interval = 100
-    this.timeout = 45 * 1000
-    this.connection = new (Base as any)(...this.params)
-    this.Base = Base
-    this.connect(false)
-  }
-
-  connect(reconnect = true) {
-    if (reconnect) {
-      this.connection.close()
-      this.connection = new (this.Base as any)(...this.params)
-    }
-    const connection = this.connection
-
-    let timeout = setTimeout(() => {
-      connection.close()
-      connection.emit('timeout')
-    }, this.timeout)
-
-    connection.on(relayEvent, (eventName: string, ...params: any[]) => {
-      if (eventName !== 'error') {
-        this.emit(eventName, ...params)
-      }
-    })
-
-    connection.on('error', e => this.emit('e', e))
-    connection.on('close', () => {
-      if (!this.closed) {
-        setTimeout(() => this.connect(), this.interval)
-      }
-    })
-
-    connection.on('heartbeat', () => {
-      clearTimeout(timeout)
-      timeout = setTimeout(() => {
-        connection.close()
-        connection.emit('timeout')
-      }, this.timeout)
-    })
-
-    connection.on('close', () => {
-      clearTimeout(timeout)
-    })
-  }
-
-  get online() {
-    return this.connection.online
-  }
-
-  get roomid() {
-    return this.connection.roomid
-  }
-
-  close() {
-    this.closed = true
-    this.connection.close()
-  }
-
-  heartbeat() {
-    return this.connection.heartbeat()
-  }
-
-  getOnline() {
-    return this.connection.getOnline()
-  }
-
-  send(data: Buffer) {
-    return this.connection.send(data)
-  }
-}

package/src/extra.ts

@@ -1,33 +0,0 @@
-type GET_DANMU_INFO = {
-  code: number
-  message: string
-  ttl: number
-  data: {
-    business_id: number
-    group: string
-    host_list: {
-      host: string
-      port: number
-      wss_port: number
-      ws_port: number
-    }[]
-    max_delay: number
-    refresh_rate: number
-    refresh_row_factor: number
-    token: string
-  }
-}
-
-export const getConf = async (roomid: number) => {
-  // eslint-disable-next-line @typescript-eslint/no-var-requires
-  const raw = await fetch(`https://api.live.bilibili.com/xlive/web-room/v1/index/getDanmuInfo?id=${roomid}`).then(w => w.json()) as GET_DANMU_INFO
-  const { data: { token: key, host_list: [{ host }] } } = raw
-  const address = `wss://${host}/sub`
-  return { key, host, address, raw }
-}
-
-export const getRoomid = async (short: number) => {
-  // eslint-disable-next-line @typescript-eslint/no-var-requires
-  const { data: { room_id } } = await fetch(`https://api.live.bilibili.com/room/v1/Room/mobileRoomInit?id=${short}`).then(w => w.json())
-  return room_id
-}

package/src/index.test.ts

@@ -1,191 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { once } from 'events'
-
-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 = (
-  live:
-    | LiveWS
-    | LiveTCP
-    | KeepLiveWS
-    | KeepLiveTCP
-    | InstanceType<typeof LiveWSBrowser>
-    | InstanceType<typeof KeepLiveWSBrowser>
-) =>
-  setTimeout(() => {
-    if (!live.closed) {
-      live.close()
-    }
-  }, TIMEOUT)
-
-describe('extra', () => {
-  it('getRoomid', async () => {
-    const roomid = await getRoomid(255)
-    expect(roomid).toBe(48743)
-  })
-})
-
-Object.entries({
-  LiveWS,
-  LiveTCP,
-  KeepLiveWS,
-  KeepLiveTCP,
-  LiveWSBrowser,
-  KeepLiveWSBrowser,
-}).forEach(([name, Live]) => {
-  describe(name, () => {
-    describe('Connect', () => {
-      it('online', async () => {
-        const live = new Live(12235923)
-        watch(live)
-        const [online] = await once(live, 'heartbeat')
-        live.close()
-        expect(online).toBeGreaterThan(0)
-      })
-      it('roomid must be number', () => {
-        expect(() => new (Live as any)('12235923')).toThrow()
-      })
-      it('roomid can not be NaN', () => {
-        expect(() => new (Live as any)(NaN)).toThrow()
-      })
-    })
-    describe('properties', () => {
-      describe('roomid', () => {
-        Object.entries({
-          Mea: 12235923,
-          nana: 21304638,
-          fubuki: 11588230,
-        }).forEach(([roomName, roomid]) => {
-          it(`roomid ${roomName}`, async () => {
-            const live = new Live(roomid)
-            watch(live)
-            await once(live, 'live')
-            live.close()
-            expect(live.roomid).toBe(roomid)
-          })
-        })
-      })
-      it('online', async () => {
-        const live = new Live(12235923)
-        watch(live)
-        const [online] = await once(live, 'heartbeat')
-        live.close()
-        expect(online).toBe(live.online)
-      })
-      it('closed', async () => {
-        const live = new Live(12235923)
-        watch(live)
-        expect(live.closed).toBe(false)
-        await once(live, 'live')
-        live.close()
-        expect(live.closed).toBe(true)
-      })
-    })
-    describe('functions', () => {
-      it('close', async () => {
-        const live = new Live(12235923)
-        watch(live)
-        await once(live, 'heartbeat')
-        const close = await new Promise(resolve => {
-          live.on('close', () => resolve('closed'))
-          live.close()
-        })
-        expect(close).toBe('closed')
-      })
-      it('getOnline', async () => {
-        const live = new Live(12235923)
-        watch(live)
-        await once(live, 'live')
-        const online = await live.getOnline()
-        live.close()
-        expect(online).toBeGreaterThan(0)
-      })
-      if (name.includes('Keep')) {
-        it('no error relay', async () => {
-          const live = new Live(12235923) as KeepLiveWS | KeepLiveTCP
-          watch(live)
-          await once(live, 'live')
-          await new Promise<void>((resolve, reject) => {
-            live.once('error', reject)
-            live.connection.emit('error', new Error('This shold not be caught'))
-            setTimeout(resolve, 1000)
-          })
-          live.close()
-        })
-      }
-      if (name.includes('Keep')) {
-        it('close and reopen', async () => {
-          const live = new Live(12235923) as KeepLiveWS | KeepLiveTCP
-          watch(live)
-          await once(live, 'live')
-          live.connection.close()
-          await once(live, 'live')
-          live.close()
-        })
-      } else {
-        it('close on error', async () => {
-          const live = new Live(12235923)
-          watch(live)
-          await once(live, 'heartbeat')
-          const close = await new Promise(resolve => {
-            live.on('close', () => resolve('closed'))
-            live.on('error', () => {})
-            live.emit('_error', Error())
-          })
-          expect(close).toBe('closed')
-        })
-      }
-    })
-    describe('options', () => {
-      it('protover: 1', async () => {
-        const live = new Live(12235923, { protover: 1 })
-        watch(live)
-        const [online] = await once(live, 'heartbeat')
-        live.close()
-        expect(online).toBeGreaterThan(0)
-      })
-      it('protover: 3', async () => {
-        const live = new Live(12235923, { protover: 3 })
-        watch(live)
-        const [online] = await once(live, 'heartbeat')
-        live.close()
-        expect(online).toBeGreaterThan(0)
-      })
-      if (name.includes('WS')) {
-        it('address', async () => {
-          const L = Live as typeof LiveWS | typeof KeepLiveWS
-          const live = new L(12235923, {
-            address: 'wss://broadcastlv.chat.bilibili.com/sub',
-          })
-          watch(live)
-          const [online] = await once(live, 'heartbeat')
-          live.close()
-          expect(online).toBeGreaterThan(0)
-        })
-      } else if (name.includes('TCP')) {
-        it('host, port', async () => {
-          const live = new Live(12235923, {
-            host: 'broadcastlv.chat.bilibili.com',
-            port: 2243,
-          })
-          watch(live)
-          const [online] = await once(live, 'heartbeat')
-          live.close()
-          expect(online).toBeGreaterThan(0)
-        })
-      } else {
-        throw new Error('no options test')
-      }
-      it('key: token', async () => {
-        const { key, host, address } = await getConf(12235923)
-        const live = new Live(12235923, { key, host, address })
-        watch(live)
-        const [online] = await once(live, 'heartbeat')
-        live.close()
-        expect(online).toBeGreaterThan(0)
-      })
-    })
-  })
-})

package/src/index.ts

@@ -1,35 +0,0 @@
-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.ts'
-export type { TCPOptions } from './tcp.ts'
-export type { WSOptions } from './ws-node.ts'
-
-export { relayEvent } from './common.ts'
-export { getConf, getRoomid } from './extra.ts'
-
-export class LiveWS extends LiveWSBase {
-  constructor(roomid: number, opts?: WSOptions) {
-    super(inflates, roomid, opts)
-  }
-}
-
-export class LiveTCP extends LiveTCPBase {
-  constructor(roomid: number, opts?: TCPOptions) {
-    super(inflates, roomid, opts)
-  }
-}
-
-export class KeepLiveWS extends KeepLive<typeof LiveWSBase> {
-  constructor(roomid: number, opts?: WSOptions) {
-    super(LiveWSBase, inflates, roomid, opts)
-  }
-}
-
-export class KeepLiveTCP extends KeepLive<typeof LiveTCPBase> {
-  constructor(roomid: number, opts?: TCPOptions) {
-    super(LiveTCPBase, inflates, roomid, opts)
-  }
-}