@laplace.live/ws 7.1.5 → 7.1.7

package/README.md

@@ -2,12 +2,11 @@
 
 LAPLACE Live! flavored bilibili live WebSocket/TCP API.
 
-This project is based on [bilibili-live-ws](https://github.com/simon300000/bilibili-live-ws) and has the exact same API as the original project, with the following differences:
+A modern, web-standard rewrite of [bilibili-live-ws](https://github.com/simon300000/bilibili-live-ws). It provides the same core classes (`LiveWS`, `LiveTCP`, `KeepLiveWS`, `KeepLiveTCP`) but uses a different event API and drops all Node.js polyfills:
 
 - Pure ESM
-- Uses web-standard `EventTarget`/`Event` instead of Node.js `EventEmitter` polyfills
-- Uses native `WebSocket` API directly, removing `isomorphic-ws` and `ws` dependencies
-- No `Buffer` polyfills
+- Web-standard `EventTarget`/`Event` instead of Node.js `EventEmitter` — use `addEventListener` / `removeEventListener` instead of `.on()` / `.once()`
+- Native `WebSocket` API directly — no `isomorphic-ws` or `ws` dependencies
 - Typed `addEventListener` via `LiveEventMap` with `@laplace.live/internal` types
 - Conditional `exports` field with `./server`, `./client`, `./browser` sub-path exports
 
@@ -73,6 +72,45 @@ const live = new LiveTCP(25034104, { key: "..." });
 live.addEventListener("heartbeat", ({ data }) => console.log("Online:", data));
 ```
 
+## Migrating from bilibili-live-ws
+
+### Event listeners
+
+Replace `.on()` / `.once()` with `addEventListener()` / `removeEventListener()`.
+Event data is accessed via the event object's `.data` property instead of direct
+callback arguments:
+
+```diff
+- live.on('heartbeat', (online) => console.log(online));
++ live.addEventListener('heartbeat', ({ data: online }) => console.log(online));
+
+- live.on('DANMU_MSG', (data) => console.log(data));
++ live.addEventListener('DANMU_MSG', ({ data }) => console.log(data));
+
+- live.once('live', () => console.log('entered'));
++ live.addEventListener('live', () => console.log('entered'), { once: true });
+```
+
+### Catch-all event
+
+The `relayEvent` symbol is replaced by an `event` meta-event:
+
+```diff
+- const { relayEvent } = require('bilibili-live-ws');
+- live.on(relayEvent, (name, data) => ...);
++ live.addEventListener('event', ({ data }) => ...);
+```
+
+### Buffer → Uint8Array
+
+Raw data uses `Uint8Array` instead of `Buffer`. If you pass a custom
+`authBody` as binary, use `Uint8Array`:
+
+```diff
+- live = new LiveWS(roomid, { authBody: Buffer.from(...) });
++ live = new LiveWS(roomid, { authBody: new Uint8Array(...) });
+```
+
 ## License
 
 MIT

package/dist/browser.d.ts

@@ -1,5 +1,5 @@
-import { K as KeepLive, b as LiveWSBase, W as WSOptions } from './ws-CAEZj7O-.js';
-export { c as LaplaceRawEvent, d as LiveEventMap, a as LiveOptions } from './ws-CAEZj7O-.js';
+import { K as KeepLive, b as LiveWSBase, W as WSOptions } from './ws-mjTot1Nb.js';
+export { c as LaplaceEventTarget, d as LaplaceRawEvent, e as LiveEventMap, a as LiveOptions } from './ws-mjTot1Nb.js';
 import '@laplace.live/internal';
 
 /**

package/dist/browser.js

@@ -1798,9 +1798,16 @@ var LaplaceRawEvent = class extends Event {
     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 EventTarget {
+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. */
@@ -1820,15 +1827,6 @@ var KeepLive = class extends EventTarget {
     this.connection = this.createConnection();
     this.connect(false);
   }
-  /**
-   * Overridden to also dispatch a `LaplaceRawEvent<Event>` with type `"event"`
-   * for every event, enabling catch-all listeners.
-   */
-  dispatchEvent(event) {
-    const result = super.dispatchEvent(event);
-    super.dispatchEvent(new LaplaceRawEvent("event", event));
-    return result;
-  }
   /**
    * Wire up event forwarding and timeout handling on the current connection.
    * When `reconnect` is `true`, the previous connection is closed and a fresh
@@ -1992,7 +1990,7 @@ var encoder = (type, body = "") => {
 };
 
 // src/live.ts
-var Live = class extends EventTarget {
+var Live = class extends LaplaceEventTarget {
   /** The live room ID this instance is connected to. */
   roomid;
   /** Latest known online viewer count, updated on each heartbeat. */
@@ -2083,15 +2081,6 @@ var Live = class extends EventTarget {
       this.dispatchEvent(new Event("error"));
     });
   }
-  /**
-   * Overridden to also dispatch a `LaplaceRawEvent<Event>` with type `"event"`
-   * for every event, enabling catch-all listeners.
-   */
-  dispatchEvent(event) {
-    const result = super.dispatchEvent(event);
-    super.dispatchEvent(new LaplaceRawEvent("event", event));
-    return result;
-  }
   /** Send a heartbeat packet to the server. */
   heartbeat() {
     this.send(encoder("heartbeat"));
@@ -2111,8 +2100,8 @@ var Live = class extends EventTarget {
 var LiveWSBase = class extends Live {
   /** The underlying native WebSocket instance. */
   ws;
-  constructor(inflates2, roomid, { address = "wss://broadcastlv.chat.bilibili.com/sub", ...options } = {}) {
-    const ws = new WebSocket(address);
+  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);
@@ -2142,6 +2131,7 @@ var KeepLiveWS = class extends KeepLive {
 };
 export {
   KeepLiveWS,
+  LaplaceEventTarget,
   LaplaceRawEvent,
   LiveWS
 };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { L as Live, I as Inflates, a as LiveOptions, K as KeepLive, b as LiveWSBase, W as WSOptions } from './ws-CAEZj7O-.js';
-export { c as LaplaceRawEvent, d as LiveEventMap } from './ws-CAEZj7O-.js';
+import { L as Live, I as Inflates, a as LiveOptions, K as KeepLive, b as LiveWSBase, W as WSOptions } from './ws-mjTot1Nb.js';
+export { c as LaplaceEventTarget, d as LaplaceRawEvent, e as LiveEventMap } from './ws-mjTot1Nb.js';
 import { Socket } from 'node:net';
 import { BilibiliInternal } from '@laplace.live/internal';
 

package/dist/index.js

@@ -15,9 +15,16 @@ var LaplaceRawEvent = class extends Event {
     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 EventTarget {
+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. */
@@ -37,15 +44,6 @@ var KeepLive = class extends EventTarget {
     this.connection = this.createConnection();
     this.connect(false);
   }
-  /**
-   * Overridden to also dispatch a `LaplaceRawEvent<Event>` with type `"event"`
-   * for every event, enabling catch-all listeners.
-   */
-  dispatchEvent(event) {
-    const result = super.dispatchEvent(event);
-    super.dispatchEvent(new LaplaceRawEvent("event", event));
-    return result;
-  }
   /**
    * Wire up event forwarding and timeout handling on the current connection.
    * When `reconnect` is `true`, the previous connection is closed and a fresh
@@ -212,7 +210,7 @@ var encoder = (type, body = "") => {
 };
 
 // src/live.ts
-var Live = class extends EventTarget {
+var Live = class extends LaplaceEventTarget {
   /** The live room ID this instance is connected to. */
   roomid;
   /** Latest known online viewer count, updated on each heartbeat. */
@@ -303,15 +301,6 @@ var Live = class extends EventTarget {
       this.dispatchEvent(new Event("error"));
     });
   }
-  /**
-   * Overridden to also dispatch a `LaplaceRawEvent<Event>` with type `"event"`
-   * for every event, enabling catch-all listeners.
-   */
-  dispatchEvent(event) {
-    const result = super.dispatchEvent(event);
-    super.dispatchEvent(new LaplaceRawEvent("event", event));
-    return result;
-  }
   /** Send a heartbeat packet to the server. */
   heartbeat() {
     this.send(encoder("heartbeat"));
@@ -378,8 +367,8 @@ var LiveTCPBase = class extends Live {
 var LiveWSBase = class extends Live {
   /** The underlying native WebSocket instance. */
   ws;
-  constructor(inflates2, roomid, { address = "wss://broadcastlv.chat.bilibili.com/sub", ...options } = {}) {
-    const ws = new WebSocket(address);
+  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);
@@ -443,6 +432,7 @@ var KeepLiveTCP = class extends KeepLive {
 export {
   KeepLiveTCP,
   KeepLiveWS,
+  LaplaceEventTarget,
   LaplaceRawEvent,
   LiveTCP,
   LiveWS,

package/dist/{ws-CAEZj7O-.d.ts → ws-mjTot1Nb.d.ts}

@@ -101,6 +101,37 @@ interface LiveEventMap {
     LIVE_OPEN_PLATFORM_LIVE_END: LaplaceRawEvent<BilibiliInternal.WebSocket.OpenPlatform.LIVE_OPEN_PLATFORM_LIVE_END>;
     LIVE_OPEN_PLATFORM_INTERACTION_END: LaplaceRawEvent<BilibiliInternal.WebSocket.OpenPlatform.LIVE_OPEN_PLATFORM_INTERACTION_END>;
 }
+/**
+ * Typed {@link EventTarget} base class for live connections.
+ *
+ * Provides typed `addEventListener` / `removeEventListener` via
+ * {@link LiveEventMap} and a `dispatchEvent` override that emits a
+ * catch-all `"event"` meta-event for every dispatched event.
+ *
+ * Extend this instead of `EventTarget` when building wrappers around
+ * `LiveWS` / `KeepLiveWS` to inherit typed event signatures
+ * automatically — no `declare` duplication required.
+ *
+ * @example
+ * ```ts
+ * import { LaplaceEventTarget, LaplaceRawEvent } from '@laplace.live/ws'
+ *
+ * class MyWrapper extends LaplaceEventTarget {
+ *   // addEventListener is already typed — no extra `declare` needed
+ * }
+ * ```
+ */
+declare class LaplaceEventTarget extends EventTarget {
+    dispatchEvent(event: Event): boolean;
+    addEventListener: {
+        <K extends keyof LiveEventMap>(type: K, listener: (ev: LiveEventMap[K]) => void, options?: boolean | AddEventListenerOptions): void;
+        <T = unknown>(type: string, listener: (ev: LaplaceRawEvent<T>) => void, options?: boolean | AddEventListenerOptions): void;
+    };
+    removeEventListener: {
+        <K extends keyof LiveEventMap>(type: K, listener: (ev: LiveEventMap[K]) => void, options?: boolean | EventListenerOptions): void;
+        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    };
+}
 
 /**
  * Options for configuring the Bilibili live connection authentication.
@@ -127,7 +158,7 @@ type LiveOptions = {
 /**
  * Base class for a single Bilibili live room connection.
  *
- * Extends {@link EventTarget} and emits the following events:
+ * Extends {@link LaplaceEventTarget} and emits the following events:
  *
  * | Event         | Payload            | Description                                      |
  * |---------------|--------------------|--------------------------------------------------|
@@ -149,7 +180,7 @@ type LiveOptions = {
  *
  * @throws {Error} If `roomid` is not a finite number.
  */
-declare class Live extends EventTarget {
+declare class Live extends LaplaceEventTarget {
     /** The live room ID this instance is connected to. */
     roomid: number;
     /** Latest known online viewer count, updated on each heartbeat. */
@@ -168,11 +199,6 @@ declare class Live extends EventTarget {
         send: (data: Uint8Array) => void;
         close: () => void;
     } & LiveOptions);
-    /**
-     * Overridden to also dispatch a `LaplaceRawEvent<Event>` with type `"event"`
-     * for every event, enabling catch-all listeners.
-     */
-    dispatchEvent(event: Event): boolean;
     /** Send a heartbeat packet to the server. */
     heartbeat(): void;
     /**
@@ -181,36 +207,6 @@ declare class Live extends EventTarget {
      * @returns A promise that resolves with the current online count.
      */
     getOnline(): Promise<number>;
-    /**
-     * Typed `addEventListener` that narrows the inherited {@link EventTarget}
-     * signature using {@link LiveEventMap}.
-     *
-     * - Known events (e.g. `"heartbeat"`, `"DANMU_MSG"`) are auto-typed.
-     * - Unknown/dynamic events accept a generic `<T>` for the payload type.
-     *
-     * Uses `declare` to shadow the inherited type without emitting code —
-     * at runtime this is still `EventTarget.prototype.addEventListener`.
-     *
-     * @example
-     * ```ts
-     * live.addEventListener('heartbeat', (e) => console.log(e.data))
-     * live.addEventListener('DANMU_MSG', ({ data }) => console.log(data.msg_id))
-     * live.addEventListener<CustomType>('NEW_CMD', ({ data }) => console.log(data))
-     * ```
-     */
-    addEventListener: {
-        <K extends keyof LiveEventMap>(type: K, listener: (ev: LiveEventMap[K]) => void, options?: boolean | AddEventListenerOptions): void;
-        <T = unknown>(type: string, listener: (ev: LaplaceRawEvent<T>) => void, options?: boolean | AddEventListenerOptions): void;
-    };
-    /**
-     * Typed `removeEventListener` matching {@link addEventListener}.
-     *
-     * Uses `declare` to shadow the inherited type without emitting code.
-     */
-    removeEventListener: {
-        <K extends keyof LiveEventMap>(type: K, listener: (ev: LiveEventMap[K]) => void, options?: boolean | EventListenerOptions): void;
-        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
-    };
 }
 
 /**
@@ -230,7 +226,7 @@ declare class Live extends EventTarget {
  * keep.addEventListener('DANMU_MSG', ({ data }) => console.log('danmaku:', data.msg_id))
  * ```
  */
-declare class KeepLive<T extends Live> extends EventTarget {
+declare class KeepLive<T extends Live> extends LaplaceEventTarget {
     /** @internal Factory that creates a fresh connection with the original arguments. */
     private createConnection;
     /** `true` after {@link close} has been called; prevents further reconnects. */
@@ -242,11 +238,6 @@ declare class KeepLive<T extends Live> extends EventTarget {
     /** The current underlying connection instance. */
     connection: T;
     constructor(createConnection: () => T);
-    /**
-     * Overridden to also dispatch a `LaplaceRawEvent<Event>` with type `"event"`
-     * for every event, enabling catch-all listeners.
-     */
-    dispatchEvent(event: Event): boolean;
     /**
      * Wire up event forwarding and timeout handling on the current connection.
      * When `reconnect` is `true`, the previous connection is closed and a fresh
@@ -274,16 +265,6 @@ declare class KeepLive<T extends Live> extends EventTarget {
      * @param data - The binary packet to send.
      */
     send(data: Uint8Array): void;
-    /** {@inheritDoc Live.addEventListener} */
-    addEventListener: {
-        <K extends keyof LiveEventMap>(type: K, listener: (ev: LiveEventMap[K]) => void, options?: boolean | AddEventListenerOptions): void;
-        <T = unknown>(type: string, listener: (ev: LaplaceRawEvent<T>) => void, options?: boolean | AddEventListenerOptions): void;
-    };
-    /** {@inheritDoc Live.removeEventListener} */
-    removeEventListener: {
-        <K extends keyof LiveEventMap>(type: K, listener: (ev: LiveEventMap[K]) => void, options?: boolean | EventListenerOptions): void;
-        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
-    };
 }
 
 /**
@@ -293,6 +274,8 @@ declare class KeepLive<T extends Live> extends EventTarget {
 type WSOptions = LiveOptions & {
     /** WebSocket server URL. Defaults to `wss://broadcastlv.chat.bilibili.com/sub`. */
     address?: string;
+    /** Factory to create the WebSocket (e.g. for runtime-specific options like Bun's proxy). */
+    createWebSocket?: (address: string) => WebSocket;
 };
 /**
  * WebSocket transport for Bilibili live room connections.
@@ -312,7 +295,7 @@ type WSOptions = LiveOptions & {
 declare class LiveWSBase extends Live {
     /** The underlying native WebSocket instance. */
     ws: WebSocket;
-    constructor(inflates: Inflates, roomid: number, { address, ...options }?: WSOptions);
+    constructor(inflates: Inflates, roomid: number, { address, createWebSocket, ...options }?: WSOptions);
 }
 
-export { type Inflates as I, KeepLive as K, Live as L, type WSOptions as W, type LiveOptions as a, LiveWSBase as b, LaplaceRawEvent as c, type LiveEventMap as d };
+export { type Inflates as I, KeepLive as K, Live as L, type WSOptions as W, type LiveOptions as a, LiveWSBase as b, LaplaceEventTarget as c, LaplaceRawEvent as d, type LiveEventMap as e };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@laplace.live/ws",
-  "version": "7.1.5",
+  "version": "7.1.7",
   "description": "LAPLACE Live! flavored bilibili live WebSocket/TCP API",
   "type": "module",
   "main": "./dist/index.js",