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

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,27 +1,28 @@
 /// <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 { 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;
     /** 插件处理模块 */
-    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,50 +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 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.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,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, config?: boolean | Record<string, any>): void;
     /** 移除房间 */
     remove(roomKey: string): void;
     /** 获取房间 */

package/dist/module/{ModRoom.js → room.js}

@@ -1,70 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModRoom = void 0;
-const Reglist_1 = require("../core/Reglist");
 /** 直播间监听实例控制器 */
 class ModRoom {
     constructor(main) {
-        this.roomMap = new Map();
-        this.auths = new Map();
-        this.configs = new Map();
+        this.list = new Map();
         this.main = main;
-        this.generator = new Reglist_1.Reglist(this.main, "room.generator");
-        this.main.state.register("room", () => {
-            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);
-            },
-        });
-    }
-    /** 设置房间配置 */
-    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);
-        }
+        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.roomMap.has(key)) {
-            this.main.emit("room:exist", key);
+        if (this.list.has(key)) {
+            this.main.throw(Object.assign(new Error("房间已存在"), {
+                from: "room",
+                signal: "room_exist",
+            }));
             return;
         }
-        this.roomMap.set(key, room);
+        this.list.set(key, room);
         // 添加监听事件
         // 直播消息
         room.on("msg", (data) => {
-            this.main.message.handle(data);
-            this.main.emit("live:message", data);
+            this.main.hook.call("message", data).then((res) => {
+                res && this.main.emit("live:message", data);
+            });
         });
         // 直播消息源数据
         room.on("raw", (data, { platform, room }) => {
@@ -88,7 +53,7 @@ class ModRoom {
         });
         // 直播状态更改
         room.on("status", (status, { id, timestamp }) => {
-            this.main.emit("room:status", key, status, { id, timestamp });
+            this.main.emit("room:status", key, { status, id, timestamp });
         });
         // 统计数据更新
         room.on("stats", (data) => {
@@ -108,47 +73,52 @@ class ModRoom {
         this.main.emit("room:add", key, room.info);
     }
     /** 添加房间 */
-    add(platform, id, open) {
-        const room = this.generate(platform, id, open);
+    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) {
-        if (!this.roomMap.has(roomKey)) {
-            this.main.emit("room:unexist", roomKey);
-            return;
+        let room = this.list.get(roomKey);
+        if (!room) {
+            this.main.throw(Object.assign(new Error("房间不存在"), {
+                from: "room",
+                signal: "room_unexist",
+            }));
         }
-        let room = this.roomMap.get(roomKey);
-        this.roomMap.delete(roomKey); // 从表中删除房间
+        this.list.delete(roomKey); // 从表中删除房间
         room?.removeAllListeners(); // 移除房间监听实例
         this.main.emit("room:remove", roomKey);
     }
     /** 获取房间 */
     get(roomKey) {
-        return this.roomMap.get(roomKey);
+        return this.list.get(roomKey);
     }
     /** 获取房间信息 */
     info(roomKey) {
-        let room = this.roomMap.get(roomKey);
+        let room = this.list.get(roomKey);
         return room ? room.info : undefined;
     }
     /** 更新房间信息 */
     update(roomKey) {
-        let room = this.roomMap.get(roomKey);
+        let room = this.list.get(roomKey);
         room && room.getInfo();
     }
     /** 获取roomKey列表 */
     get keys() {
-        return [...this.roomMap.keys()];
+        return [...this.list.keys()];
     }
     /** 打开房间连接 */
     open(roomKey) {
-        let room = this.roomMap.get(roomKey);
+        let room = this.list.get(roomKey);
         room?.available && !room.opened && room.open();
     }
     /** 关闭房间连接 */
     close(roomKey) {
-        let room = this.roomMap.get(roomKey);
+        let room = this.list.get(roomKey);
         room?.opened && room.close();
     }
 }

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;

package/dist/module/values.d.ts

@@ -0,0 +1,21 @@
+import { FloatingLive } from "../live";
+interface ValueConfig<T> {
+    get: () => T;
+    set?: (value: T) => void;
+}
+export declare class ModValues {
+    private list;
+    protected readonly main: FloatingLive;
+    constructor(main: FloatingLive);
+    /** 注册值 */
+    register<T>(name: string, config: ValueConfig<T>): void;
+    /** 取消注册 */
+    unregister(name: string): void;
+    /** 获取值 */
+    get(name: string): any;
+    /** 设置值 */
+    set(name: string, value: any): boolean;
+    /** 获取注册的所有值 */
+    getMap(): Record<string, any>;
+}
+export {};

package/dist/module/values.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModValues = void 0;
+class ModValues {
+    constructor(main) {
+        this.list = new Map();
+        this.main = main;
+    }
+    /** 注册值 */
+    register(name, config) {
+        this.list.set(name, config);
+    }
+    /** 取消注册 */
+    unregister(name) {
+        this.list.delete(name);
+    }
+    /** 获取值 */
+    get(name) {
+        return this.list.get(name)?.get();
+    }
+    /** 设置值 */
+    set(name, value) {
+        const valueConfig = this.list.get(name);
+        if (valueConfig?.set) {
+            valueConfig?.set(value);
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    /** 获取注册的所有值 */
+    getMap() {
+        const map = {};
+        this.list.forEach((config, name) => {
+            map[name] = config.get();
+        });
+        return map;
+    }
+}
+exports.ModValues = ModValues;

package/dist/types/events.d.ts

@@ -0,0 +1,26 @@
+import { RoomStatus } from "../enums";
+import { Message } from "./message";
+import { RoomDetail, RoomInfo, RoomStatsInfo } from "./room";
+export interface FloatingEventMap {
+    "live:message": (msg: Message.All) => void;
+    "live:raw": (data: any) => void;
+    "room:connect": (key: string) => void;
+    "room:disconnect": (key: string) => void;
+    "room:info": (key: string, info: RoomInfo) => void;
+    "room:detail": (key: string, info: RoomDetail) => void;
+    "room:status": (key: string, info: {
+        status: RoomStatus;
+        id?: string;
+        timestamp?: number;
+    }) => void;
+    "room:stats": (key: string, info: RoomStatsInfo) => void;
+    "room:open": (key: string, info: RoomInfo) => void;
+    "room:close": (key: string, info: RoomInfo) => void;
+    "room:add": (key: string, info: RoomInfo) => void;
+    "room:remove": (key: string, info: RoomInfo) => void;
+    "plugin:add": (name: string) => void;
+    "plugin:remove": (name: string) => void;
+    "command:add": (name: string) => void;
+    "command:remove": (name: string) => void;
+    error: (err: Error) => void;
+}

package/dist/types/events.js

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

package/dist/types/plugin.d.ts

@@ -1,8 +1,15 @@
 import { FloatingLive } from "../live";
 /** 插件模块, 加载时调用 */
-export declare type FloatingLivePlugin<C extends object = object, E extends object | void = object | void> = () => {
+export declare type FloatingLivePlugin<C extends object = object> = () => {
     /** 插件名称 */
     name: string;
-    register: (ctx: FloatingLive, config?: C) => E;
+    register: (ctx: FloatingLive, config?: C) => void;
     destroy?: (ctx: FloatingLive) => void;
 };
+export interface IPlugin {
+    destroy: () => void;
+}
+export interface PluginConstructor {
+    pluginName: string;
+    new (ctx: FloatingLive, config: any): IPlugin;
+}

package/dist/types/room.d.ts

@@ -1,5 +1,15 @@
 import { RoomStatus } from "../enums";
 import { UserInfo } from "./message";
+/** 房间配置 */
+export interface RoomConfig {
+    /** 添加后是否打开房间 */
+    open?: boolean;
+    /** 口令 */
+    tokens?: Record<string, number>;
+    /** 凭据 */
+    credentials?: string;
+}
+/** 房间信息 */
 export interface RoomInfo {
     /** 平台id */
     platform: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "floating-live",
-  "version": "0.15.0-beta.1",
+  "version": "0.15.0-beta.2",
   "type": "commonjs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/core/Reglist.d.ts

@@ -1,29 +0,0 @@
-import { FloatingLive } from "../live";
-/** 插件可注册对象模块 */
-export declare class Reglist<T> {
-    /** 功能列表 */
-    private readonly list;
-    /** 插件与功能名称绑定表 */
-    private readonly pluginIdMap;
-    private readonly name;
-    protected readonly main: FloatingLive;
-    constructor(main: FloatingLive, name: string);
-    /** 注册一个对象 */
-    register(id: string, item: T): void;
-    /** 取消某一插件在该模块中的注册 */
-    unregister(pluginName: string): void;
-    /** 获取名称 */
-    getName(): string;
-    /** 根据id获取注册对象 */
-    get(id: string): T | undefined;
-    /** 检查注册对象是否存在 */
-    has(id: string): boolean;
-    /** 获取注册对象列表 */
-    getList(): T[];
-    /** 遍历 */
-    forEach(callbackfn: (value: T, key: string) => void): void;
-    /** 获取注册id列表 */
-    getIdList(): string[];
-    /** 获取注册id列表 */
-    getIdByPlugin(name: string): string[];
-}

package/dist/core/Reglist.js

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Reglist = void 0;
-/** 插件可注册对象模块 */
-class Reglist {
-    constructor(main, name) {
-        this.main = main;
-        this.name = name;
-        this.list = new Map();
-        this.pluginIdMap = new Map();
-    }
-    /** 注册一个对象 */
-    register(id, item) {
-        // 如果组件缺少id, 或者id与已安装插件重复, 则报错
-        if (!id)
-            throw new TypeError("id is required!");
-        if (this.list.has(id))
-            throw new TypeError(`${this.name} duplicate id: ${id}!`);
-        // 将组件添加至列表中
-        this.list.set(id, item);
-        // 将插件名称与注册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(this.main.plugin.currentPlugin, [id]);
-            }
-        }
-    }
-    /** 取消某一插件在该模块中的注册 */
-    unregister(pluginName) {
-        if (this.pluginIdMap.has(pluginName)) {
-            const handlerList = this.pluginIdMap.get(pluginName);
-            handlerList?.forEach((plugin) => {
-                this.list.delete(plugin);
-            });
-        }
-    }
-    /** 获取名称 */
-    getName() {
-        return this.name;
-    }
-    /** 根据id获取注册对象 */
-    get(id) {
-        return this.list.get(id);
-    }
-    /** 检查注册对象是否存在 */
-    has(id) {
-        return this.list.has(id);
-    }
-    /** 获取注册对象列表 */
-    getList() {
-        return [...this.list.values()];
-    }
-    /** 遍历 */
-    forEach(callbackfn) {
-        this.list.forEach(callbackfn);
-    }
-    /** 获取注册id列表 */
-    getIdList() {
-        return [...this.list.keys()];
-    }
-    /** 获取注册id列表 */
-    getIdByPlugin(name) {
-        return [...(this.pluginIdMap.get(name) || [])];
-    }
-}
-exports.Reglist = Reglist;

package/dist/module/ModCommand.d.ts

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

package/dist/module/ModCommand.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const Reglist_1 = require("../core/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)?.(...args);
-    }
-}
-exports.default = ModCommand;

package/dist/module/ModMessage.d.ts

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

package/dist/module/ModMessage.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModMessage = void 0;
-const Reglist_1 = require("../core/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/dist/module/ModPlugin.d.ts

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

package/dist/module/ModState.d.ts

@@ -1,12 +0,0 @@
-import { FloatingLive } from "../live";
-import { Reglist } from "../core/Reglist";
-export declare class ModState extends Reglist<() => object> {
-    constructor(main: FloatingLive);
-    generate(): Record<string, any>;
-    /** 设置一个值 */
-    set(name: string, value: any): void;
-    /** 在数组中添加一个值 */
-    arrayPush(name: string, value: any): void;
-    /** 在数组中移除一个值 */
-    arrayRemove(name: string, key: string, val: string): void;
-}

package/dist/module/ModState.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModState = void 0;
-const Reglist_1 = require("../core/Reglist");
-class ModState extends Reglist_1.Reglist {
-    constructor(main) {
-        super(main, "state");
-    }
-    generate() {
-        const state = {};
-        this.forEach((gen, key) => {
-            state[key] = gen();
-        });
-        return state;
-    }
-    /** 设置一个值 */
-    set(name, value) {
-        this.main.emit("state:set", name, value);
-    }
-    /** 在数组中添加一个值 */
-    arrayPush(name, value) {
-        this.main.emit("state:array_push", name, value);
-    }
-    /** 在数组中移除一个值 */
-    arrayRemove(name, key, val) {
-        this.main.emit("state:array_remove", name, key, val);
-    }
-}
-exports.ModState = ModState;