@laplace.live/ws 6.3.3 → 6.3.5

package/dist/common-BGRg5uk7.d.ts

@@ -0,0 +1,53 @@
+import { EventEmitter } from 'events';
+
+type Inflates = {
+    inflateAsync: (b: Buffer) => Buffer | Promise<Buffer>;
+    brotliDecompressAsync: (b: Buffer) => Buffer | Promise<Buffer>;
+    Buffer: typeof Buffer;
+};
+
+type LiveOptions = {
+    protover?: 1 | 2 | 3;
+    key?: string;
+    authBody?: any;
+    uid?: number;
+    buvid?: string;
+};
+declare const relayEvent: unique symbol;
+declare class NiceEventEmitter extends EventEmitter {
+    emit(eventName: string | symbol, ...params: any[]): boolean;
+}
+declare 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, key, authBody, uid, buvid, }: {
+        send: (data: Buffer) => void;
+        close: () => void;
+    } & LiveOptions);
+    heartbeat(): void;
+    getOnline(): Promise<number>;
+}
+declare 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>);
+    connect(reconnect?: boolean): void;
+    get online(): number;
+    get roomid(): number;
+    close(): void;
+    heartbeat(): void;
+    getOnline(): Promise<number>;
+    send(data: Buffer): void;
+}
+
+export { type Inflates as I, KeepLive as K, Live as L, type LiveOptions as a, relayEvent as r };

package/dist/index.d.ts

@@ -0,0 +1,76 @@
+import { L as Live, I as Inflates, a as LiveOptions, K as KeepLive } from './common-BGRg5uk7.js';
+export { r as relayEvent } from './common-BGRg5uk7.js';
+import { Socket } from 'node:net';
+import { Agent } from 'node:http';
+import { EventEmitter } from 'events';
+import WS from 'ws';
+
+type TCPOptions = LiveOptions & {
+    host?: string;
+    port?: number;
+};
+declare class LiveTCPBase extends Live {
+    socket: Socket;
+    buffer: Buffer;
+    i: number;
+    constructor(inflates: Inflates, roomid: number, { host, port, ...options }?: TCPOptions);
+    splitBuffer(): void;
+}
+
+type WSOptions = LiveOptions & {
+    address?: string;
+    agent?: Agent;
+};
+declare class WSWrapper extends EventEmitter {
+    ws: WS;
+    constructor(address: string, ...args: any[]);
+    get readyState(): 0 | 1 | 3 | 2;
+    send(data: Buffer): void;
+    close(code?: number, data?: string): void;
+}
+declare class LiveWSBase extends Live {
+    ws: WSWrapper;
+    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,377 @@
+// src/common.ts
+import { EventEmitter } from "events";
+
+// src/buffer.ts
+var cutBuffer = (buffer) => {
+  const bufferPacks = [];
+  let size;
+  for (let i = 0; i < buffer.length; i += size) {
+    size = buffer.readInt32BE(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 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;
+      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 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, { Buffer: Buffer3 }, body = "") => {
+  const blank = Buffer3.alloc(16);
+  if (typeof body !== "string") {
+    body = JSON.stringify(body);
+  }
+  const head = Buffer3.from(blank);
+  const buffer = Buffer3.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 Buffer3.concat([head, buffer]);
+};
+
+// src/common.ts
+var relayEvent = /* @__PURE__ */ Symbol("relay");
+var NiceEventEmitter = class extends EventEmitter {
+  emit(eventName, ...params) {
+    super.emit(eventName, ...params);
+    super.emit(relayEvent, eventName, ...params);
+    return true;
+  }
+};
+var Live = class extends NiceEventEmitter {
+  roomid;
+  online;
+  live;
+  closed;
+  timeout;
+  inflates;
+  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.inflates = inflates2;
+    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(inflates2)(buffer);
+      packs.forEach(({ type, data }) => {
+        if (type === "welcome") {
+          this.live = true;
+          this.emit("live");
+          this.send(encoder("heartbeat", inflates2));
+        }
+        if (type === "heartbeat") {
+          this.online = data;
+          clearTimeout(this.timeout);
+          this.timeout = setTimeout(() => this.heartbeat(), 1e3 * 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", inflates2, 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", inflates2, 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((resolve) => this.once("heartbeat", resolve));
+  }
+};
+var KeepLive = class extends EventEmitter {
+  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);
+  }
+  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.emit("timeout");
+    }, this.timeout);
+    connection.on(relayEvent, (eventName, ...params) => {
+      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) {
+    return this.connection.send(data);
+  }
+};
+
+// src/inflate/node.ts
+import { promisify } from "util";
+import { brotliDecompress, inflate } from "zlib";
+import { Buffer as Buffer2 } from "buffer";
+var inflateAsync = promisify(inflate);
+var brotliDecompressAsync = promisify(brotliDecompress);
+var inflates = { inflateAsync, brotliDecompressAsync, Buffer: Buffer2 };
+
+// src/tcp.ts
+import net from "net";
+var LiveTCPBase = class extends Live {
+  socket;
+  buffer;
+  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.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);
+    }
+  }
+};
+
+// src/ws-node.ts
+import { EventEmitter as EventEmitter2 } from "events";
+import WS from "ws";
+var WSWrapper = class extends EventEmitter2 {
+  ws;
+  constructor(address, ...args) {
+    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) {
+    this.ws.send(data);
+  }
+  close(code, data) {
+    this.ws.close(code, data);
+  }
+};
+var LiveWSBase = class extends Live {
+  ws;
+  constructor(inflates2, roomid, { address = "wss://broadcastlv.chat.bilibili.com/sub", agent, ...options } = {}) {
+    const ws = new WSWrapper(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", (...params) => this.emit("open", ...params));
+    ws.on("message", (data) => this.emit("message", data));
+    ws.on("close", (code, reason) => this.emit("close", code, reason));
+    ws.on("error", (error) => this.emit("_error", 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 {
+  KeepLiveTCP,
+  KeepLiveWS,
+  LiveTCP,
+  LiveWS,
+  getConf,
+  getRoomid,
+  relayEvent
+};

package/package.json

@@ -1,22 +1,41 @@
 {
   "name": "@laplace.live/ws",
-  "version": "6.3.3",
+  "version": "6.3.5",
   "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,6 +60,9 @@
     "provenance": true
   },
   "dependencies": {
+    "buffer": "^6.0.3",
+    "events": "^3.3.0",
+    "pako": "^2.1.0",
     "ws": "^8.19.0"
   },
   "devDependencies": {
@@ -48,11 +70,7 @@
     "@types/bun": "^1.3.10",
     "@types/pako": "^2.0.4",
     "@types/ws": "^8.18.1",
+    "tsup": "^8.5.1",
     "typescript": "^5.9.3"
-  },
-  "peerDependencies": {
-    "buffer": "^6.0.3",
-    "events": "^3.3.0",
-    "pako": "^2.1.0"
   }
 }

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])
-}