@laplace.live/ws 7.1.8 → 7.1.10

package/dist/index.js

@@ -1,437 +1,218 @@
-// 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/events.ts
-var LaplaceRawEvent = class extends Event {
-  data;
-  constructor(type, data) {
-    super(type);
-    this.data = data;
-  }
-};
-var LaplaceEventTarget = class extends EventTarget {
-  dispatchEvent(event) {
-    const result = super.dispatchEvent(event);
-    super.dispatchEvent(new LaplaceRawEvent("event", event));
-    return result;
-  }
-};
-
-// src/keep-live.ts
-var KeepLive = class extends LaplaceEventTarget {
-  /** @internal Factory that creates a fresh connection with the original arguments. */
-  createConnection;
-  /** `true` after {@link close} has been called; prevents further reconnects. */
-  closed;
-  /** Delay in milliseconds before attempting a reconnect. */
-  interval;
-  /** Maximum milliseconds to wait for a heartbeat before forcing a reconnect. */
-  timeout;
-  /** The current underlying connection instance. */
-  connection;
-  constructor(createConnection) {
-    super();
-    this.createConnection = createConnection;
-    this.closed = false;
-    this.interval = 100;
-    this.timeout = 45 * 1e3;
-    this.connection = this.createConnection();
-    this.connect(false);
-  }
-  /**
-   * Wire up event forwarding and timeout handling on the current connection.
-   * When `reconnect` is `true`, the previous connection is closed and a fresh
-   * one is created via the factory.
-   *
-   * @param reconnect - Whether to tear down and recreate the connection first.
-   */
-  connect(reconnect = true) {
-    if (reconnect) {
-      this.connection.close();
-      this.connection = this.createConnection();
-    }
-    const connection = this.connection;
-    let timeout = setTimeout(() => {
-      connection.close();
-      connection.dispatchEvent(new Event("timeout"));
-    }, this.timeout);
-    connection.addEventListener("event", (e) => {
-      const evt = e.data;
-      if (evt.type !== "error") {
-        if (evt instanceof LaplaceRawEvent) {
-          this.dispatchEvent(new LaplaceRawEvent(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);
-    });
-  }
-  /** Latest known online viewer count from the underlying connection. */
-  get online() {
-    return this.connection.online;
-  }
-  /** The live room ID. */
-  get roomid() {
-    return this.connection.roomid;
-  }
-  /** Permanently close the connection and stop reconnecting. */
-  close() {
-    this.closed = true;
-    this.connection.close();
-  }
-  /** Send a heartbeat packet to the server. */
-  heartbeat() {
-    return this.connection.heartbeat();
-  }
-  /**
-   * Send a heartbeat and resolve with the online viewer count from the
-   * next heartbeat response.
-   * @returns A promise that resolves with the current online count.
-   */
-  getOnline() {
-    return this.connection.getOnline();
-  }
-  /**
-   * Send raw binary data through the underlying connection.
-   * @param data - The binary packet to send.
-   */
-  send(data) {
-    return this.connection.send(data);
-  }
-};
-
-// src/tcp.ts
-import net from "net";
-
-// 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 = "") => {
-  const encoded = 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(encoded);
-  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/live.ts
-var Live = class extends LaplaceEventTarget {
-  /** The live room ID this instance is connected to. */
-  roomid;
-  /** Latest known online viewer count, updated on each heartbeat. */
-  online;
-  /** `true` after the server acknowledges the join (`welcome` packet). */
-  live;
-  /** `true` after {@link close} has been called. */
-  closed;
-  /** @internal Handle for the heartbeat interval timer. */
-  timeout;
-  /** Send raw binary data over the underlying transport. */
-  send;
-  /** Gracefully close the connection and set {@link closed} to `true`. */
-  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 LaplaceRawEvent("heartbeat", this.online));
-        }
-        if (type === "message") {
-          this.dispatchEvent(new LaplaceRawEvent("msg", data));
-          const cmd = data.cmd || data.msg?.cmd;
-          if (cmd) {
-            this.dispatchEvent(new LaplaceRawEvent(cmd, data));
-          }
-        }
-      });
-    });
-    this.addEventListener("open", () => {
-      if (authBody) {
-        this.send(authBody instanceof Uint8Array ? authBody : encoder("join", 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"));
-    });
-  }
-  /** Send a heartbeat packet to the server. */
-  heartbeat() {
-    this.send(encoder("heartbeat"));
-  }
-  /**
-   * Send a heartbeat and resolve with the online viewer count from the
-   * next heartbeat response.
-   * @returns A promise that resolves with the current online count.
-   */
-  getOnline() {
-    this.heartbeat();
-    return new Promise((resolve) => this.addEventListener("heartbeat", (e) => resolve(e.data), { once: true }));
-  }
-};
-
-// src/tcp.ts
+import { a as LaplaceRawEvent, i as LaplaceEventTarget, n as Live, r as KeepLive, t as LiveWSBase } from "./ws-DfVxzRDM.js";
+import { promisify } from "node:util";
+import { brotliDecompress, inflate } from "node:zlib";
+import net from "node:net";
+//#region src/inflate/node.ts
+const _inflate = promisify(inflate);
+const _brotli = promisify(brotliDecompress);
+const inflateAsync = (b) => _inflate(b);
+const brotliDecompressAsync = (b) => _brotli(b);
+const inflates = {
+	inflateAsync,
+	brotliDecompressAsync
+};
+//#endregion
+//#region src/tcp.ts
+/**
+* TCP transport for Bilibili live room connections.
+*
+* Wraps a Node.js TCP {@link Socket}, handling packet reassembly from the
+* stream and forwarding complete frames into the {@link Live} event system.
+*
+* Not typically instantiated directly — use {@link LiveTCP} which injects
+* the Node.js inflate implementation.
+*
+* @param inflates - Platform-specific inflate/brotli decompressors.
+* @param roomid   - Numeric Bilibili live room ID.
+* @param options  - TCP host/port and authentication options.
+*/
 var LiveTCPBase = class extends Live {
-  /** The underlying Node.js TCP socket. */
-  socket;
-  /** @internal Accumulator for incomplete packets from the TCP stream. */
-  buf;
-  /** @internal Counter for periodic buffer compaction. */
-  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;
-  }
-  /**
-   * Extract complete packets from the internal buffer and dispatch them
-   * as `message` events. Compacts the buffer periodically to avoid
-   * unbounded memory growth from `Buffer.concat` / `slice` chains.
-   * @internal
-   */
-  splitBuffer() {
-    while (this.buf.length >= 4 && this.buf.readInt32BE(0) <= this.buf.length) {
-      const size = this.buf.readInt32BE(0);
-      const pack = this.buf.subarray(0, size);
-      this.buf = this.buf.subarray(size);
-      this.i++;
-      if (this.i > 5) {
-        this.i = 0;
-        this.buf = Buffer.from(this.buf);
-      }
-      this.dispatchEvent(new LaplaceRawEvent("message", pack));
-    }
-  }
-};
-
-// src/ws.ts
-var LiveWSBase = class extends Live {
-  /** The underlying native WebSocket instance. */
-  ws;
-  constructor(inflates2, roomid, { address = "wss://broadcastlv.chat.bilibili.com/sub", createWebSocket, ...options } = {}) {
-    const ws = createWebSocket ? createWebSocket(address) : new WebSocket(address);
-    const send = (data) => {
-      if (ws.readyState === 1) {
-        ws.send(data);
-      }
-    };
-    const close = () => this.ws.close();
-    super(inflates2, roomid, { send, close, ...options });
-    ws.binaryType = "arraybuffer";
-    ws.addEventListener("open", (e) => this.dispatchEvent(new Event(e.type)));
-    ws.addEventListener("message", (e) => this.dispatchEvent(new LaplaceRawEvent("message", new Uint8Array(e.data))));
-    ws.addEventListener("close", (e) => this.dispatchEvent(new Event(e.type)));
-    ws.addEventListener("error", () => this.dispatchEvent(new Event("_error")));
-    this.ws = ws;
-  }
-};
-
-// src/extra.ts
-var getConf = async (roomid) => {
-  const resp = await fetch(`https://api.live.bilibili.com/xlive/web-room/v1/index/getDanmuInfo?id=${roomid}`);
-  const json = await resp.json();
-  if (!json.data) {
-    throw new Error(`getConf failed for room ${roomid}: ${json.message || "no data"} (code: ${json.code})`);
-  }
-  const {
-    data: {
-      token: key,
-      host_list: [{ host }]
-    }
-  } = json;
-  const address = `wss://${host}/sub`;
-  return { key, host, address, json };
-};
-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
+	/** The underlying Node.js TCP socket. */
+	socket;
+	/** @internal Accumulator for incomplete packets from the TCP stream. */
+	buf;
+	/** @internal Counter for periodic buffer compaction. */
+	i;
+	constructor(inflates, 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(inflates, roomid, {
+			send,
+			close,
+			...options
+		});
+		this.i = 0;
+		this.buf = Buffer.alloc(0);
+		socket.on("ready", () => this.dispatchEvent(new Event("open")));
+		socket.on("close", () => {
+			if (!this.closed) 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;
+	}
+	/**
+	* Extract complete packets from the internal buffer and dispatch them
+	* as `message` events. Compacts the buffer periodically to avoid
+	* unbounded memory growth from `Buffer.concat` / `slice` chains.
+	* @internal
+	*/
+	splitBuffer() {
+		while (this.buf.length >= 4 && this.buf.readInt32BE(0) <= this.buf.length) {
+			const size = this.buf.readInt32BE(0);
+			const pack = this.buf.subarray(0, size);
+			this.buf = this.buf.subarray(size);
+			this.i++;
+			if (this.i > 5) {
+				this.i = 0;
+				this.buf = Buffer.from(this.buf);
+			}
+			this.dispatchEvent(new LaplaceRawEvent("message", pack));
+		}
+	}
+};
+//#endregion
+//#region src/extra.ts
+/**
+* Fetch WebSocket connection configuration for a Bilibili live room directly
+* from the Bilibili API (`getDanmuInfo`).
+*
+* **Note:** This endpoint is subject to Bilibili's risk-control system and
+* may return error code `-352` when called without proper cookies or headers.
+* For production use, consider proxying through an external service that
+* handles authentication.
+*
+* @param roomid - Numeric Bilibili live room ID.
+* @returns An object containing:
+*   - `key` — authentication token for the WebSocket handshake
+*   - `host` — hostname of the danmaku WebSocket server
+*   - `address` — full `wss://` URL ready to pass as `WSOptions.address`
+*   - `raw` — the complete API response for advanced use
+* @throws {Error} If the API returns no data (e.g. invalid room or risk-control block).
+*/
+const getConf = async (roomid) => {
+	const json = await (await fetch(`https://api.live.bilibili.com/xlive/web-room/v1/index/getDanmuInfo?id=${roomid}`)).json();
+	if (!json.data) throw new Error(`getConf failed for room ${roomid}: ${json.message || "no data"} (code: ${json.code})`);
+	const { data: { token: key, host_list: [{ host }] } } = json;
+	return {
+		key,
+		host,
+		address: `wss://${host}/sub`,
+		json
+	};
+};
+/**
+* Resolve a short (vanity) room ID to its real numeric room ID via the
+* Bilibili API.
+*
+* Short room IDs are custom aliases (e.g. `1`) that map to longer numeric
+* IDs used internally by the live platform.
+*
+* @param short - The short or numeric room ID to resolve.
+* @returns The canonical numeric room ID.
+*/
+const 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;
+};
+//#endregion
+//#region src/index.ts
+/**
+* WebSocket client for a Bilibili live room (Node.js / Bun).
+*
+* Uses `node:zlib` for inflate and brotli decompression.
+*
+* @param roomid - Numeric Bilibili live room ID.
+* @param opts   - Optional WebSocket address and authentication options.
+*
+* @example
+* ```ts
+* import { LiveWS } from '@laplace.live/ws'
+*
+* const live = new LiveWS(12345, { key: '...', address: 'wss://...' })
+* live.on('DANMU_MSG', (e) => console.log(e.data))
+* ```
+*/
 var LiveWS = class extends LiveWSBase {
-  constructor(roomid, opts) {
-    super(inflates, roomid, opts);
-  }
-};
+	constructor(roomid, opts) {
+		super(inflates, roomid, opts);
+	}
+};
+/**
+* TCP client for a Bilibili live room (Node.js / Bun only).
+*
+* Uses `node:zlib` for inflate and brotli decompression, and `node:net`
+* for the TCP transport.
+*
+* @param roomid - Numeric Bilibili live room ID.
+* @param opts   - Optional TCP host/port and authentication options.
+*
+* @example
+* ```ts
+* import { LiveTCP } from '@laplace.live/ws'
+*
+* const live = new LiveTCP(12345, { key: '...' })
+* live.on('heartbeat', (e) => console.log('online:', e.data))
+* ```
+*/
 var LiveTCP = class extends LiveTCPBase {
-  constructor(roomid, opts) {
-    super(inflates, roomid, opts);
-  }
-};
+	constructor(roomid, opts) {
+		super(inflates, roomid, opts);
+	}
+};
+/**
+* Auto-reconnecting WebSocket client for a Bilibili live room
+* (Node.js / Bun).
+*
+* Wraps {@link LiveWS} with automatic reconnection on disconnect or
+* heartbeat timeout. All events from the underlying connection are
+* forwarded to this instance.
+*
+* @param roomid - Numeric Bilibili live room ID.
+* @param opts   - Optional WebSocket address and authentication options.
+*
+* @example
+* ```ts
+* import { KeepLiveWS } from '@laplace.live/ws'
+*
+* const keep = new KeepLiveWS(12345, { key: '...' })
+* keep.on('DANMU_MSG', (e) => console.log(e.data))
+* ```
+*/
 var KeepLiveWS = class extends KeepLive {
-  constructor(roomid, opts) {
-    super(() => new LiveWSBase(inflates, roomid, opts));
-  }
-};
+	constructor(roomid, opts) {
+		super(() => new LiveWSBase(inflates, roomid, opts));
+	}
+};
+/**
+* Auto-reconnecting TCP client for a Bilibili live room
+* (Node.js / Bun only).
+*
+* Wraps {@link LiveTCP} with automatic reconnection on disconnect or
+* heartbeat timeout. All events from the underlying connection are
+* forwarded to this instance.
+*
+* @param roomid - Numeric Bilibili live room ID.
+* @param opts   - Optional TCP host/port and authentication options.
+*
+* @example
+* ```ts
+* import { KeepLiveTCP } from '@laplace.live/ws'
+*
+* const keep = new KeepLiveTCP(12345, { key: '...' })
+* keep.on('heartbeat', (e) => console.log('online:', e.data))
+* ```
+*/
 var KeepLiveTCP = class extends KeepLive {
-  constructor(roomid, opts) {
-    super(() => new LiveTCPBase(inflates, roomid, opts));
-  }
-};
-export {
-  KeepLiveTCP,
-  KeepLiveWS,
-  LaplaceEventTarget,
-  LaplaceRawEvent,
-  LiveTCP,
-  LiveWS,
-  getConf,
-  getRoomid
+	constructor(roomid, opts) {
+		super(() => new LiveTCPBase(inflates, roomid, opts));
+	}
 };
+//#endregion
+export { KeepLiveTCP, KeepLiveWS, LaplaceEventTarget, LaplaceRawEvent, LiveTCP, LiveWS, getConf, getRoomid };