floating-live 0.12.1 → 0.14.0

package/src/index.d.ts

@@ -1,59 +1,30 @@
 /// <reference types="node" />
 import { EventEmitter } from "events";
-import { Reglist } from "./lib/Reglist";
-import { LiveRoom } from "./lib/LiveRoom";
-import { MessageData } from "./types";
-import { PluginHandler } from "./module/Plugin";
-import { RoomController } from "./module/Room";
+import { ModPlugin } from "./module/ModPlugin";
+import { ModRooms } from "./module/ModRooms";
+import { ModAuth } from "./module/ModAuth";
+import { ModMessage } from "./module/ModMessage";
+import { ModState } from "./module/ModState";
+import ModCommand from "./module/ModCommand";
 export declare class FloatingLive extends EventEmitter {
     /** 房间控制模块 */
-    room: RoomController;
+    rooms: ModRooms;
+    /** 消息处理模块 */
+    message: ModMessage;
+    /** 用户登录凭据模块 */
+    auth: ModAuth;
     /** 插件处理模块 */
-    plugin: PluginHandler<this>;
-    helper: {
-        /** 房间生成器 */
-        roomGenerator: Reglist<(id: string | number, open?: boolean) => LiveRoom>;
-        /** 消息处理 */
-        messageHandler: Reglist<(msg: MessageData) => void>;
-        /** 插件销毁 */
-        pluginDestory: Reglist<() => void>;
-        /** 添加插件 */
-        pluginAddHandler: Reglist<(name: string) => void>;
-        /** 移除插件 */
-        pluginRemoveHandler: Reglist<(name: string) => void>;
-    };
+    plugin: ModPlugin<this>;
+    /** 命令模块 */
+    command: ModCommand;
+    /** 状态模块 */
+    state: ModState;
     /** 插件事件注册表 */
     private regEventMap;
-    /** 状态 */
-    private status;
-    get started(): boolean;
-    get timestamp(): number;
     constructor();
     /** 初始化 */
     private init;
-    /** 开始 */
-    start(): void;
-    /** 结束 */
-    end(): void;
-    /** 添加房间 */
-    addRoom({ platform, id }: {
-        platform: string;
-        id: string | number;
-    }, open?: boolean, config?: {}): void;
-    /** 移除房间 */
-    removeRoom(roomKey: string): void;
-    /** 添加房间实例 */
-    addLiveRoom(room: LiveRoom): void;
-    /** 打开房间 */
-    openRoom(roomKey: string): void;
-    /** 关闭房间 */
-    closeRoom(roomKey: string): void;
-    /** 打开所有房间 */
-    openAllRooms(): void;
-    /** 关闭所有房间 */
-    closeAllRooms(): void;
-    /** 更新房间信息 */
-    updateRoomInfo(roomKey: string): void;
     /** 重写事件监听 */
     on(eventName: string, listener: (...args: any[]) => void): this;
+    emit(eventName: string | symbol, ...args: any[]): boolean;
 }

package/src/index.js

@@ -1,102 +1,38 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FloatingLive = void 0;
 const events_1 = require("events");
-const Reglist_1 = require("./lib/Reglist");
-const Plugin_1 = require("./module/Plugin");
-const Room_1 = require("./module/Room");
+const ModPlugin_1 = require("./module/ModPlugin");
+const ModRooms_1 = require("./module/ModRooms");
+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"));
 class FloatingLive extends events_1.EventEmitter {
     constructor() {
         super();
         /** 插件事件注册表 */
         this.regEventMap = new Map();
-        /** 状态 */
-        this.status = {
-            started: false,
-            timestamp: 0,
-        };
-        this.helper = {
-            roomGenerator: new Reglist_1.Reglist(this, "roomGenerator"),
-            messageHandler: new Reglist_1.Reglist(this, "messageHandler"),
-            pluginDestory: new Reglist_1.Reglist(this, "pluginDestory"),
-            pluginAddHandler: new Reglist_1.Reglist(this, "pluginAddHandler"),
-            pluginRemoveHandler: new Reglist_1.Reglist(this, "pluginRemoveHandler"),
-        };
-        this.room = new Room_1.RoomController(this);
-        this.plugin = new Plugin_1.PluginHandler(this);
+        this.command = new ModCommand_1.default(this);
+        this.state = new ModState_1.ModState(this);
+        this.plugin = new ModPlugin_1.ModPlugin(this);
+        this.rooms = new ModRooms_1.ModRooms(this);
+        this.message = new ModMessage_1.ModMessage(this);
+        this.auth = new ModAuth_1.ModAuth(this);
         this.init();
     }
-    get started() {
-        return this.status.started;
-    }
-    get timestamp() {
-        return this.status.timestamp;
-    }
     /** 初始化 */
     init() {
-        // 监听到有房间打开，则开始记录
-        this.on("room_open", () => {
-            this.started || this.start();
-        });
         // 设置在插件卸载时移除由插件注册的事件
-        this.helper.pluginRemoveHandler.register("removePluginEvent", (name) => {
+        this.on("plugin:remove", (name) => {
             this.regEventMap.get(name)?.forEach(([eventName, listener]) => {
                 this.removeListener(eventName, listener);
             });
         });
     }
-    /** 开始 */
-    start() {
-        this.status.started = true;
-        this.status.timestamp = Date.now();
-        this.emit("start", this.timestamp);
-    }
-    /** 结束 */
-    end() {
-        this.closeAllRooms();
-        this.status.started = false;
-        this.emit("end", this.timestamp);
-        this.status.timestamp = 0;
-    }
-    /** 添加房间 */
-    addRoom({ platform, id }, open, config) {
-        let generated = this.room.generate({ platform, id }, open);
-        if (generated) {
-            this.room.add(generated);
-        }
-    }
-    /** 移除房间 */
-    removeRoom(roomKey) {
-        this.room.remove(roomKey);
-    }
-    /** 添加房间实例 */
-    addLiveRoom(room) {
-        this.room.add(room);
-    }
-    /** 打开房间 */
-    openRoom(roomKey) {
-        this.room.open(roomKey);
-    }
-    /** 关闭房间 */
-    closeRoom(roomKey) {
-        this.room.close(roomKey);
-    }
-    /** 打开所有房间 */
-    openAllRooms() {
-        this.room.keyList.forEach((key) => {
-            this.room.open(key);
-        });
-    }
-    /** 关闭所有房间 */
-    closeAllRooms() {
-        this.room.keyList.forEach((key) => {
-            this.room.close(key);
-        });
-    }
-    /** 更新房间信息 */
-    updateRoomInfo(roomKey) {
-        this.room.update(roomKey);
-    }
     /** 重写事件监听 */
     on(eventName, listener) {
         super.on(eventName, listener);
@@ -105,9 +41,16 @@ class FloatingLive extends events_1.EventEmitter {
             if (!this.regEventMap.has(this.plugin.currentPlugin)) {
                 this.regEventMap.set(this.plugin.currentPlugin, []);
             }
-            this.regEventMap.get(this.plugin.currentPlugin)?.push([eventName, listener]);
+            this.regEventMap
+                .get(this.plugin.currentPlugin)
+                ?.push([eventName, listener]);
         }
         return this;
     }
+    emit(eventName, ...args) {
+        const result = super.emit(eventName, ...args);
+        super.emit("event", eventName, ...args);
+        return result;
+    }
 }
 exports.FloatingLive = FloatingLive;

package/src/module/ModAuth.d.ts

@@ -0,0 +1,8 @@
+import { Reglist } from "../abstract/Reglist";
+import { FloatingLive } from "..";
+export declare class ModAuth {
+    options: Reglist<object>;
+    main: FloatingLive;
+    constructor(main: FloatingLive);
+    set(name: string, auth: string): void;
+}

package/src/module/ModAuth.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModAuth = void 0;
+const Reglist_1 = require("../abstract/Reglist");
+class ModAuth {
+    constructor(main) {
+        this.options = new Reglist_1.Reglist(main, "auth.options");
+        this.main = main;
+        this.main.state.register("auth", () => {
+            const options = {};
+            this.options.forEach((val, key) => {
+                options[key] = val;
+            });
+            return {
+                options: options,
+            };
+        });
+        this.main.command.batchRegister({
+            auth: (platform, auth) => {
+                this.set(platform, auth);
+            },
+        });
+    }
+    set(name, auth) {
+        this.main.rooms.setAuth(name, auth);
+    }
+}
+exports.ModAuth = ModAuth;

package/src/module/ModCommand.d.ts

@@ -0,0 +1,9 @@
+import { FloatingLive } from "..";
+import { Reglist } from "../abstract/Reglist";
+export default class ModCommand extends Reglist<(e: any, ...args: any[]) => any> {
+    constructor(main: FloatingLive);
+    /** 批量注册命令 */
+    batchRegister(list: Record<string, (...args: any) => any>): void;
+    /** 执行命令 */
+    execute(name: string, ...args: any[]): any;
+}

package/src/module/ModCommand.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Reglist_1 = require("../abstract/Reglist");
+class ModCommand extends Reglist_1.Reglist {
+    constructor(main) {
+        super(main, "command");
+    }
+    /** 批量注册命令 */
+    batchRegister(list) {
+        for (const key in list) {
+            this.register(key, list[key]);
+        }
+    }
+    /** 执行命令 */
+    execute(name, ...args) {
+        return this.get(name)?.(null, ...args);
+    }
+}
+exports.default = ModCommand;

package/src/module/ModMessage.d.ts

@@ -0,0 +1,9 @@
+import { Message } from "../types/message";
+import { FloatingLive } from "..";
+import { Reglist } from "../abstract/Reglist";
+export declare class ModMessage {
+    main: FloatingLive;
+    handler: Reglist<(msg: Message.All) => void>;
+    constructor(main: FloatingLive);
+    handle(msg: Message.All): void;
+}

package/src/module/ModMessage.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModMessage = void 0;
+const Reglist_1 = require("../abstract/Reglist");
+class ModMessage {
+    constructor(main) {
+        this.main = main;
+        this.handler = new Reglist_1.Reglist(main, "message.handler");
+    }
+    handle(msg) {
+        this.handler.getList().forEach((handler) => {
+            handler(msg);
+        });
+    }
+}
+exports.ModMessage = ModMessage;

package/src/module/{Plugin.d.ts → ModPlugin.d.ts}

@@ -1,26 +1,20 @@
 import { FloatingLive } from "..";
 import { FloatingLivePlugin } from "../types/plugin";
-export declare class PluginHandler<T extends FloatingLive> {
+export declare class ModPlugin<T extends FloatingLive> {
     private current;
     /** 插件列表 */
     private list;
     private pluginEvent;
     private main;
-    private helper;
+    private exports;
     constructor(main: T);
     /** 获取当前安装插件 */
     get currentPlugin(): string | null;
     addPluginEvent(eventName: string, listener: (...args: any[]) => void): void;
-    /** 获取插件操作对象 */
-    get(name: string): {
-        [key: string]: any;
-    } | undefined;
+    /** 访问插件操作对象 */
+    access(name: string): object | undefined;
     /** 注册插件 */
-    register(name: string, plugin: FloatingLivePlugin<T>, config?: {
-        [key: string]: any;
-    }): void | {
-        [key: string]: any;
-    };
+    register(pluginFunc: FloatingLivePlugin<T>): object | undefined;
     /** 移除插件 */
     unregister(name: string): void;
 }

package/src/module/ModPlugin.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModPlugin = void 0;
+class ModPlugin {
+    constructor(main) {
+        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) {
+        // 执行插件函数
+        const plugin = pluginFunc();
+        const name = plugin.name;
+        if (this.list.has(name)) {
+            this.main.emit("plugin:duplicate", name);
+            return;
+        }
+        this.list.set(name, plugin);
+        this.current = name;
+        // 调用register函数，并保存获取值
+        let pluginExpose = plugin.register?.(this.main) || {};
+        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);
+            return;
+        }
+        // 获取该插件的销毁函数
+        plugin.destroy?.();
+        // 从列表中移除插件
+        this.list.delete(name);
+        // 移除插件注册
+        this.main.emit("plugin:remove", name);
+    }
+}
+exports.ModPlugin = ModPlugin;

package/src/module/ModRooms.d.ts

@@ -0,0 +1,37 @@
+import { Reglist } from "../abstract/Reglist";
+import { LiveRoom } from "../abstract/LiveRoom";
+import { FloatingLive } from "..";
+import { RoomInfo } from "../types";
+/** 直播间监听实例控制器 */
+export declare class ModRooms {
+    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;
+    /** 移除房间 */
+    remove(roomKey: string): void;
+    /** 获取房间 */
+    get(roomKey: string): LiveRoom | undefined;
+    /** 获取房间信息 */
+    info(roomKey: string): RoomInfo | undefined;
+    /** 更新房间信息 */
+    update(roomKey: string): void;
+    /** 获取roomKey列表 */
+    get keys(): Array<string>;
+    /** 打开房间连接 */
+    open(roomKey: string): void;
+    /** 关闭房间连接 */
+    close(roomKey: string): void;
+}

package/src/module/ModRooms.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModRooms = void 0;
+const Reglist_1 = require("../abstract/Reglist");
+/** 直播间监听实例控制器 */
+class ModRooms {
+    constructor(main) {
+        this.roomMap = new Map();
+        this.auths = new Map();
+        this.configs = new Map();
+        this.main = main;
+        this.generator = new Reglist_1.Reglist(this.main, "rooms.generator");
+        this.main.state.register("rooms", () => {
+            const list = [];
+            this.roomMap.forEach((room) => {
+                list.push(room.info);
+            });
+            return list;
+        });
+        this.main.command.batchRegister({
+            add: (platform, id, open) => {
+                this.add(platform, id, open);
+            },
+            remove: (key) => {
+                this.remove(key);
+            },
+            open: (key) => {
+                this.open(key);
+            },
+            close: (key) => {
+                this.close(key);
+            },
+            update: (key) => {
+                this.update(key);
+            },
+        });
+    }
+    /** 设置登录凭据 */
+    setAuth(platform, auth) {
+        this.auths.set(platform, auth);
+    }
+    /** 设置房间配置 */
+    setConfig(platform, config) {
+        this.configs.set(platform, config);
+    }
+    /** 生成房间 */
+    generate(platform, id, open) {
+        platform = platform.toLowerCase();
+        const config = this.configs.get(platform) || {};
+        const auth = this.auths.get(platform);
+        let platformGenerator = this.generator.get(platform);
+        if (platformGenerator) {
+            return platformGenerator(id, open, { auth, ...config });
+        }
+        else {
+            this.main.emit("room:unknown_platform", platform);
+        }
+    }
+    /** 添加房间监听实例 */
+    addRoom(room, open) {
+        let key = room.key;
+        if (this.roomMap.has(key)) {
+            this.main.emit("room:exist", key);
+            return;
+        }
+        this.roomMap.set(key, room);
+        // 添加监听事件
+        // 直播消息
+        room.on("msg", (data) => {
+            this.main.message.handle(data);
+            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, open) {
+        const room = this.generate(platform, id, open);
+        room && this.addRoom(room);
+    }
+    /** 移除房间 */
+    remove(roomKey) {
+        if (!this.roomMap.has(roomKey)) {
+            this.main.emit("room:unexist", roomKey);
+            return;
+        }
+        let room = this.roomMap.get(roomKey);
+        this.roomMap.delete(roomKey); // 从表中删除房间
+        room?.removeAllListeners(); // 移除房间监听实例
+        this.main.emit("room:remove", roomKey);
+    }
+    /** 获取房间 */
+    get(roomKey) {
+        return this.roomMap.get(roomKey);
+    }
+    /** 获取房间信息 */
+    info(roomKey) {
+        let room = this.roomMap.get(roomKey);
+        return room ? room.info : undefined;
+    }
+    /** 更新房间信息 */
+    update(roomKey) {
+        let room = this.roomMap.get(roomKey);
+        room && room.getInfo();
+    }
+    /** 获取roomKey列表 */
+    get keys() {
+        return [...this.roomMap.keys()];
+    }
+    /** 打开房间连接 */
+    open(roomKey) {
+        let room = this.roomMap.get(roomKey);
+        room?.available && !room.opened && room.open();
+    }
+    /** 关闭房间连接 */
+    close(roomKey) {
+        let room = this.roomMap.get(roomKey);
+        room?.opened && room.close();
+    }
+}
+exports.ModRooms = ModRooms;

package/src/module/ModState.d.ts

@@ -0,0 +1,6 @@
+import { FloatingLive } from "..";
+import { Reglist } from "../abstract/Reglist";
+export declare class ModState extends Reglist<() => object> {
+    constructor(main: FloatingLive);
+    generate(): Record<string, any>;
+}

package/src/module/ModState.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModState = void 0;
+const Reglist_1 = require("../abstract/Reglist");
+class ModState extends Reglist_1.Reglist {
+    constructor(main) {
+        super(main, "state");
+    }
+    generate() {
+        const state = {};
+        this.forEach((gen, key) => {
+            state[key] = gen();
+        });
+        return state;
+    }
+}
+exports.ModState = ModState;

package/src/types/index.d.ts

@@ -1,4 +1,3 @@
-export * from "./message/AttributeInfo";
-export * from "./message/MessageData";
+export * from "./message";
 export * from "./plugin";
 export * from "./room";

package/src/types/index.js

@@ -14,7 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./message/AttributeInfo"), exports);
-__exportStar(require("./message/MessageData"), exports);
+__exportStar(require("./message"), exports);
 __exportStar(require("./plugin"), exports);
 __exportStar(require("./room"), exports);