floating-live 0.15.0-beta.1 → 0.15.0-beta.11

package/dist/core/LiveRoom.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { EventEmitter } from "events";
-import { RoomStatus } from "../enums";
+import { ConnectStatus, RoomStatus } from "../enums";
 import { RoomDetail, RoomInfo, RoomStatsInfo } from "../types";
 import { Message, UserInfo } from "../types/message";
 export declare abstract class LiveRoom extends EventEmitter implements RoomInfo {
@@ -23,10 +23,10 @@ export declare abstract class LiveRoom extends EventEmitter implements RoomInfo
     liveId?: string;
     /** 房间是否打开 */
     opened: boolean;
+    /** 是否连接上房间 */
+    connection: ConnectStatus;
     /** 房间是否可用 */
     abstract available: boolean;
-    /** 是否连接上房间 */
-    abstract connected: boolean;
     /** 打开连接 */
     abstract open(): void;
     /** 关闭连接 */
@@ -34,10 +34,10 @@ export declare abstract class LiveRoom extends EventEmitter implements RoomInfo
     /** 从服务器获取信息 */
     abstract getInfo(): Promise<void>;
     /** 销毁事件 */
-    protected onDestory?(): void;
+    protected onDestroy?(): void;
     /** 销毁 */
     destroy(): void;
-    protected emitMsg(msg: Message.All): void;
+    protected emitMessage(msg: Message.All): void;
     protected emitRaw(msg: any): void;
     get info(): RoomInfo;
     get key(): string;

package/dist/core/LiveRoom.js

@@ -12,15 +12,17 @@ class LiveRoom extends events_1.EventEmitter {
         this.timestamp = 0;
         /** 房间是否打开 */
         this.opened = false;
+        /** 是否连接上房间 */
+        this.connection = enums_1.ConnectStatus.off;
     }
     /** 销毁 */
     destroy() {
         this.close();
         this.removeAllListeners();
-        this.onDestory?.();
+        this.onDestroy?.();
     }
     // 发送消息
-    emitMsg(msg) {
+    emitMessage(msg) {
         // 其他消息 => 先更改状态再发送消息
         // 直播结束消息 => 先发送消息再更改状态
         switch (msg.type) {
@@ -42,15 +44,15 @@ class LiveRoom extends events_1.EventEmitter {
                 break;
             case "live_end":
             case "live_cut":
-                this.emit("msg", msg);
                 this.status = msg.status || enums_1.RoomStatus.off;
                 this.timestamp = msg.timestamp;
+                this.emit("message", msg);
                 this.emit("status", msg.status || enums_1.RoomStatus.off, {
                     timestamp: msg.timestamp,
                 });
                 return;
         }
-        this.emit("msg", msg);
+        this.emit("message", msg);
     }
     // 发送源消息
     emitRaw(msg) {
@@ -68,7 +70,7 @@ class LiveRoom extends events_1.EventEmitter {
             liveId: this.liveId,
             available: this.available,
             opened: this.opened,
-            connected: this.connected,
+            connection: this.connection,
             key: this.key,
         };
     }

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/enums.d.ts

@@ -7,7 +7,22 @@ export declare enum RoomStatus {
     /** 正在轮播 */
     round = 2,
     /** 被封禁 */
-    banned = -1
+    banned = -1,
+    /** 已上锁 */
+    locked = -2
+}
+/** 直播间状态 */
+export declare enum ConnectStatus {
+    /** 未连接 */
+    off = 0,
+    /** 连接中 */
+    connecting = 1,
+    /** 连接到服务器 */
+    connected = 2,
+    /** 连接到房间 */
+    entered = 3,
+    /** 连接失败或断开 */
+    disconnected = -1
 }
 /** 图片大小 */
 export declare enum ImageSize {

package/dist/enums.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UserType = exports.DanmakuMode = exports.ImageSize = exports.RoomStatus = void 0;
+exports.UserType = exports.DanmakuMode = exports.ImageSize = exports.ConnectStatus = exports.RoomStatus = void 0;
 /** 直播间状态 */
 var RoomStatus;
 (function (RoomStatus) {
@@ -12,7 +12,23 @@ var RoomStatus;
     RoomStatus[RoomStatus["round"] = 2] = "round";
     /** 被封禁 */
     RoomStatus[RoomStatus["banned"] = -1] = "banned";
+    /** 已上锁 */
+    RoomStatus[RoomStatus["locked"] = -2] = "locked";
 })(RoomStatus = exports.RoomStatus || (exports.RoomStatus = {}));
+/** 直播间状态 */
+var ConnectStatus;
+(function (ConnectStatus) {
+    /** 未连接 */
+    ConnectStatus[ConnectStatus["off"] = 0] = "off";
+    /** 连接中 */
+    ConnectStatus[ConnectStatus["connecting"] = 1] = "connecting";
+    /** 连接到服务器 */
+    ConnectStatus[ConnectStatus["connected"] = 2] = "connected";
+    /** 连接到房间 */
+    ConnectStatus[ConnectStatus["entered"] = 3] = "entered";
+    /** 连接失败或断开 */
+    ConnectStatus[ConnectStatus["disconnected"] = -1] = "disconnected";
+})(ConnectStatus = exports.ConnectStatus || (exports.ConnectStatus = {}));
 /** 图片大小 */
 var ImageSize;
 (function (ImageSize) {

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,27 +1,35 @@
 /// <reference types="node" />
 import { EventEmitter } from "events";
-import { ModPlugin } from "./module/ModPlugin";
-import { ModRoom } from "./module/ModRoom";
-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 { ModManifest } from "./module/manifest";
+import { ModCommand } from "./module/command";
+import { ModValue } from "./module/value";
+import { ModHook } from "./module/hook";
+import { FloatingEventMap } from "./types/events";
+import { FloatingCommandMap } from "./types";
 export declare class FloatingLive extends EventEmitter {
     /** 房间控制模块 */
     room: ModRoom;
-    /** 消息处理模块 */
-    message: ModMessage;
     /** 插件处理模块 */
-    plugin: ModPlugin<this>;
+    plugin: ModPlugin;
     /** 命令模块 */
     command: ModCommand;
-    /** 状态模块 */
-    state: ModState;
-    /** 插件事件注册表 */
-    private regEventMap;
+    /** Manifest模块 */
+    manifest: ModManifest;
+    /** 数值模块 */
+    value: ModValue;
+    /** 钩子模块 */
+    hook: ModHook;
     constructor();
-    /** 初始化 */
-    private init;
-    /** 重写事件监听 */
-    on(eventName: string, listener: (...args: any[]) => void): this;
-    emit(eventName: string | symbol, ...args: any[]): boolean;
+    call<T extends keyof FloatingCommandMap>(name: T, ...args: Parameters<FloatingCommandMap[T]>): ReturnType<FloatingCommandMap[T]>;
+    on<T extends keyof FloatingEventMap>(eventName: T, listener: FloatingEventMap[T]): this;
+    emit<T extends keyof FloatingEventMap>(eventName: T, ...args: Parameters<FloatingEventMap[T]>): boolean;
+    throw(err: Error): void;
+    getSnapshot(): {
+        room: import("./types").RoomInfo[];
+        value: Record<string, any>;
+        manifest: Record<string, Record<string, any>>;
+        command: string[];
+    };
 }

package/dist/live.js

@@ -1,54 +1,42 @@
 "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 ModPlugin_1 = require("./module/ModPlugin");
-const ModRoom_1 = require("./module/ModRoom");
-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 manifest_1 = require("./module/manifest");
+const command_1 = require("./module/command");
+const value_1 = require("./module/value");
+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.init();
+        this.command = new command_1.ModCommand(this);
+        this.manifest = new manifest_1.ModManifest(this);
+        this.plugin = new plugin_1.ModPlugin(this);
+        this.room = new room_1.ModRoom(this);
+        this.value = new value_1.ModValue(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);
+    }
+    getSnapshot() {
+        return {
+            room: this.room.getSnapshot(),
+            value: this.value.getSnapshot(),
+            manifest: this.manifest.getSnapshot(),
+            command: this.command.getSnapshot(),
+        };
     }
 }
 exports.FloatingLive = FloatingLive;

package/dist/module/command.d.ts

@@ -0,0 +1,18 @@
+import { FloatingLive } from "../live";
+import { FloatingCommandMap } from "../types";
+export declare class ModCommand {
+    /** 功能列表 */
+    private readonly list;
+    protected readonly main: FloatingLive;
+    constructor(main: FloatingLive);
+    /** 注册命令 */
+    register<T extends keyof FloatingCommandMap>(name: T, func: FloatingCommandMap[T]): void;
+    /** 取消注册命令 */
+    unregister(name: string): void;
+    /** 调用命令 */
+    call<T extends keyof FloatingCommandMap>(name: T, ...args: Parameters<FloatingCommandMap[T]>): any;
+    /** 检测命令是否存在 */
+    has<T extends keyof FloatingCommandMap>(name: T): boolean;
+    /** 获取快照 */
+    getSnapshot(): string[];
+}

package/dist/module/command.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModCommand = void 0;
+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);
+    }
+    /** 检测命令是否存在 */
+    has(name) {
+        return this.list.has(name);
+    }
+    /** 获取快照 */
+    getSnapshot() {
+        return [...this.list].map(([key]) => key);
+    }
+}
+exports.ModCommand = ModCommand;

package/dist/module/hook.d.ts

@@ -0,0 +1,14 @@
+import { FloatingLive } from "../live";
+import { FloatingHookMap } from "../types/hook";
+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 extends keyof FloatingHookMap>(name: T, func: HookFunction<FloatingHookMap[T]>): void;
+    /** 取消注册钩子函数 */
+    unregister<T extends keyof FloatingHookMap>(name: T, func: HookFunction<FloatingHookMap[T]>): void;
+    /** 调用钩子函数 */
+    call<T extends keyof FloatingHookMap>(name: T, ctx: FloatingHookMap[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 true;
+    }
+}
+exports.ModHook = ModHook;

package/dist/module/manifest.d.ts

@@ -0,0 +1,15 @@
+import { FloatingLive } from "../live";
+import { FloatingManifestMap } from "../types/manifest";
+export declare class ModManifest {
+    private list;
+    protected readonly main: FloatingLive;
+    constructor(main: FloatingLive);
+    /** 注册manifest */
+    register<T extends keyof FloatingManifestMap>(name: T, id: string, value: FloatingManifestMap[T]): void;
+    /** 取消注册manifest */
+    unregister<T extends keyof FloatingManifestMap>(name: T, id: string): void;
+    /** 获取值 */
+    get(name: string): Map<string, any> | undefined;
+    /** 获取快照 */
+    getSnapshot(): Record<string, Record<string, any>>;
+}

package/dist/module/manifest.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModManifest = void 0;
+class ModManifest {
+    constructor(main) {
+        this.list = new Map();
+        this.main = main;
+    }
+    /** 注册manifest */
+    register(name, id, value) {
+        let store = this.list.get(name);
+        if (!store) {
+            store = new Map();
+            this.list.set(name, store);
+        }
+        store.set(id, value);
+        this.main.emit("manifest:add", name, id, value);
+    }
+    /** 取消注册manifest */
+    unregister(name, id) {
+        let store = this.list.get(name);
+        if (store) {
+            store.delete(id);
+            this.main.emit("manifest:remove", name, id);
+        }
+    }
+    /** 获取值 */
+    get(name) {
+        return this.list.get(name);
+    }
+    /** 获取快照 */
+    getSnapshot() {
+        const map = {};
+        this.list.forEach((store, name) => {
+            const part = {};
+            map[name] = part;
+            store.forEach((value, id) => {
+                part[id] = value;
+            });
+        });
+        return map;
+    }
+}
+exports.ModManifest = ModManifest;

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, options?: 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, options) {
+        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, options);
         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,23 +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);
-    /** 设置房间配置 */
-    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, options?: boolean | Record<string, any>): void;
     /** 移除房间 */
     remove(roomKey: string): void;
     /** 获取房间 */
@@ -32,4 +24,8 @@ export declare class ModRoom {
     open(roomKey: string): void;
     /** 关闭房间连接 */
     close(roomKey: string): void;
+    /** 更改某个房间的顺序 */
+    move(roomKey: string, position: number): void;
+    /** 获取快照 */
+    getSnapshot(): RoomInfo[];
 }