@laplace.live/ws 6.3.4 → 6.3.6

package/dist/common-D1XOmtU3.d.ts

@@ -0,0 +1,55 @@
+type Inflates = {
+    inflateAsync: (b: Uint8Array) => Uint8Array | Promise<Uint8Array>;
+    brotliDecompressAsync: (b: Uint8Array) => Uint8Array | Promise<Uint8Array>;
+};
+
+type LiveOptions = {
+    protover?: 1 | 2 | 3;
+    key?: string;
+    authBody?: any;
+    uid?: number;
+    buvid?: string;
+};
+declare class DataEvent<T> extends Event {
+    data: T;
+    constructor(type: string, data: T);
+}
+declare class EventEvent extends Event {
+    event: Event;
+    constructor(event: Event);
+}
+declare class Live extends EventTarget {
+    roomid: number;
+    online: number;
+    live: boolean;
+    closed: boolean;
+    timeout: ReturnType<typeof setTimeout>;
+    send: (data: Uint8Array) => void;
+    close: () => void;
+    constructor(inflates: Inflates, roomid: number, { send, close, protover, key, authBody, uid, buvid, }: {
+        send: (data: Uint8Array) => void;
+        close: () => void;
+    } & LiveOptions);
+    dispatchEvent(event: Event): boolean;
+    heartbeat(): void;
+    getOnline(): Promise<number>;
+}
+declare class KeepLive<Base extends typeof Live> extends EventTarget {
+    params: ConstructorParameters<Base>;
+    closed: boolean;
+    interval: number;
+    timeout: number;
+    connection: InstanceType<Base>;
+    Base: Base;
+    constructor(Base: Base, ...params: ConstructorParameters<Base>);
+    dispatchEvent(event: Event): boolean;
+    connect(reconnect?: boolean): void;
+    get online(): number;
+    get roomid(): number;
+    close(): void;
+    heartbeat(): void;
+    getOnline(): Promise<number>;
+    send(data: Uint8Array): void;
+}
+
+export { DataEvent as D, EventEvent as E, type Inflates as I, KeepLive as K, Live as L, type LiveOptions as a };

package/dist/index.d.ts

@@ -0,0 +1,68 @@
+import { L as Live, I as Inflates, a as LiveOptions, K as KeepLive } from './common-D1XOmtU3.js';
+export { D as DataEvent, E as EventEvent } from './common-D1XOmtU3.js';
+import { Socket } from 'node:net';
+import { Agent } from 'node:http';
+import WS from 'ws';
+
+type TCPOptions = LiveOptions & {
+    host?: string;
+    port?: number;
+};
+declare class LiveTCPBase extends Live {
+    socket: Socket;
+    buf: Buffer;
+    i: number;
+    constructor(inflates: Inflates, roomid: number, { host, port, ...options }?: TCPOptions);
+    splitBuffer(): void;
+}
+
+type WSOptions = LiveOptions & {
+    address?: string;
+    agent?: Agent;
+};
+declare class LiveWSBase extends Live {
+    ws: WS;
+    constructor(inflates: Inflates, roomid: number, { address, agent, ...options }?: WSOptions);
+}
+
+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;
+    };
+};
+declare const getConf: (roomid: number) => Promise<{
+    key: string;
+    host: string;
+    address: string;
+    raw: GET_DANMU_INFO;
+}>;
+declare const getRoomid: (short: number) => Promise<any>;
+
+declare class LiveWS extends LiveWSBase {
+    constructor(roomid: number, opts?: WSOptions);
+}
+declare class LiveTCP extends LiveTCPBase {
+    constructor(roomid: number, opts?: TCPOptions);
+}
+declare class KeepLiveWS extends KeepLive<typeof LiveWSBase> {
+    constructor(roomid: number, opts?: WSOptions);
+}
+declare class KeepLiveTCP extends KeepLive<typeof LiveTCPBase> {
+    constructor(roomid: number, opts?: TCPOptions);
+}
+
+export { KeepLiveTCP, KeepLiveWS, LiveOptions, LiveTCP, LiveWS, type TCPOptions, type WSOptions, getConf, getRoomid };

package/dist/index.js

@@ -0,0 +1,395 @@
+// src/buffer.ts
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+function concatUint8Arrays(arrs) {
+  let totalLength = 0;
+  for (const arr of arrs) totalLength += arr.length;
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of arrs) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+var cutBuffer = (buffer) => {
+  const bufferPacks = [];
+  const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  let size;
+  for (let i = 0; i < buffer.length; i += size) {
+    size = view.getInt32(i);
+    bufferPacks.push(buffer.slice(i, i + size));
+  }
+  return bufferPacks;
+};
+var makeDecoder = ({ inflateAsync: inflateAsync2, brotliDecompressAsync: brotliDecompressAsync2 }) => {
+  const decoder = async (buffer) => {
+    const packs = await Promise.all(
+      cutBuffer(buffer).map(async (buf) => {
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        const body = buf.slice(16);
+        const protocol = view.getInt16(6);
+        const operation = view.getInt32(8);
+        let type = "unknow";
+        if (operation === 3) {
+          type = "heartbeat";
+        } else if (operation === 5) {
+          type = "message";
+        } else if (operation === 8) {
+          type = "welcome";
+        }
+        let data;
+        if (protocol === 0) {
+          data = JSON.parse(textDecoder.decode(body));
+        }
+        if (protocol === 1 && body.length === 4) {
+          const bodyView = new DataView(body.buffer, body.byteOffset, body.byteLength);
+          data = bodyView.getUint32(0);
+        }
+        if (protocol === 2) {
+          data = await decoder(await inflateAsync2(body));
+        }
+        if (protocol === 3) {
+          data = await decoder(await brotliDecompressAsync2(body));
+        }
+        return { buf, type, protocol, data };
+      })
+    );
+    return packs.flatMap((pack) => {
+      if (pack.protocol === 2 || pack.protocol === 3) {
+        return pack.data;
+      }
+      return pack;
+    });
+  };
+  return decoder;
+};
+var encoder = (type, body = "") => {
+  if (typeof body !== "string") {
+    body = JSON.stringify(body);
+  }
+  const head = new Uint8Array(16);
+  const headView = new DataView(head.buffer, head.byteOffset, head.byteLength);
+  const buffer = textEncoder.encode(body);
+  headView.setInt32(0, buffer.length + head.length);
+  headView.setInt16(4, 16);
+  headView.setInt16(6, 1);
+  if (type === "heartbeat") {
+    headView.setInt32(8, 2);
+  }
+  if (type === "join") {
+    headView.setInt32(8, 7);
+  }
+  headView.setInt32(12, 1);
+  return concatUint8Arrays([head, buffer]);
+};
+
+// src/common.ts
+var DataEvent = class extends Event {
+  data;
+  constructor(type, data) {
+    super(type);
+    this.data = data;
+  }
+};
+var EventEvent = class extends Event {
+  event;
+  constructor(event) {
+    super("event");
+    this.event = event;
+  }
+};
+var Live = class extends EventTarget {
+  roomid;
+  online;
+  live;
+  closed;
+  timeout;
+  send;
+  close;
+  constructor(inflates2, roomid, {
+    send,
+    close,
+    protover = 3,
+    key,
+    authBody,
+    uid = 0,
+    buvid
+  }) {
+    if (typeof roomid !== "number" || Number.isNaN(roomid)) {
+      throw new Error(`roomid ${roomid} must be Number not NaN`);
+    }
+    super();
+    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();
+    };
+    const decode = makeDecoder(inflates2);
+    this.addEventListener("message", async (e) => {
+      const buffer = e.data;
+      const packs = await decode(buffer);
+      packs.forEach(({ type, data }) => {
+        if (type === "welcome") {
+          this.live = true;
+          this.dispatchEvent(new Event("live"));
+          this.send(encoder("heartbeat"));
+        }
+        if (type === "heartbeat") {
+          this.online = data;
+          clearTimeout(this.timeout);
+          this.timeout = setTimeout(() => this.heartbeat(), 1e3 * 30);
+          this.dispatchEvent(new DataEvent("heartbeat", this.online));
+        }
+        if (type === "message") {
+          this.dispatchEvent(new DataEvent("msg", data));
+          const cmd = data.cmd || data.msg?.cmd;
+          if (cmd) {
+            if (cmd.includes("DANMU_MSG")) {
+              this.dispatchEvent(new DataEvent("DANMU_MSG", data));
+            } else {
+              this.dispatchEvent(new DataEvent(cmd, data));
+            }
+          }
+        }
+      });
+    });
+    this.addEventListener("open", () => {
+      if (authBody) {
+        if (typeof authBody === "object") {
+          authBody = encoder("join", authBody);
+        }
+        this.send(authBody);
+      } else {
+        const hi = { uid, roomid, protover, platform: "web", type: 2 };
+        if (key) {
+          hi.key = key;
+        }
+        if (buvid) {
+          hi.buvid = buvid;
+        }
+        const buf = encoder("join", hi);
+        this.send(buf);
+      }
+    });
+    this.addEventListener("close", () => {
+      clearTimeout(this.timeout);
+    });
+    this.addEventListener("_error", () => {
+      this.close();
+      this.dispatchEvent(new Event("error"));
+    });
+  }
+  dispatchEvent(event) {
+    const result = super.dispatchEvent(event);
+    super.dispatchEvent(new EventEvent(event));
+    return result;
+  }
+  heartbeat() {
+    this.send(encoder("heartbeat"));
+  }
+  getOnline() {
+    this.heartbeat();
+    return new Promise(
+      (resolve) => this.addEventListener("heartbeat", (e) => resolve(e.data), { once: true })
+    );
+  }
+};
+var KeepLive = class extends EventTarget {
+  params;
+  closed;
+  interval;
+  timeout;
+  connection;
+  Base;
+  constructor(Base, ...params) {
+    super();
+    this.params = params;
+    this.closed = false;
+    this.interval = 100;
+    this.timeout = 45 * 1e3;
+    this.connection = new Base(...this.params);
+    this.Base = Base;
+    this.connect(false);
+  }
+  dispatchEvent(event) {
+    const result = super.dispatchEvent(event);
+    super.dispatchEvent(new EventEvent(event));
+    return result;
+  }
+  connect(reconnect = true) {
+    if (reconnect) {
+      this.connection.close();
+      this.connection = new this.Base(...this.params);
+    }
+    const connection = this.connection;
+    let timeout = setTimeout(() => {
+      connection.close();
+      connection.dispatchEvent(new Event("timeout"));
+    }, this.timeout);
+    connection.addEventListener("event", (e) => {
+      const evt = e.event;
+      if (evt.type !== "error") {
+        if (evt instanceof DataEvent) {
+          this.dispatchEvent(new DataEvent(evt.type, evt.data));
+        } else {
+          this.dispatchEvent(new Event(evt.type));
+        }
+      }
+    });
+    connection.addEventListener("error", () => this.dispatchEvent(new Event("e")));
+    connection.addEventListener("close", () => {
+      if (!this.closed) {
+        setTimeout(() => this.connect(), this.interval);
+      }
+    });
+    connection.addEventListener("heartbeat", () => {
+      clearTimeout(timeout);
+      timeout = setTimeout(() => {
+        connection.close();
+        connection.dispatchEvent(new Event("timeout"));
+      }, this.timeout);
+    });
+    connection.addEventListener("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) {
+    return this.connection.send(data);
+  }
+};
+
+// src/inflate/node.ts
+import { promisify } from "util";
+import { brotliDecompress, inflate } from "zlib";
+var _inflate = promisify(inflate);
+var _brotli = promisify(brotliDecompress);
+var inflateAsync = (b) => _inflate(b);
+var brotliDecompressAsync = (b) => _brotli(b);
+var inflates = { inflateAsync, brotliDecompressAsync };
+
+// src/tcp.ts
+import net from "net";
+var LiveTCPBase = class extends Live {
+  socket;
+  buf;
+  i;
+  constructor(inflates2, roomid, { host = "broadcastlv.chat.bilibili.com", port = 2243, ...options } = {}) {
+    const socket = net.connect(port, host);
+    const send = (data) => {
+      socket.write(data);
+    };
+    const close = () => this.socket.end();
+    super(inflates2, roomid, { send, close, ...options });
+    this.i = 0;
+    this.buf = Buffer.alloc(0);
+    socket.on("ready", () => this.dispatchEvent(new Event("open")));
+    socket.on("close", () => this.dispatchEvent(new Event("close")));
+    socket.on("error", () => this.dispatchEvent(new Event("_error")));
+    socket.on("data", (buffer) => {
+      this.buf = Buffer.concat([this.buf, buffer]);
+      this.splitBuffer();
+    });
+    this.socket = socket;
+  }
+  splitBuffer() {
+    while (this.buf.length >= 4 && this.buf.readInt32BE(0) <= this.buf.length) {
+      const size = this.buf.readInt32BE(0);
+      const pack = this.buf.slice(0, size);
+      this.buf = this.buf.slice(size);
+      this.i++;
+      if (this.i > 5) {
+        this.i = 0;
+        this.buf = Buffer.from(this.buf);
+      }
+      this.dispatchEvent(new DataEvent("message", pack));
+    }
+  }
+};
+
+// src/ws-node.ts
+import WS from "ws";
+var LiveWSBase = class extends Live {
+  ws;
+  constructor(inflates2, roomid, { address = "wss://broadcastlv.chat.bilibili.com/sub", agent, ...options } = {}) {
+    const ws = new WS(address, { agent });
+    const send = (data) => {
+      if (ws.readyState === 1) {
+        ws.send(data);
+      }
+    };
+    const close = () => this.ws.close();
+    super(inflates2, roomid, { send, close, ...options });
+    ws.on("open", () => this.dispatchEvent(new Event("open")));
+    ws.on("message", (data) => this.dispatchEvent(new DataEvent("message", data)));
+    ws.on("close", () => this.dispatchEvent(new Event("close")));
+    ws.on("error", () => this.dispatchEvent(new Event("_error")));
+    this.ws = ws;
+  }
+};
+
+// src/extra.ts
+var getConf = async (roomid) => {
+  const raw = await fetch(`https://api.live.bilibili.com/xlive/web-room/v1/index/getDanmuInfo?id=${roomid}`).then((w) => w.json());
+  const { data: { token: key, host_list: [{ host }] } } = raw;
+  const address = `wss://${host}/sub`;
+  return { key, host, address, raw };
+};
+var getRoomid = async (short) => {
+  const { data: { room_id } } = await fetch(`https://api.live.bilibili.com/room/v1/Room/mobileRoomInit?id=${short}`).then((w) => w.json());
+  return room_id;
+};
+
+// src/index.ts
+var LiveWS = class extends LiveWSBase {
+  constructor(roomid, opts) {
+    super(inflates, roomid, opts);
+  }
+};
+var LiveTCP = class extends LiveTCPBase {
+  constructor(roomid, opts) {
+    super(inflates, roomid, opts);
+  }
+};
+var KeepLiveWS = class extends KeepLive {
+  constructor(roomid, opts) {
+    super(LiveWSBase, inflates, roomid, opts);
+  }
+};
+var KeepLiveTCP = class extends KeepLive {
+  constructor(roomid, opts) {
+    super(LiveTCPBase, inflates, roomid, opts);
+  }
+};
+export {
+  DataEvent,
+  EventEvent,
+  KeepLiveTCP,
+  KeepLiveWS,
+  LiveTCP,
+  LiveWS,
+  getConf,
+  getRoomid
+};

package/package.json

@@ -1,22 +1,41 @@
 {
   "name": "@laplace.live/ws",
-  "version": "6.3.4",
+  "version": "6.3.6",
   "description": "Bilibili Live WebSocket/TCP API",
   "type": "module",
-  "main": "./src/index.ts",
-  "browser": "./src/browser.ts",
+  "main": "./dist/index.js",
+  "browser": "./dist/browser.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "browser": "./src/browser.ts",
-      "default": "./src/index.ts"
+      "browser": {
+        "types": "./dist/browser.d.ts",
+        "default": "./dist/browser.js"
+      },
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
-    "./server": "./src/index.ts",
-    "./client": "./src/browser.ts",
-    "./browser": "./src/browser.ts"
+    "./server": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/browser.d.ts",
+      "default": "./dist/browser.js"
+    },
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "default": "./dist/browser.js"
+    }
   },
+  "files": [
+    "dist"
+  ],
   "scripts": {
+    "build": "tsup",
     "check": "tsc --noEmit",
-    "test": "bun test --timeout 5000"
+    "test": "bun test --timeout 5000",
+    "prepublishOnly": "bun run build"
   },
   "repository": {
     "type": "git",
@@ -41,8 +60,6 @@
     "provenance": true
   },
   "dependencies": {
-    "buffer": "^6.0.3",
-    "events": "^3.3.0",
     "pako": "^2.1.0",
     "ws": "^8.19.0"
   },
@@ -51,6 +68,7 @@
     "@types/bun": "^1.3.10",
     "@types/pako": "^2.0.4",
     "@types/ws": "^8.18.1",
+    "tsup": "^8.5.1",
     "typescript": "^5.9.3"
   }
 }

package/src/browser.ts

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

package/src/buffer.ts

@@ -1,82 +0,0 @@
-export type { Buffer } from 'buffer'
-export type Inflates = { inflateAsync: (b: Buffer) => Buffer | Promise<Buffer>, brotliDecompressAsync: (b: Buffer) => Buffer | Promise<Buffer>, Buffer: typeof Buffer }
-
-// https://github.com/lovelyyoshino/Bilibili-Live-API/blob/master/API.WebSocket.md
-
-const cutBuffer = (buffer: Buffer) => {
-  const bufferPacks: Buffer[] = []
-  let size: number
-  for (let i = 0; i < buffer.length; i += size) {
-    size = buffer.readInt32BE(i)
-    bufferPacks.push(buffer.slice(i, i + size))
-  }
-  return bufferPacks
-}
-
-export const makeDecoder = ({ inflateAsync, brotliDecompressAsync }: Inflates) => {
-  const decoder = async (buffer: Buffer) => {
-    const packs = await Promise.all(cutBuffer(buffer)
-      .map(async buf => {
-        const body = buf.slice(16)
-        const protocol = buf.readInt16BE(6)
-        const operation = buf.readInt32BE(8)
-
-        let type = 'unknow'
-        if (operation === 3) {
-          type = 'heartbeat'
-        } else if (operation === 5) {
-          type = 'message'
-        } else if (operation === 8) {
-          type = 'welcome'
-        }
-
-        let data: any
-        if (protocol === 0) {
-          data = JSON.parse(String(body))
-        }
-        if (protocol === 1 && body.length === 4) {
-          data = body.readUIntBE(0, 4)
-        }
-        if (protocol === 2) {
-          data = await decoder(await inflateAsync(body))
-        }
-        if (protocol === 3) {
-          data = await decoder(await brotliDecompressAsync(body))
-        }
-
-        return { buf, type, protocol, data }
-      }))
-
-    return packs.flatMap(pack => {
-      if (pack.protocol === 2 || pack.protocol === 3) {
-        return pack.data as typeof packs
-      }
-      return pack
-    })
-  }
-
-  return decoder
-}
-
-type EncodeType = 'heartbeat' | 'join'
-
-export const encoder = (type: EncodeType, { Buffer }: Inflates, body: any = '') => {
-  const blank = Buffer.alloc(16)
-  if (typeof body !== 'string') {
-    body = JSON.stringify(body)
-  }
-  const head = Buffer.from(blank)
-  const buffer = Buffer.from(body)
-
-  head.writeInt32BE(buffer.length + head.length, 0)
-  head.writeInt16BE(16, 4)
-  head.writeInt16BE(1, 6)
-  if (type === 'heartbeat') {
-    head.writeInt32BE(2, 8)
-  }
-  if (type === 'join') {
-    head.writeInt32BE(7, 8)
-  }
-  head.writeInt32BE(1, 12)
-  return Buffer.concat([head, buffer])
-}