floating-live 0.15.0-beta.0 → 0.15.0-beta.2

package/README.md

@@ -1,6 +1,8 @@
 # Floating Live
 一个用于处理和保存直播弹幕的Node.js小工具，开箱即用。
 
+本体无弹幕获取功能，需要配合[floating-live-danmaku](https://github.com/Minteea/floating-live-danmaku)中的弹幕获取插件使用。
+
 目前支持bilibili和AcFun的直播弹幕，不同平台的弹幕会转换为同一种格式便于保存。
 
 项目仍在开发中，功能尚未完善，目前除了记录保存直播弹幕外暂时没有别的用处啦，敬请期待。
@@ -18,7 +20,7 @@ npm install floating-live
 // 导入FloatingLive
 const { FloatingLive } = require("floating-live")
 // 导入bilibili房间生成插件
-const bilibili = require("floating-live/plugin/bilibili")   
+const bilibili = require("@floating-live/bilibili/plugin")   
 
 // 创建一个FloatingLive实例
 const live = new FloatingLive()
@@ -28,36 +30,3 @@ live.plugin.register(bilibili)
 // 添加房间并自动打开
 live.room.add("bilibili", 6, true)
 ```
-
-### 拆包即用模式
-* 下载并安装 `Node.js` ，建议下载最新LTS版本（如果已经安装可跳过这一步）。
-* 下载该项目的zip压缩包，解压，并在项目根目录下新建一个名为 `save` 的文件夹。
-* 在项目根目录的控制台输入下列命令，安装所有依赖包。
-  ```
-  npm install
-  ```
-#### 运行Demo文件
-* 打开demo/demo.ts
-  ``` typescript
-  // ...
-  const config = {
-    rooms: [
-      {
-        platform: "bilibili", // 直播平台
-        id: 2064239,          // 直播间号
-      },
-    ],
-  };
-  // ...
-  ```
-* 根据需要修改直播平台和直播间号，目前支持的 `platform` 值有：`acfun`、`bilibili`(注意是小写)，也可以通过自定义插件添加直播平台
-* 在项目根目录的控制台输入下列命令：
-  ```
-  npm run test
-  ```
-  即可接收来自平台的直播弹幕。
-
-## 感谢
-### 使用开源库
-* [simon300000/bilibili-live-ws](https://github.com/simon300000/bilibili-live-ws/)
-* [ACFUN-FOSS/ac-danmu](https://github.com/ACFUN-FOSS/ac-danmu.js)

package/dist/core/LiveRoom.d.ts

@@ -33,8 +33,6 @@ export declare abstract class LiveRoom extends EventEmitter implements RoomInfo
     abstract close(): void;
     /** 从服务器获取信息 */
     abstract getInfo(): Promise<void>;
-    /** 设置用户凭据 */
-    setAuth?(auth: string): void;
     /** 销毁事件 */
     protected onDestory?(): void;
     /** 销毁 */

package/dist/core/index.d.ts

@@ -1,2 +1 @@
 export * from "./LiveRoom";
-export * from "./Reglist";

package/dist/core/index.js

@@ -15,4 +15,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./LiveRoom"), exports);
-__exportStar(require("./Reglist"), exports);

package/dist/core/plugin.d.ts

@@ -0,0 +1,17 @@
+import { FloatingLive } from "../live";
+import { FloatingEventMap } from "../types/events";
+export declare abstract class BasePlugin {
+    static pluginName: string;
+    protected main: FloatingLive;
+    private registerList;
+    constructor(main: FloatingLive);
+    /** 插件监听事件 */
+    on<T extends keyof FloatingEventMap>(eventName: T, listener: FloatingEventMap[T]): void;
+    /** 插件一次性监听事件 */
+    once<T extends keyof FloatingEventMap>(eventName: T, listener: FloatingEventMap[T]): void;
+    /** 插件移除监听事件 */
+    off<T extends keyof FloatingEventMap>(eventName: T, listener: FloatingEventMap[T]): void;
+    /** 插件发送事件 */
+    emit<T extends keyof FloatingEventMap>(eventName: T, ...args: Parameters<FloatingEventMap[T]>): void;
+    abstract destroy(): void;
+}

package/dist/core/plugin.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasePlugin = void 0;
+class BasePlugin {
+    constructor(main) {
+        this.registerList = [];
+        this.main = main;
+    }
+    /** 插件监听事件 */
+    on(eventName, listener) {
+        this.main.on(eventName, listener);
+        this.registerList.push(["event", eventName, listener]);
+    }
+    /** 插件一次性监听事件 */
+    once(eventName, listener) {
+        this.main.once(eventName, listener);
+        this.registerList.push(["event", eventName, listener]);
+    }
+    /** 插件移除监听事件 */
+    off(eventName, listener) {
+        this.main.off(eventName, listener);
+    }
+    /** 插件发送事件 */
+    emit(eventName, ...args) {
+        this.main.emit(eventName, ...args);
+    }
+}
+exports.BasePlugin = BasePlugin;

package/dist/index.d.ts

@@ -2,5 +2,4 @@ export { FloatingLive } from "./live";
 export * from "./types";
 export * from "./enums";
 export * from "./core/LiveRoom";
-export * from "./core/Reglist";
 export * from "./utils";

package/dist/index.js

@@ -20,5 +20,4 @@ Object.defineProperty(exports, "FloatingLive", { enumerable: true, get: function
 __exportStar(require("./types"), exports);
 __exportStar(require("./enums"), exports);
 __exportStar(require("./core/LiveRoom"), exports);
-__exportStar(require("./core/Reglist"), exports);
 __exportStar(require("./utils"), exports);

package/dist/live.d.ts

@@ -1,30 +1,28 @@
 /// <reference types="node" />
 import { EventEmitter } from "events";
-import { ModPlugin } from "./module/ModPlugin";
-import { ModRoom } from "./module/ModRoom";
-import { ModAuth } from "./module/ModAuth";
-import { ModMessage } from "./module/ModMessage";
-import { ModState } from "./module/ModState";
-import ModCommand from "./module/ModCommand";
+import { ModPlugin } from "./module/plugin";
+import { ModRoom } from "./module/room";
+import { ModStore } from "./module/store";
+import ModCommand from "./module/command";
+import { ModValues } from "./module/values";
+import { ModHook } from "./module/hook";
+import { FloatingEventMap } from "./types/events";
 export declare class FloatingLive extends EventEmitter {
     /** 房间控制模块 */
     room: ModRoom;
-    /** 消息处理模块 */
-    message: ModMessage;
-    /** 用户登录凭据模块 */
-    auth: ModAuth;
     /** 插件处理模块 */
-    plugin: ModPlugin<this>;
+    plugin: ModPlugin;
     /** 命令模块 */
     command: ModCommand;
     /** 状态模块 */
-    state: ModState;
-    /** 插件事件注册表 */
-    private regEventMap;
+    store: ModStore;
+    /** 数值模块 */
+    values: ModValues;
+    /** 数值模块 */
+    hook: ModHook;
     constructor();
-    /** 初始化 */
-    private init;
-    /** 重写事件监听 */
-    on(eventName: string, listener: (...args: any[]) => void): this;
-    emit(eventName: string | symbol, ...args: any[]): boolean;
+    call(name: string, ...args: any[]): any;
+    on<T extends keyof FloatingEventMap>(eventName: T, listener: FloatingEventMap[T]): this;
+    emit<T extends keyof FloatingEventMap>(eventName: T, ...args: any[]): boolean;
+    throw(err: Error): void;
 }

package/dist/live.js

@@ -5,52 +5,33 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FloatingLive = void 0;
 const events_1 = require("events");
-const ModPlugin_1 = require("./module/ModPlugin");
-const ModRoom_1 = require("./module/ModRoom");
-const ModAuth_1 = require("./module/ModAuth");
-const ModMessage_1 = require("./module/ModMessage");
-const ModState_1 = require("./module/ModState");
-const ModCommand_1 = __importDefault(require("./module/ModCommand"));
+const plugin_1 = require("./module/plugin");
+const room_1 = require("./module/room");
+const store_1 = require("./module/store");
+const command_1 = __importDefault(require("./module/command"));
+const values_1 = require("./module/values");
+const hook_1 = require("./module/hook");
 class FloatingLive extends events_1.EventEmitter {
     constructor() {
         super();
-        /** 插件事件注册表 */
-        this.regEventMap = new Map();
-        this.command = new ModCommand_1.default(this);
-        this.state = new ModState_1.ModState(this);
-        this.plugin = new ModPlugin_1.ModPlugin(this);
-        this.room = new ModRoom_1.ModRoom(this);
-        this.message = new ModMessage_1.ModMessage(this);
-        this.auth = new ModAuth_1.ModAuth(this);
-        this.init();
+        this.command = new command_1.default(this);
+        this.store = new store_1.ModStore(this);
+        this.plugin = new plugin_1.ModPlugin(this);
+        this.room = new room_1.ModRoom(this);
+        this.values = new values_1.ModValues(this);
+        this.hook = new hook_1.ModHook(this);
     }
-    /** 初始化 */
-    init() {
-        // 设置在插件卸载时移除由插件注册的事件
-        this.on("plugin:remove", (name) => {
-            this.regEventMap.get(name)?.forEach(([eventName, listener]) => {
-                this.removeListener(eventName, listener);
-            });
-        });
+    call(name, ...args) {
+        return this.command.call(name, ...args);
     }
-    /** 重写事件监听 */
     on(eventName, listener) {
-        super.on(eventName, listener);
-        // 检测是否为插件添加事件，并添加进事件列表
-        if (this.plugin.currentPlugin) {
-            if (!this.regEventMap.has(this.plugin.currentPlugin)) {
-                this.regEventMap.set(this.plugin.currentPlugin, []);
-            }
-            this.regEventMap
-                .get(this.plugin.currentPlugin)
-                ?.push([eventName, listener]);
-        }
-        return this;
+        return super.on(eventName, listener);
     }
     emit(eventName, ...args) {
-        const result = super.emit(eventName, ...args);
-        super.emit("event", eventName, ...args);
-        return result;
+        return super.emit(eventName, ...args);
+    }
+    throw(err) {
+        this.emit("error", err);
     }
 }
 exports.FloatingLive = FloatingLive;

package/dist/module/command.d.ts

@@ -0,0 +1,15 @@
+import { FloatingLive } from "../live";
+declare type CommandFunction = (...args: any[]) => any;
+export default class ModCommand {
+    /** 功能列表 */
+    private readonly list;
+    protected readonly main: FloatingLive;
+    constructor(main: FloatingLive);
+    /** 注册命令 */
+    register(name: string, func: CommandFunction): void;
+    /** 取消注册命令 */
+    unregister(name: string): void;
+    /** 调用命令 */
+    call(name: string, ...args: any[]): any;
+}
+export {};

package/dist/module/command.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ModCommand {
+    constructor(main) {
+        /** 功能列表 */
+        this.list = new Map();
+        this.main = main;
+    }
+    /** 注册命令 */
+    register(name, func) {
+        this.list.set(name, func);
+        this.main.emit("command:add", name);
+    }
+    /** 取消注册命令 */
+    unregister(name) {
+        this.list.delete(name);
+        this.main.emit("command:remove", name);
+    }
+    /** 调用命令 */
+    call(name, ...args) {
+        return this.list.get(name)?.(...args);
+    }
+}
+exports.default = ModCommand;

package/dist/module/hook.d.ts

@@ -0,0 +1,13 @@
+import { FloatingLive } from "../live";
+export declare type HookFunction<T> = (ctx: T) => boolean | void | Promise<boolean | void>;
+export declare class ModHook {
+    private list;
+    protected readonly main: FloatingLive;
+    constructor(main: FloatingLive);
+    /** 注册钩子函数 */
+    register<T>(name: string, func: HookFunction<T>): void;
+    /** 取消注册钩子函数 */
+    unregister(name: string, func: HookFunction<any>): void;
+    /** 调用钩子函数 */
+    call<T>(name: string, ctx: T): Promise<boolean>;
+}

package/dist/module/hook.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModHook = void 0;
+class ModHook {
+    constructor(main) {
+        this.list = new Map();
+        this.main = main;
+    }
+    /** 注册钩子函数 */
+    register(name, func) {
+        let hooks = this.list.get(name);
+        if (!hooks) {
+            hooks = [];
+            this.list.set(name, hooks);
+        }
+        hooks.push(func);
+    }
+    /** 取消注册钩子函数 */
+    unregister(name, func) {
+        let hooks = this.list.get(name);
+        if (hooks) {
+            const index = hooks.indexOf(func);
+            index > -1 && hooks.splice(index, 1);
+        }
+    }
+    /** 调用钩子函数 */
+    async call(name, ctx) {
+        const hooks = this.list.get(name);
+        if (!hooks) {
+            return true;
+        }
+        for (const func of hooks) {
+            const result = await func(ctx);
+            if (result == true) {
+                return true;
+            }
+            else if (result == false) {
+                return false;
+            }
+        }
+        return false;
+    }
+}
+exports.ModHook = ModHook;

package/dist/module/plugin.d.ts

@@ -0,0 +1,15 @@
+import { FloatingLive } from "../live";
+import { PluginConstructor } from "../types/plugin";
+export declare class ModPlugin {
+    private current;
+    /** 插件列表 */
+    private list;
+    protected readonly main: FloatingLive;
+    constructor(main: FloatingLive);
+    /** 获取当前安装插件 */
+    get currentPlugin(): string | null;
+    /** 注册插件 */
+    register(pluginFunc: PluginConstructor, config?: any): void;
+    /** 移除插件 */
+    unregister(name: string): void;
+}

package/dist/module/{ModPlugin.js → plugin.js}

@@ -6,50 +6,44 @@ class ModPlugin {
         this.current = null;
         /** 插件列表 */
         this.list = new Map();
-        this.pluginEvent = new Map();
-        this.exports = new Map();
         this.main = main;
     }
     /** 获取当前安装插件 */
     get currentPlugin() {
         return this.current;
     }
-    addPluginEvent(eventName, listener) {
-        if (this.currentPlugin) {
-            if (!this.pluginEvent.has(this.currentPlugin)) {
-                this.pluginEvent.set(this.currentPlugin, []);
-            }
-            this.pluginEvent.get(this.currentPlugin)?.push([eventName, listener]);
-        }
-    }
-    /** 访问插件操作对象 */
-    access(name) {
-        return this.exports.get(name);
-    }
     /** 注册插件 */
-    register(pluginFunc, pluginConfig) {
-        // 执行插件函数
-        const plugin = pluginFunc();
-        const name = plugin.name;
+    register(pluginFunc, config) {
+        const name = pluginFunc.name;
+        if (!name) {
+            this.main.throw(Object.assign(new TypeError("缺少插件id"), {
+                from: "plugin",
+                signal: "plugin_id_missing",
+            }));
+            return;
+        }
         if (this.list.has(name)) {
-            this.main.emit("plugin:duplicate", name);
+            this.main.throw(Object.assign(new Error("插件id重复"), {
+                from: "plugin",
+                signal: "plugin_id_duplicate",
+            }));
             return;
         }
+        // 执行插件函数
+        const plugin = new pluginFunc(this.main, config);
         this.list.set(name, plugin);
-        this.current = name;
-        // 调用register函数，并保存获取值
-        let pluginExpose = plugin.register?.(this.main, pluginConfig) || {};
-        this.exports.set(name, pluginExpose);
         this.main.emit("plugin:add", name);
         this.current = null;
-        return pluginExpose;
     }
     /** 移除插件 */
     unregister(name) {
         const plugin = this.list.get(name);
         // 检测插件是否存在
         if (!plugin) {
-            this.main.emit("plugin:unexist", name);
+            this.main.throw(Object.assign(new Error("插件不存在"), {
+                from: "plugin",
+                signal: "plugin_unexist",
+            }));
             return;
         }
         // 获取该插件的销毁函数

package/dist/module/{ModRoom.d.ts → room.d.ts}

@@ -1,25 +1,15 @@
-import { Reglist } from "../core/Reglist";
 import { LiveRoom } from "../core/LiveRoom";
 import { FloatingLive } from "../live";
 import { RoomInfo } from "../types";
 /** 直播间监听实例控制器 */
 export declare class ModRoom {
+    private list;
     readonly main: FloatingLive;
-    private roomMap;
-    private auths;
-    private configs;
-    generator: Reglist<(id: string | number, open?: boolean, config?: object) => LiveRoom>;
     constructor(main: FloatingLive);
-    /** 设置登录凭据 */
-    setAuth(platform: string, auth: string): void;
-    /** 设置房间配置 */
-    setConfig(platform: string, config: any): void;
-    /** 生成房间 */
-    generate(platform: string, id: string | number, open?: boolean): LiveRoom | undefined;
     /** 添加房间监听实例 */
     addRoom(room: LiveRoom, open?: boolean): void;
     /** 添加房间 */
-    add(platform: string, id: number, open: boolean): void;
+    add(platform: string, id: number, config?: boolean | Record<string, any>): void;
     /** 移除房间 */
     remove(roomKey: string): void;
     /** 获取房间 */

package/dist/module/room.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModRoom = void 0;
+/** 直播间监听实例控制器 */
+class ModRoom {
+    constructor(main) {
+        this.list = new Map();
+        this.main = main;
+        const { command } = main;
+        command.register("add", this.add.bind(this));
+        command.register("remove", this.remove.bind(this));
+        command.register("open", this.open.bind(this));
+        command.register("close", this.close.bind(this));
+        command.register("update", this.update.bind(this));
+    }
+    /** 添加房间监听实例 */
+    addRoom(room, open) {
+        let key = room.key;
+        if (this.list.has(key)) {
+            this.main.throw(Object.assign(new Error("房间已存在"), {
+                from: "room",
+                signal: "room_exist",
+            }));
+            return;
+        }
+        this.list.set(key, room);
+        // 添加监听事件
+        // 直播消息
+        room.on("msg", (data) => {
+            this.main.hook.call("message", data).then((res) => {
+                res && this.main.emit("live:message", data);
+            });
+        });
+        // 直播消息源数据
+        room.on("raw", (data, { platform, room }) => {
+            this.main.emit("live:raw", data, { platform, room });
+        });
+        // 连接到直播间
+        room.on("connect", () => {
+            this.main.emit("room:connect", key);
+        });
+        // 与直播间的连接已断开
+        room.on("disconnect", () => {
+            this.main.emit("room:disconnect", key);
+        });
+        // 获取房间信息
+        room.on("info", () => {
+            this.main.emit("room:info", key, room.info);
+        });
+        // 直播展示信息更改
+        room.on("detail", (data) => {
+            this.main.emit("room:detail", key, data);
+        });
+        // 直播状态更改
+        room.on("status", (status, { id, timestamp }) => {
+            this.main.emit("room:status", key, { status, id, timestamp });
+        });
+        // 统计数据更新
+        room.on("stats", (data) => {
+            this.main.emit("room:stats", key, data);
+        });
+        // 房间被打开
+        room.on("open", () => {
+            this.main.emit("room:open", key, room.info);
+        });
+        // 房间被关闭
+        room.on("close", () => {
+            this.main.emit("room:close", key, room.info);
+        });
+        if (open) {
+            room.open();
+        }
+        this.main.emit("room:add", key, room.info);
+    }
+    /** 添加房间 */
+    add(platform, id, config) {
+        if (typeof config == "boolean") {
+            config = { open: config };
+        }
+        const room = this.main.call(platform, id, config);
+        room && this.addRoom(room);
+    }
+    /** 移除房间 */
+    remove(roomKey) {
+        let room = this.list.get(roomKey);
+        if (!room) {
+            this.main.throw(Object.assign(new Error("房间不存在"), {
+                from: "room",
+                signal: "room_unexist",
+            }));
+        }
+        this.list.delete(roomKey); // 从表中删除房间
+        room?.removeAllListeners(); // 移除房间监听实例
+        this.main.emit("room:remove", roomKey);
+    }
+    /** 获取房间 */
+    get(roomKey) {
+        return this.list.get(roomKey);
+    }
+    /** 获取房间信息 */
+    info(roomKey) {
+        let room = this.list.get(roomKey);
+        return room ? room.info : undefined;
+    }
+    /** 更新房间信息 */
+    update(roomKey) {
+        let room = this.list.get(roomKey);
+        room && room.getInfo();
+    }
+    /** 获取roomKey列表 */
+    get keys() {
+        return [...this.list.keys()];
+    }
+    /** 打开房间连接 */
+    open(roomKey) {
+        let room = this.list.get(roomKey);
+        room?.available && !room.opened && room.open();
+    }
+    /** 关闭房间连接 */
+    close(roomKey) {
+        let room = this.list.get(roomKey);
+        room?.opened && room.close();
+    }
+}
+exports.ModRoom = ModRoom;

package/dist/module/store.d.ts

@@ -0,0 +1,14 @@
+import { FloatingLive } from "../live";
+export declare class ModStore {
+    private list;
+    protected readonly main: FloatingLive;
+    constructor(main: FloatingLive);
+    /** 注册钩子函数 */
+    register<T>(name: string, id: string, value: T): void;
+    /** 取消注册钩子函数 */
+    unregister(name: string, id: string): void;
+    /** 获取值 */
+    get(name: string): Map<string, any> | undefined;
+    /** 获取注册的所有值 */
+    getMap(): Record<string, Record<string, any>>;
+}

package/dist/module/store.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModStore = void 0;
+class ModStore {
+    constructor(main) {
+        this.list = new Map();
+        this.main = main;
+    }
+    /** 注册钩子函数 */
+    register(name, id, value) {
+        let store = this.list.get(name);
+        if (!store) {
+            store = new Map();
+            this.list.set(name, store);
+        }
+        store.set(id, value);
+    }
+    /** 取消注册钩子函数 */
+    unregister(name, id) {
+        let store = this.list.get(name);
+        if (store) {
+            store.delete(id);
+        }
+    }
+    /** 获取值 */
+    get(name) {
+        return this.list.get(name);
+    }
+    /** 获取注册的所有值 */
+    getMap() {
+        const map = {};
+        this.list.forEach((store, name) => {
+            const part = {};
+            map[name] = part;
+            store.forEach((value, id) => {
+                part[id] = value;
+            });
+        });
+        return map;
+    }
+}
+exports.ModStore = ModStore;