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

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/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); // 从表中删除房间

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.16",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",