floating-live 0.8.7 → 0.10.0

package/src/index.d.ts

@@ -1,33 +1,59 @@
 /// <reference types="node" />
 import { EventEmitter } from "events";
-import { Registerable } from "./lib/Registerable";
-import LiveRoom from "./types/room/LiveRoom";
-import { MessageType } from "./types/message/MessageData";
-import Controller from "./controller";
-declare class FloatingLive extends EventEmitter {
-    /** 控制器 */
-    controller: Controller;
-    /** 拓展插件 */
-    plugin: Map<string, {
-        [key: string]: any;
-    }>;
+import { Reglist } from "./lib/Reglist";
+import { LiveRoom } from "./lib/LiveRoom";
+import { MessageData } from "./types/message/MessageData";
+import { PluginHandler } from "./module/Plugin";
+import { RoomController } from "./module/Room";
+export declare class FloatingLive extends EventEmitter {
+    /** 房间控制模块 */
+    room: RoomController;
+    /** 插件处理模块 */
+    plugin: PluginHandler<this>;
     helper: {
         /** 房间生成器 */
-        roomGenerator: Registerable<(id: string | number, open?: boolean) => {
-            key: string;
-            room: LiveRoom;
-        }>;
+        roomGenerator: Reglist<(id: string | number, open?: boolean) => LiveRoom>;
         /** 消息处理 */
-        messageHandler: Registerable<(msg: MessageType) => void>;
+        messageHandler: Reglist<(msg: MessageData) => void>;
+        /** 插件销毁 */
+        pluginDestory: Reglist<() => void>;
+        /** 添加插件 */
+        pluginAddHandler: Reglist<(name: string) => void>;
+        /** 移除插件 */
+        pluginRemoveHandler: Reglist<(name: string) => void>;
     };
+    /** 插件事件注册表 */
+    private pluginEventMap;
+    /** 状态 */
+    private status;
+    get started(): boolean;
+    get timestamp(): number;
     constructor();
-    /** 添加插件 */
-    registerPlugin(name: string, pluginFunc: (main: FloatingLive) => any): any;
-    /** 根据名称获取插件操作对象 */
-    getPlugin(name: string): {
-        [key: string]: any;
-    } | undefined;
-    /** 移除插件 */
-    removePlugin(name: string): void;
+    /** 初始化 */
+    private init;
+    /** 开始 */
+    start(): void;
+    /** 结束 */
+    end(): void;
+    /** 添加房间 */
+    addRoom({ platform, id }: {
+        platform: string;
+        id: string | number;
+    }, open?: boolean): 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;
 }
-export default FloatingLive;

package/src/index.js

@@ -1,54 +1,111 @@
 "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 Registerable_1 = require("./lib/Registerable");
-const controller_1 = __importDefault(require("./controller"));
+const Reglist_1 = require("./lib/Reglist");
+const Plugin_1 = require("./module/Plugin");
+const Room_1 = require("./module/Room");
 class FloatingLive extends events_1.EventEmitter {
     constructor() {
         super();
-        /** 拓展插件 */
-        this.plugin = new Map();
+        /** 插件事件注册表 */
+        this.pluginEventMap = new Map();
+        /** 状态 */
+        this.status = {
+            started: false,
+            timestamp: 0,
+        };
         this.helper = {
-            /** 房间生成器 */
-            roomGenerator: new Registerable_1.Registerable("roomGenerator"),
-            /** 消息处理 */
-            messageHandler: new Registerable_1.Registerable("messageHandler"),
+            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.controller = new controller_1.default(this);
+        this.room = new Room_1.RoomController(this);
+        this.plugin = new Plugin_1.PluginHandler(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.pluginEventMap.get(name)?.forEach(([eventName, listener]) => {
+                this.removeListener(eventName, listener);
+            });
+        });
     }
-    /** 添加插件 */
-    registerPlugin(name, pluginFunc) {
-        if (this.plugin.has(name)) {
-            this.emit("plugin_duplicate");
-            return;
+    /** 开始 */
+    start() {
+        this.status.started = true;
+        this.status.timestamp = new Date().valueOf();
+        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) {
+        let generated = this.room.generate({ platform, id }, open);
+        if (generated) {
+            this.room.add(generated);
         }
-        Registerable_1.Registerable.currentPlugin = name;
-        let pluginObject = pluginFunc(this); // 获取插件操作对象
-        this.plugin.set(name, pluginObject);
-        this.emit("plugin_add", name);
-        console.log(`已添加插件: ${name}`);
-        Registerable_1.Registerable.currentPlugin = null;
-        return pluginObject;
-    }
-    /** 根据名称获取插件操作对象 */
-    getPlugin(name) {
-        return this.plugin.get(name);
-    }
-    /** 移除插件 */
-    removePlugin(name) {
-        if (!this.plugin.has(name)) {
-            this.emit("plugin_unexist", name);
-            return;
+    }
+    /** 移除房间 */
+    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);
+        // 检测是否为插件添加事件，并添加进事件列表
+        if (this.plugin.currentPlugin) {
+            if (!this.pluginEventMap.has(this.plugin.currentPlugin)) {
+                this.pluginEventMap.set(this.plugin.currentPlugin, []);
+            }
+            this.pluginEventMap.get(this.plugin.currentPlugin)?.push([eventName, listener]);
         }
-        let pluginObject = this.plugin.get(name);
-        this.plugin.delete(name);
-        this.helper.roomGenerator.unregister(name);
-        this.helper.messageHandler.unregister(name);
-        pluginObject?.destory && pluginObject.destory();
-        this.emit("plugin_remove", name);
+        return this;
     }
 }
-exports.default = FloatingLive;
+exports.FloatingLive = FloatingLive;

package/src/lib/LiveRoom.d.ts

@@ -0,0 +1,88 @@
+/// <reference types="node" />
+import { EventEmitter } from "events";
+import { UserInfo } from "../types/message/AttributeInfo";
+import { MessageData } from "../types/message/MessageData";
+export interface RoomInfo {
+    /** 平台id */
+    platform: string;
+    /** 房间id */
+    id: number | string;
+    /** 房间key */
+    key: string;
+    /** 基本信息 */
+    base: RoomBaseInfo;
+    /** 统计信息 */
+    stats?: RoomStatsInfo;
+    /** 主播信息 */
+    anchor: UserInfo;
+    /** 时间戳 */
+    timestamp: number;
+    /** 直播状态 */
+    status: RoomStatus;
+    /** 直播间是否可用 */
+    available: boolean;
+    /** 房间监听是否打开 */
+    opening: boolean;
+    /** 是否连接到房间 */
+    connected: boolean;
+}
+/** 房间基本信息 */
+export declare type RoomBaseInfo = {
+    /** 直播标题 */
+    title?: string;
+    /** 分区 */
+    area?: string[];
+    /** 封面 */
+    cover?: string;
+};
+/** 房间统计数据信息 */
+export declare type RoomStatsInfo = {
+    /** 点赞数 */
+    like?: number;
+    /** 观看数 */
+    watch?: number;
+    /** 在线人数 */
+    online?: number;
+    /** 人气值 */
+    popularity?: number;
+};
+/** 房间状态 */
+export declare type RoomStatus = "live" | "off" | "round" | "banned";
+export declare abstract class LiveRoom extends EventEmitter implements RoomInfo {
+    constructor();
+    /** 平台 */
+    abstract readonly platform: string;
+    /** 房间id */
+    abstract readonly id: string | number;
+    /** 基本信息 */
+    abstract base: RoomBaseInfo;
+    /** 统计信息 */
+    stats?: RoomStatsInfo;
+    /** 主播信息 */
+    abstract anchor: UserInfo;
+    /** 直播状态 */
+    status: RoomStatus;
+    /** 时间戳 */
+    timestamp: number;
+    /** 房间是否打开 */
+    opening: boolean;
+    /** 房间是否可用 */
+    abstract available: boolean;
+    /** 是否连接上房间 */
+    abstract connected: boolean;
+    /** 打开连接 */
+    abstract open(): void;
+    /** 关闭连接 */
+    abstract close(): void;
+    /** 从服务器获取信息 */
+    abstract getInfo(): void;
+    /** 销毁事件 */
+    protected onDestory?(): void;
+    /** 销毁 */
+    destory(): void;
+    protected emitMsg(msg: MessageData): void;
+    protected emitOrigin(msg: any): void;
+    get info(): RoomInfo;
+    get key(): string;
+    private msgCheck;
+}

package/src/lib/LiveRoom.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveRoom = void 0;
+const events_1 = require("events");
+class LiveRoom extends events_1.EventEmitter {
+    constructor() {
+        super();
+        /** 直播状态 */
+        this.status = "off";
+        /** 时间戳 */
+        this.timestamp = 0;
+        /** 房间是否打开 */
+        this.opening = false;
+    }
+    /** 销毁 */
+    destory() {
+        this.close();
+        this.removeAllListeners();
+        this.onDestory?.();
+    }
+    // 发送消息
+    emitMsg(msg) {
+        this.msgCheck(msg);
+        this.emit("msg", msg);
+    }
+    // 发送源消息
+    emitOrigin(msg) {
+        this.emit("origin", msg);
+    }
+    get info() {
+        return {
+            platform: this.platform,
+            id: this.id,
+            base: this.base,
+            stats: this.stats,
+            anchor: this.anchor,
+            timestamp: this.timestamp,
+            status: this.status,
+            available: this.available,
+            opening: this.opening,
+            connected: this.connected,
+            key: this.key,
+        };
+    }
+    get key() {
+        return `${this.platform}:${this.id}`;
+    }
+    // 检测特定消息
+    msgCheck(msg) {
+        switch (msg.type) {
+            case "live_start":
+                this.status = "live";
+                this.timestamp = msg.info.timestamp || msg.record_time;
+                this.emit("status", "live", msg.info.timestamp);
+                break;
+            case "live_end":
+            case "live_cut":
+                this.status = msg.status || "off";
+                this.timestamp = msg.timestamp || msg.record_time;
+                this.emit("status", msg.status || "off", msg.timestamp || msg.record_time);
+                break;
+            case "live_change":
+                this.base = Object.assign(this.base, msg.info);
+                this.emit("change", msg.info);
+                break;
+            case "live_stats":
+                this.stats = Object.assign(this.stats, msg.info);
+                break;
+        }
+    }
+}
+exports.LiveRoom = LiveRoom;

package/src/lib/{Registerable.d.ts → Reglist.d.ts}

@@ -1,13 +1,13 @@
+import { FloatingLive } from "..";
 /** 插件可注册对象模块 */
-export declare class Registerable<T> {
-    /** 当前安装插件 */
-    static currentPlugin: string | null;
+export declare class Reglist<T> {
     /** 功能列表 */
     private readonly list;
     /** 插件与功能名称绑定表 */
     private readonly pluginIdMap;
     private readonly name;
-    constructor(name: string);
+    private readonly main;
+    constructor(main: FloatingLive, name: string);
     /** 注册一个对象 */
     register(id: string, item: T): void;
     /** 取消某一插件在该模块中的注册 */
@@ -20,8 +20,6 @@ export declare class Registerable<T> {
     getList(): T[];
     /** 获取注册id列表 */
     getIdList(): string[];
+    /** 获取注册id列表 */
+    getIdByPlugin(name: string): string[];
 }
-/** 设置当前安装插件名称 */
-export declare const setCurrentPluginName: (name?: string | null) => void;
-/** 获取当前安装插件名称 */
-export declare const getCurrentPluginName: () => string | null;

package/src/lib/{Registerable.js → Reglist.js}

@@ -1,10 +1,10 @@
 "use strict";
-// Plugin System modified from PicGo
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCurrentPluginName = exports.setCurrentPluginName = exports.Registerable = void 0;
+exports.Reglist = void 0;
 /** 插件可注册对象模块 */
-class Registerable {
-    constructor(name) {
+class Reglist {
+    constructor(main, name) {
+        this.main = main;
         this.name = name;
         this.list = new Map();
         this.pluginIdMap = new Map();
@@ -19,12 +19,12 @@ class Registerable {
         // 将组件添加至列表中
         this.list.set(id, item);
         // 将插件名称与注册id关联
-        if (Registerable.currentPlugin) {
-            if (this.pluginIdMap.has(Registerable.currentPlugin)) {
-                this.pluginIdMap.get(Registerable.currentPlugin)?.push(id);
+        if (this.main.plugin.currentPlugin) {
+            if (this.pluginIdMap.has(this.main.plugin.currentPlugin)) {
+                this.pluginIdMap.get(this.main.plugin.currentPlugin)?.push(id);
             }
             else {
-                this.pluginIdMap.set(Registerable.currentPlugin, [id]);
+                this.pluginIdMap.set(this.main.plugin.currentPlugin, [id]);
             }
         }
     }
@@ -53,15 +53,9 @@ class Registerable {
     getIdList() {
         return [...this.list.keys()];
     }
+    /** 获取注册id列表 */
+    getIdByPlugin(name) {
+        return [...(this.pluginIdMap.get(name) || [])];
+    }
 }
-exports.Registerable = Registerable;
-/** 设置当前安装插件名称 */
-const setCurrentPluginName = (name = null) => {
-    Registerable.currentPlugin = name;
-};
-exports.setCurrentPluginName = setCurrentPluginName;
-/** 获取当前安装插件名称 */
-const getCurrentPluginName = () => {
-    return Registerable.currentPlugin;
-};
-exports.getCurrentPluginName = getCurrentPluginName;
+exports.Reglist = Reglist;

package/src/module/Command.d.ts

@@ -0,0 +1,2 @@
+export declare class Command {
+}

package/src/{types/room/RoomInfo.js → module/Command.js}

@@ -1,2 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Command = void 0;
+class Command {
+}
+exports.Command = Command;

package/src/module/Plugin.d.ts

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

package/src/module/Plugin.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginHandler = void 0;
+class PluginHandler {
+    constructor(main) {
+        this.current = null;
+        this.list = new Map();
+        this.pluginEvent = new Map();
+        this.main = main;
+        this.helper = main.helper;
+    }
+    /** 获取当前安装插件 */
+    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]);
+        }
+    }
+    /** 获取插件操作对象 */
+    get(name) {
+        return this.list.get(name);
+    }
+    /** 注册插件 */
+    register(name, pluginFunc) {
+        if (this.list.has(name)) {
+            this.main.emit("plugin_duplicate", name);
+            return;
+        }
+        this.current = name;
+        // 执行插件函数并获取插件操作对象
+        let pluginObject = pluginFunc(this.main);
+        this.list.set(name, pluginObject || {});
+        // 执行钩子函数
+        this.helper.pluginAddHandler.getList().forEach(handler => {
+            handler(name);
+        });
+        this.main.emit("plugin_add", name);
+        this.current = null;
+        return pluginObject;
+    }
+    /** 移除插件 */
+    unregister(name) {
+        // 检测插件是否存在
+        if (!this.list.has(name)) {
+            this.main.emit("plugin_unexist", name);
+            return;
+        }
+        // 获取该插件的销毁函数
+        let destoryFunc = this.helper.pluginDestory.getIdByPlugin(name).map(id => this.helper.pluginDestory.get(id));
+        // 从列表中移除插件
+        this.list.delete(name);
+        // 移除helper注册
+        this.helper.roomGenerator.unregister(name);
+        this.helper.messageHandler.unregister(name);
+        this.helper.pluginAddHandler.unregister(name);
+        this.helper.pluginRemoveHandler.unregister(name);
+        this.helper.pluginDestory.unregister(name);
+        // 执行钩子函数
+        this.helper.pluginRemoveHandler.getList().forEach(handler => {
+            handler(name);
+        });
+        // 执行销毁函数
+        destoryFunc.forEach(handler => {
+            handler?.();
+        });
+        this.main.emit("plugin_remove", name);
+    }
+}
+exports.PluginHandler = PluginHandler;

package/src/{controller → module}/Room.d.ts

@@ -1,27 +1,22 @@
-import LiveRoom from "../types/room/LiveRoom";
-import FloatingLive from "..";
-import Controller from ".";
+import { LiveRoom } from "../lib/LiveRoom";
+import { FloatingLive } from "..";
 /** 直播间监听实例控制器 */
-declare class Room {
-    readonly controller: Controller;
+export declare class RoomController {
     readonly main: FloatingLive;
     private roomMap;
-    constructor(controller: Controller);
+    constructor(main: FloatingLive);
     generate(r: {
         platform: string;
         id: string | number;
-    }, open?: boolean): {
-        key: string;
-        room: LiveRoom;
-    } | undefined;
+    }, open?: boolean): LiveRoom | undefined;
     /** 添加房间监听对象 */
-    add(key: string, room: LiveRoom, open?: boolean): void;
+    add(room: LiveRoom, open?: boolean): void;
     /** 移除房间 */
     remove(roomKey: string): void;
     /** 获取房间 */
     get(roomKey: string): LiveRoom | undefined;
     /** 获取房间信息 */
-    info(roomKey: string): import("../types/room/RoomInfo").default | undefined;
+    info(roomKey: string): import("../lib/LiveRoom").RoomInfo | undefined;
     /** 更新房间信息 */
     update(roomKey: string): void;
     /** 获取roomKey列表 */
@@ -29,4 +24,3 @@ declare class Room {
     open(roomKey: string): void;
     close(roomKey: string): void;
 }
-export default Room;