floating-live 0.15.2 → 0.15.4

package/README.md

@@ -1,9 +1,9 @@
 # Floating Live
 一个用于处理和保存直播弹幕的Node.js小工具，开箱即用。
 
-本体无弹幕获取功能，需要配合[floating-live-danmaku](https://github.com/Minteea/floating-live-danmaku)中的弹幕获取插件使用。
+本体无弹幕获取功能，需要配合[floating-live-plugins](https://github.com/Minteea/floating-live-plugins)中的插件使用。
 
-目前支持bilibili和AcFun的直播弹幕，不同平台的弹幕会转换为同一种格式便于保存。
+目前插件库支持bilibili和AcFun的直播弹幕，不同平台的弹幕会转换为同一种格式便于保存。
 
 项目仍在开发中，功能尚未完善，目前除了记录保存直播弹幕外暂时没有别的用处啦，敬请期待。
 

package/dist/live.d.ts

@@ -7,7 +7,7 @@ import { ModCommand } from "./module/command";
 import { ModValue } from "./module/value";
 import { ModHook } from "./module/hook";
 import { FloatingEventMap } from "./types/events";
-import { FloatingCommandMap } from "./types";
+import { ErrorOptions, FloatingCommandMap } from "./types";
 export declare class FloatingLive extends EventEmitter {
     /** 房间控制模块 */
     room: ModRoom;
@@ -25,11 +25,14 @@ export declare class FloatingLive extends EventEmitter {
     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;
+    /** 抛出错误 */
+    throw(err: Error, options?: ErrorOptions): void;
+    throw(options: ErrorOptions): void;
     getSnapshot(): {
         room: import("./types").RoomInfo[];
         value: Record<string, any>;
         manifest: Record<string, Record<string, any>>;
         command: string[];
+        hook: Record<string, any>;
     };
 }

package/dist/live.js

@@ -29,8 +29,13 @@ class FloatingLive extends events_1.EventEmitter {
         super.emit("event", eventName, ...args);
         return emit;
     }
-    throw(err) {
-        this.emit("error", err);
+    throw(err, options) {
+        if (err instanceof Error) {
+            throw Object.assign(err, options);
+        }
+        else {
+            throw Object.assign(new Error(), err);
+        }
     }
     getSnapshot() {
         return {
@@ -38,6 +43,7 @@ class FloatingLive extends events_1.EventEmitter {
             value: this.value.getSnapshot(),
             manifest: this.manifest.getSnapshot(),
             command: this.command.getSnapshot(),
+            hook: this.value.getSnapshot(),
         };
     }
 }

package/dist/module/command.js

@@ -19,7 +19,16 @@ class ModCommand {
     }
     /** 调用命令 */
     call(name, ...args) {
-        return this.list.get(name)?.(...args);
+        const command = this.list.get(name);
+        if (!command) {
+            this.main.throw({
+                message: "命令不存在",
+                id: "command:call_unexist",
+            });
+        }
+        else {
+            return command(...args);
+        }
     }
     /** 检测命令是否存在 */
     has(name) {

package/dist/module/plugin.d.ts

@@ -1,16 +1,14 @@
 import { FloatingLive } from "../live";
-import { PluginConstructor } from "../types/plugin";
+import { PluginItem, PluginConstructor } from "../types/plugin";
 export declare class ModPlugin {
     /** 插件列表 */
     private list;
     protected readonly main: FloatingLive;
     constructor(main: FloatingLive);
     /** 注册插件 */
-    register(pluginFunc: PluginConstructor, options?: any): Promise<void> | undefined;
+    register(pluginFunc: PluginConstructor, options?: Record<string, any>): Promise<PluginItem | undefined>;
     /** 移除插件 */
-    unregister(name: string): void;
+    unregister(name: string): Promise<void>;
     /** 获取插件实例 */
-    get(name: string): {
-        [key: string]: any;
-    } | undefined;
+    get(name: string): PluginItem | undefined;
 }

package/dist/module/plugin.js

@@ -8,52 +8,52 @@ class ModPlugin {
         this.main = main;
     }
     /** 注册插件 */
-    register(pluginFunc, options) {
+    async register(pluginFunc, options = {}) {
         const name = pluginFunc.pluginName;
         if (!name) {
-            this.main.throw(Object.assign(new TypeError("缺少插件id"), {
-                from: "plugin",
-                signal: "plugin_id_missing",
-            }));
-            return;
+            this.main.throw({
+                message: "缺少插件id",
+                id: "plugin:register_id_missing",
+            });
         }
         if (this.list.has(name)) {
-            this.main.throw(Object.assign(new Error("插件id重复"), {
-                from: "plugin",
-                signal: "plugin_id_duplicate",
-            }));
-            return;
+            this.main.throw({
+                message: "已存在相同id的插件",
+                id: "plugin:register_id_duplicate",
+            });
         }
-        return this.main.hook
+        return await this.main.hook
             .call("plugin.register", { name, options })
-            .then((res) => {
+            .then(async (res) => {
             if (!res)
                 return;
             // 执行插件函数
             const plugin = new pluginFunc(this.main, options);
             this.list.set(name, plugin);
             // 调用插件的register钩子
-            plugin.register?.(this.main, options);
+            await plugin.register?.(this.main, options);
             this.main.emit("plugin:add", name);
+            return plugin;
         });
     }
     /** 移除插件 */
-    unregister(name) {
+    async unregister(name) {
         const plugin = this.list.get(name);
         // 检测插件是否存在
         if (!plugin) {
-            this.main.throw(Object.assign(new Error("插件不存在"), {
-                from: "plugin",
-                signal: "plugin_unexist",
-            }));
-            return;
+            this.main.throw({
+                message: "插件不存在",
+                id: "plugin:unregister_unexist",
+            });
+        }
+        else {
+            // 调用该插件的destroy钩子
+            await plugin.destroy?.();
+            // 从列表中移除插件
+            this.list.delete(name);
+            // 移除插件注册
+            this.main.emit("plugin:remove", name);
         }
-        // 调用该插件的destroy钩子
-        plugin.destroy?.();
-        // 从列表中移除插件
-        this.list.delete(name);
-        // 移除插件注册
-        this.main.emit("plugin:remove", name);
     }
     /** 获取插件实例 */
     get(name) {

package/dist/module/room.d.ts

@@ -9,7 +9,7 @@ export declare class ModRoom {
     /** 添加房间监听实例 */
     addRoom(room: LiveRoom, open?: boolean): void;
     /** 添加房间 */
-    add(platform: string, id: number, options?: boolean | Record<string, any>): void;
+    add(platform: string, id: number, options?: boolean | Record<string, any>): Promise<void>;
     /** 移除房间 */
     remove(roomKey: string): void;
     /** 获取房间 */

package/dist/module/room.js

@@ -17,10 +17,10 @@ class ModRoom {
     addRoom(room, open) {
         let key = room.key;
         if (this.list.has(key)) {
-            this.main.throw(Object.assign(new Error("房间已存在"), {
-                from: "room",
-                signal: "room_exist",
-            }));
+            this.main.throw({
+                message: "房间已存在",
+                id: "room:add_exist",
+            });
             return;
         }
         this.list.set(key, room);
@@ -81,24 +81,29 @@ class ModRoom {
         this.main.emit("room:add", key, room.info);
     }
     /** 添加房间 */
-    add(platform, id, options) {
-        const opt = typeof options == "boolean" ? { open: options } : options;
-        const ctx = { platform, id, options: opt || {} };
-        this.main.hook.call("room.add", ctx).then((res) => {
-            if (!res)
-                return;
-            const room = this.main.call(`${platform}.room.create`, id, opt);
-            room && this.addRoom(room);
-        });
+    async add(platform, id, options) {
+        const opt = typeof options == "boolean" ? { open: options } : options || {};
+        const ctx = { platform, id, options: opt };
+        const res = await this.main.hook.call("room.add", ctx);
+        if (!res) {
+            this.main.throw({ message: "无法添加房间", id: "room:add_fail" });
+        }
+        const room = this.main.call(`${platform}.room.create`, id, opt);
+        if (!room) {
+            this.main.throw({ message: "无法创建房间", id: "room:create_fail" });
+        }
+        else {
+            this.addRoom(room);
+        }
     }
     /** 移除房间 */
     remove(roomKey) {
         let room = this.list.get(roomKey);
         if (!room) {
-            this.main.throw(Object.assign(new Error("房间不存在"), {
-                from: "room",
-                signal: "room_unexist",
-            }));
+            this.main.throw({
+                message: "房间不存在",
+                id: "room:remove_unexist",
+            });
         }
         this.list.delete(roomKey); // 从表中删除房间
         room?.removeAllListeners(); // 移除房间监听实例

package/dist/types/command.d.ts

@@ -1,4 +1,5 @@
 import { LiveRoom } from "../core";
+import { RoomInfo } from "./room";
 export interface FloatingCommandMap {
     add: (platform: string, id: number, options?: boolean | Record<string, any>) => void;
     remove: (key: string) => void;
@@ -6,4 +7,5 @@ export interface FloatingCommandMap {
     close: (key: string) => void;
     update: (key: string) => void;
     [name: `${string}.room.create`]: (id: string | number, options?: Record<string, any>) => LiveRoom;
+    [name: `${string}.room.info`]: (id: string | number) => RoomInfo;
 }

package/dist/types/error.d.ts

@@ -0,0 +1,8 @@
+export interface ErrorOptions {
+    /** 错误消息 */
+    message?: string;
+    /** 错误id */
+    id?: string;
+    /** 错误名称 */
+    [key: string]: any;
+}

package/dist/types/error.js

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

package/dist/types/index.d.ts

@@ -6,3 +6,4 @@ export * from "./events";
 export * from "./manifest";
 export * from "./hook";
 export * from "./value";
+export * from "./error";

package/dist/types/index.js

@@ -22,3 +22,4 @@ __exportStar(require("./events"), exports);
 __exportStar(require("./manifest"), exports);
 __exportStar(require("./hook"), exports);
 __exportStar(require("./value"), exports);
+__exportStar(require("./error"), exports);

package/dist/types/plugin.d.ts

@@ -1,16 +1,13 @@
 import { FloatingLive } from "../live";
-/** 插件模块, 加载时调用 */
-export type FloatingLivePlugin<C extends object = object> = () => {
-    /** 插件名称 */
-    name: string;
-    register: (ctx: FloatingLive, options?: C) => void;
-    destroy?: (ctx: FloatingLive) => void;
-};
-export interface IPlugin {
-    register?(ctx: FloatingLive, options: any): void;
-    destroy?(): void;
+/** 插件对象 */
+export interface PluginItem {
+    pluginName?: string;
+    register?(ctx: FloatingLive, options: any): void | Promise<void>;
+    destroy?(): void | Promise<void>;
+    [name: string]: any;
 }
+/** 插件构造器 */
 export interface PluginConstructor {
     pluginName: string;
-    new (ctx: FloatingLive, options: any): IPlugin;
+    new (ctx: FloatingLive, options: any): PluginItem;
 }

package/package.json

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