floating-live 0.16.0-alpha.15 → 0.16.0-alpha.17

package/dist/command/manager.js

@@ -1,3 +1,4 @@
+import { AppError } from "../error";
 export class CommandManager {
     constructor(app) {
         /** 功能列表 */
@@ -23,10 +24,10 @@ export class CommandManager {
     callWithOptions(name, options, ...args) {
         const command = this.list.get(name);
         if (!command) {
-            throw {
-                message: "命令不存在",
-                id: "command:call_unexist",
-            };
+            throw new AppError("command:call_unexist", {
+                message: `命令不存在: ${name}`,
+                target: `command/${name}`,
+            });
         }
         else {
             return command.call({ source: options.source, client: options.client }, ...args);

package/dist/error/index.d.ts

@@ -1,10 +1,12 @@
 import { ErrorOptions } from "./types";
 export * from "./types";
 export declare class AppError extends Error {
-    /** 错误来源 */
-    source?: string;
     /** 错误id */
     id: string;
+    /** 错误来源 */
+    source?: string;
+    /** 错误目标 */
+    target?: string;
     /** 错误原因 */
     cause?: Error | string;
     constructor(id: string, options: ErrorOptions);

package/dist/error/types.d.ts

@@ -2,5 +2,6 @@ export interface ErrorOptions {
     message?: string;
     cause?: string | Error;
     source?: string;
+    target?: string;
     [key: string]: any;
 }

package/dist/hook/manager.d.ts

@@ -1,13 +1,5 @@
 import { App } from "../app";
-import { AppError, ErrorOptions } from "../error";
 import { HookFunction, HookUseOptions } from "./types";
-export interface HookErrorOptions extends ErrorOptions {
-    hookName: string;
-}
-export declare class HookError extends AppError {
-    hookName: string;
-    constructor(id: string, options: HookErrorOptions);
-}
 export declare class HookManager {
     private list;
     private pluginMap;

package/dist/hook/manager.js

@@ -1,10 +1,4 @@
 import { AppError } from "../error";
-export class HookError extends AppError {
-    constructor(id, options) {
-        super(id, options);
-        this.hookName = options.hookName;
-    }
-}
 export class HookManager {
     constructor(app) {
         this.list = new Map();
@@ -20,10 +14,10 @@ export class HookManager {
             this.list.set(name, hooks);
         }
         else if (hooks.includes(call)) {
-            throw new HookError("hook:use_duplicate", {
+            throw new AppError("hook:use_duplicate", {
                 message: `钩子函数挂载失败: ${name}`,
                 cause: "重复挂载同一函数",
-                hookName: name,
+                target: `hook/${name}`,
             });
         }
         hooks.push({ call, pluginName });
@@ -31,15 +25,13 @@ export class HookManager {
     /** 取消挂载钩子函数 */
     unuse(name, call) {
         let hooks = this.list.get(name);
-        if (!hooks)
-            throw new HookError("hook:unuse_unexisted", {
+        const index = hooks?.findIndex((item) => item.call == call) ?? -1;
+        if (!hooks || index < 0)
+            throw new AppError("hook:unuse_unexist", {
                 message: `钩子函数卸载失败: ${name}`,
                 cause: "卸载不存在的钩子函数",
-                hookName: name,
+                target: `hook/${name}`,
             });
-        const index = hooks.findIndex((item) => item.call == call);
-        if (index < 0)
-            throw {};
         hooks.splice(index, 1);
     }
     /** 调用钩子函数 */

package/dist/live/room.d.ts

@@ -21,12 +21,12 @@ export declare abstract class LiveRoom extends CustomEventEmitter implements Liv
     timestamp: number;
     /** 当前直播id */
     liveId?: string;
-    /** 房间是否打开 */
-    opened: boolean;
     /** 房间连接状态 */
-    connection: LiveConnectionStatus;
-    /** 房间是否可用 */
-    available: boolean;
+    connectionStatus: LiveConnectionStatus;
+    /** 房间开启状态 */
+    openStatus: LiveRoomOpenStatus;
+    get opened(): boolean;
+    get available(): boolean;
     /** 打开连接 */
     abstract open(): void;
     /** 关闭连接 */
@@ -78,12 +78,14 @@ export interface LiveRoomData {
     liveId?: string;
     /** 直播状态 */
     status: LiveRoomStatus;
-    /** 直播间是否可用 */
-    available: boolean;
-    /** 房间监听是否打开 */
-    opened: boolean;
     /** 房间连接状态 */
-    connection: LiveConnectionStatus;
+    connectionStatus: LiveConnectionStatus;
+    /** 房间监听状态 */
+    openStatus: LiveRoomOpenStatus;
+    /** 房间是否开启 */
+    opened: boolean;
+    /** 房间是否可用 */
+    available: boolean;
 }
 /** 房间展示信息 */
 export interface LiveRoomDetailInfo {
@@ -133,6 +135,18 @@ export declare const LiveConnectionStatus: {
     readonly disconnected: -1;
 };
 export type LiveConnectionStatus = EnumValue<typeof LiveConnectionStatus>;
+/** 直播间开启状态 */
+export declare const LiveRoomOpenStatus: {
+    /** 已关闭 */
+    readonly closed: 0;
+    /** 正在开启 */
+    readonly opening: 1;
+    /** 已开启 */
+    readonly opened: 2;
+    /** 不可用 */
+    readonly unavailable: -1;
+};
+export type LiveRoomOpenStatus = EnumValue<typeof LiveRoomOpenStatus>;
 export interface LiveRoomEventMap {
     /**  */
     status: {

package/dist/live/room.js

@@ -7,12 +7,16 @@ export class LiveRoom extends CustomEventEmitter {
         this.status = LiveRoomStatus.off;
         /** 时间戳 */
         this.timestamp = 0;
-        /** 房间是否打开 */
-        this.opened = false;
         /** 房间连接状态 */
-        this.connection = LiveConnectionStatus.off;
-        /** 房间是否可用 */
-        this.available = false;
+        this.connectionStatus = LiveConnectionStatus.off;
+        /** 房间开启状态 */
+        this.openStatus = -1;
+    }
+    get opened() {
+        return this.openStatus == 2;
+    }
+    get available() {
+        return this.openStatus > -1;
     }
     /** 销毁 */
     destroy() {
@@ -70,9 +74,10 @@ export class LiveRoom extends CustomEventEmitter {
             timestamp: this.timestamp,
             status: this.status,
             liveId: this.liveId,
-            available: this.available,
+            openStatus: this.openStatus,
             opened: this.opened,
-            connection: this.connection,
+            available: this.available,
+            connectionStatus: this.connectionStatus,
             key: this.key,
         };
     }
@@ -106,3 +111,14 @@ export const LiveConnectionStatus = {
     /** 连接失败或断开 */
     disconnected: -1,
 };
+/** 直播间开启状态 */
+export const LiveRoomOpenStatus = {
+    /** 已关闭 */
+    closed: 0,
+    /** 正在开启 */
+    opening: 1,
+    /** 已开启 */
+    opened: 2,
+    /** 不可用 */
+    unavailable: -1,
+};

package/dist/plugin/index.d.ts

@@ -1,8 +1,11 @@
+import { AppError } from "../error";
 import type { PluginItem, PluginContext } from "./types";
 export type * from "./types";
 export declare class BasePlugin implements PluginItem {
     static pluginName: string;
     pluginName: string;
     ctx: PluginContext;
+    readonly Error: typeof AppError;
+    readonly throw: (err?: Error) => void;
     constructor(ctx: PluginContext, options?: any);
 }

package/dist/plugin/index.js

@@ -1,5 +1,8 @@
+import { AppError } from "../error";
 export class BasePlugin {
     constructor(ctx, options) {
+        this.Error = AppError;
         this.ctx = ctx;
+        this.throw = ctx.throw;
     }
 }

package/dist/plugin/manager.d.ts

@@ -1,13 +1,5 @@
 import type { App } from "../app";
-import { AppError, ErrorOptions } from "../error";
 import { PluginItem, PluginConstructor, PluginContext, PluginRegisterOptions } from "./types";
-export interface PluginErrorOptions extends ErrorOptions {
-    pluginName: string;
-}
-export declare class PluginError extends AppError {
-    pluginName: string;
-    constructor(id: string, options: PluginErrorOptions);
-}
 export interface PluginData<T> {
     plugin: PluginItem;
     context: PluginContext;

package/dist/plugin/manager.js

@@ -1,12 +1,6 @@
 import { CommonPluginContext } from "./context/CommonPluginContext";
 import { AppError } from "../error";
 import { CorePluginContext } from "./context/CorePluginContext";
-export class PluginError extends AppError {
-    constructor(id, options) {
-        super(id, options);
-        this.pluginName = options.pluginName;
-    }
-}
 export class PluginManager {
     constructor(app) {
         /** 插件列表 */
@@ -16,17 +10,17 @@ export class PluginManager {
     registerSync(pluginConstructor, options = {}, { context, core } = {}) {
         const pluginName = pluginConstructor.pluginName;
         if (!pluginName) {
-            throw new PluginError("plugin:register_id_missing", {
+            throw new AppError("plugin:register_id_missing", {
                 message: "插件注册失败",
                 cause: "插件缺少pluginName字段",
-                pluginName: "",
+                target: "plugin/#unnamed",
             });
         }
         if (this.list.has(pluginName)) {
-            throw new PluginError("plugin:register_id_duplicate", {
+            throw new AppError("plugin:register_id_duplicate", {
                 message: `插件注册失败: ${pluginName}`,
                 cause: "已存在相同id的插件",
-                pluginName,
+                target: `plugin/${pluginName}`,
             });
         }
         const registerCtx = { pluginName, options };
@@ -34,10 +28,10 @@ export class PluginManager {
         try {
             const ctx = this.app.callHookSync("plugin.register", registerCtx);
             if (ctx.defaultPrevented)
-                throw new PluginError("plugin:register_hook_prevented", {
+                throw new AppError("plugin:register_hook_prevented", {
                     message: `插件注册失败: ${pluginName}`,
                     cause: "插件注册被钩子函数阻止",
-                    pluginName,
+                    target: `plugin/${pluginName}`,
                 });
             // 执行插件函数
             const plugin = new pluginConstructor(pluginCtx, registerCtx.options || {});
@@ -55,10 +49,10 @@ export class PluginManager {
             return plugin;
         }
         catch (err) {
-            throw new PluginError("plugin:register_fail", {
+            throw new AppError("plugin:register_fail", {
                 message: `插件注册失败: ${pluginName}`,
                 cause: err,
-                pluginName,
+                target: `plugin/${pluginName}`,
             });
         }
     }
@@ -66,17 +60,17 @@ export class PluginManager {
     async register(pluginConstructor, options = {}, { context, core } = {}) {
         const pluginName = pluginConstructor.pluginName;
         if (!pluginName) {
-            throw new PluginError("plugin:register_id_missing", {
+            throw new AppError("plugin:register_id_missing", {
                 message: "插件注册失败",
                 cause: "插件缺少pluginName字段",
-                pluginName: "",
+                target: "plugin/#unnamed",
             });
         }
         if (this.list.has(pluginName)) {
-            throw new PluginError("plugin:register_id_duplicate", {
+            throw new AppError("plugin:register_id_duplicate", {
                 message: `插件注册失败: ${pluginName}`,
                 cause: "已存在相同id的插件",
-                pluginName,
+                target: `plugin/${pluginName}`,
             });
         }
         const registerCtx = { pluginName, options };
@@ -85,10 +79,10 @@ export class PluginManager {
             .callHook("plugin.register", registerCtx)
             .then(async (ctx) => {
             if (ctx.defaultPrevented)
-                throw new PluginError("plugin:register_hook_prevented", {
+                throw new AppError("plugin:register_hook_prevented", {
                     message: `插件注册失败: ${pluginName}`,
                     cause: "插件注册被钩子函数阻止",
-                    pluginName,
+                    target: `plugin/${pluginName}`,
                 });
             // 执行插件函数
             const plugin = new pluginConstructor(pluginCtx, registerCtx.options || {});
@@ -106,10 +100,10 @@ export class PluginManager {
             return plugin;
         })
             .catch((err) => {
-            throw new PluginError("plugin:register_fail", {
+            throw new AppError("plugin:register_fail", {
                 message: `插件注册失败: ${pluginName}`,
                 cause: err,
-                pluginName,
+                target: `plugin/${pluginName}`,
             });
         });
     }
@@ -118,19 +112,19 @@ export class PluginManager {
         const pluginData = this.list.get(pluginName);
         // 检测插件是否存在
         if (!pluginData) {
-            throw new PluginError("plugin:unregister_unexist", {
+            throw new AppError("plugin:unregister_unexist", {
                 message: `插件移除失败: ${pluginName}`,
                 cause: "插件不存在",
-                pluginName,
+                target: `plugin/${pluginName}`,
             });
         }
         else {
             const { plugin, context, core } = pluginData;
             if (core) {
-                throw new PluginError("plugin:unregister_core", {
+                throw new AppError("plugin:unregister_core", {
                     message: `插件移除失败: ${pluginName}`,
                     cause: "无法移除核心插件",
-                    pluginName,
+                    target: `plugin/${pluginName}`,
                 });
             }
             // 调用插件和上下文的destroy钩子

package/dist/plugin/types.d.ts

@@ -45,7 +45,7 @@ export interface PluginContext {
     emit<K extends keyof AppEventDetailMap>(type: K, detail: AppEventDetailMap[K], options?: AppEventEmitOptions & EventInit): void;
     /** 抛出错误 */
     throw(err?: Error): void;
-    /** 生成错误 */
+    /** 生成错误 @deprecated */
     error(id: string, options: ErrorOptions): AppError;
     /** 注册插件 */
     register<P extends PluginItem>(plugin: PluginConstructor<P>, options?: PluginInitOptions): Promise<P>;

package/dist/plugins/room/index.js

@@ -32,7 +32,7 @@ export class Room extends BasePlugin {
     attach(room, open) {
         let key = room.key;
         if (this.map.has(key)) {
-            this.ctx.throw(new AppError("room:add_exist", {
+            this.throw(new AppError("room:add_exist", {
                 message: "房间已存在",
             }));
             return;
@@ -108,25 +108,32 @@ export class Room extends BasePlugin {
         const ctx = { platform, id, options: opt };
         const res = await this.ctx.callHook("room.add", ctx);
         if (res.defaultPrevented) {
-            this.ctx.throw(this.ctx.error("room:add_hook_prevented", {
+            this.throw(new this.Error("room:add_hook_prevented", {
                 message: "无法添加房间",
                 cause: "房间添加被钩子函数阻止",
+                target: `room/${platform}:${id}`,
             }));
         }
-        const room = await this.ctx.call(`${platform}.room.create`, id, opt);
-        if (!room) {
-            this.ctx.throw(this.ctx.error("room:create_fail", { message: "无法创建房间" }));
+        let room;
+        try {
+            room = await this.ctx.call(`${platform}.room.create`, id, opt);
         }
-        else {
-            this.attach(room);
+        catch (e) {
+            this.throw(new this.Error("room:create_fail", {
+                message: "无法创建房间",
+                cause: e,
+                target: `room/${platform}:${id}`,
+            }));
         }
+        this.attach(room);
     }
     /** 移除房间 */
     remove(key) {
         let room = this.map.get(key);
         if (!room) {
-            this.ctx.throw(this.ctx.error("room:remove_unexist", {
+            this.throw(new this.Error("room:remove_unexist", {
                 message: "房间不存在",
+                target: `room/${key}`,
             }));
         }
         this.map.delete(key); // 从表中删除房间
@@ -161,19 +168,35 @@ export class Room extends BasePlugin {
     /** 打开房间连接 */
     open(key) {
         let room = this.map.get(key);
-        room?.available && !room.opened && room.open();
+        if (!room) {
+            this.throw(new this.Error("room:open_unexist", {
+                message: "打开的房间不存在",
+                target: `room/${key}`,
+            }));
+        }
+        room.open();
     }
     /** 关闭房间连接 */
     close(key) {
         let room = this.map.get(key);
-        room?.opened && room.close();
+        if (!room) {
+            this.throw(new this.Error("room:close_unexist", {
+                message: "关闭的房间不存在",
+                target: `room/${key}`,
+            }));
+        }
+        room.close();
     }
     /** 更改某个房间的顺序 */
     move(key, position) {
         const arr = [...this.map];
         const index = arr.findIndex(([k]) => k == key);
-        if (index == -1)
-            return;
+        if (index == -1) {
+            this.throw(new this.Error("room:move_unexist", {
+                message: "要移动的房间不存在",
+                target: `room/${key}`,
+            }));
+        }
         const [item] = arr.splice(index, 1);
         arr.splice(position, 0, item);
         this.map = new Map(arr);

package/dist/value/manager.js

@@ -1,3 +1,4 @@
+import { AppError } from "../error";
 import { bindCommand } from "../utils";
 export class ValueManager {
     constructor(app) {
@@ -25,7 +26,9 @@ export class ValueManager {
     get(name, options) {
         const item = this.list.get(name);
         if (!item)
-            throw {};
+            throw new AppError("value:get_unexist", {
+                message: "无法获取未注册的值",
+            });
         return item.get(options);
     }
     /** 获取值(不存在则返回undefined) */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "floating-live",
-  "version": "0.16.0-alpha.15",
+  "version": "0.16.0-alpha.17",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",