floating-live 0.17.0-alpha.2 → 0.17.0-alpha.4

package/dist/plugin/types.d.ts

@@ -1,10 +1,13 @@
 import { App } from "../app.js";
 import { CommandOptions, CommandCallOptions, AppCommandMap, CommandFunction } from "../command/index.js";
-import { AppError, ErrorOptions } from "../error/index.js";
 import { AppEventListener, AppEventEmitOptions, AppEventDetailMap } from "../event/index.js";
 import { AppHookMap, HookCallOptions, HookContext, HookFunction, HookUseOptions } from "../hook/index.js";
 import { AppValueMap, ValueContext, ValueOptions } from "../value/index.js";
-import { WhenRegisterCallback } from "./manager.js";
+/** 插件注册监听回调
+ * 当目标插件已经注册时，回调会被立即调用，否则将在目标插件注册时调用。
+ * 回调可以返回一个函数作为注销时的回调。
+ */
+export type WhenRegisterCallback = () => (() => void) | void;
 /** 插件对象 */
 export interface PluginItem {
     /** 插件名称 */
@@ -39,6 +42,16 @@ export interface PluginRegisterOptions {
     /** 插件类型 */
     pluginType?: "core" | "framework" | "";
 }
+export interface PluginData<T> {
+    plugin: PluginItem;
+    context: PluginContext;
+    exposes?: T;
+    unremovable: boolean;
+    /** 可访问App实例 */
+    accessApp: boolean;
+    /** 插件类型 */
+    pluginType: "core" | "framework" | "";
+}
 /** 插件上下文 */
 export interface PluginContext {
     /** 安全插件上下文 */
@@ -53,10 +66,6 @@ export interface PluginContext {
     off<K extends keyof AppEventDetailMap>(type: K, listener: AppEventListener<AppEventDetailMap[K]>): void;
     /** 发送事件 */
     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/platform/index.js

@@ -1,13 +1,11 @@
-import { BasePlugin } from "../../index.js";
+import { appError, BasePlugin } from "../../index.js";
 export class Platform extends BasePlugin {
-    constructor() {
-        super(...arguments);
-        this.list = new Map();
-    }
+    static pluginName = "platform";
+    list = new Map();
     /** 注册直播平台信息 */
     register(name, info, signal) {
         if (this.list.has(name)) {
-            throw new this.Error("platform:register_duplicated", {
+            throw appError("platform:register_duplicated", {
                 message: "平台信息重复注册",
             });
         }
@@ -21,7 +19,7 @@ export class Platform extends BasePlugin {
     /** 解除注册直播平台信息 */
     unregister(name) {
         if (!this.list.has(name)) {
-            throw new this.Error("platform:unregister_unexisted", {
+            throw appError("platform:unregister_unexisted", {
                 message: "无法解除不存在的平台信息注册",
             });
         }
@@ -44,5 +42,4 @@ export class Platform extends BasePlugin {
         return [...this.list].map(([name, info]) => ({ name, info }));
     }
 }
-Platform.pluginName = "platform";
 export default Platform;

package/dist/plugins/room/index.d.ts

@@ -1,17 +1,22 @@
 import { LiveMessage } from "../../live/message.js";
-import { LiveRoom, LiveRoomDetailInfo, LiveRoomData, LiveRoomStatsInfo, LiveRoomStatus } from "../../live/room.js";
+import { LiveRoom, LiveRoomDetailInfo, LiveRoomData, LiveRoomStatsInfo, LiveRoomStatus, InvalidLiveRoom } from "../../live/room.js";
 import { BasePlugin } from "../../plugin/index.js";
 import { PluginContext } from "../../plugin/types.js";
+export interface RoomCreateOptions {
+    allowInvalidRoom?: boolean;
+    open?: boolean;
+    [option: string]: any;
+}
 interface PluginExposes {
     add(platform: string, id: number, options?: boolean | Record<string, any>): void;
     remove(key: string): void;
-    get(key: string): LiveRoom | undefined;
+    get(key: string): LiveRoom | InvalidLiveRoom | undefined;
     has(key: string): boolean;
     data(key: string): LiveRoomData | undefined;
     update(key: string): void;
     open(key: string): void;
     close(key: string): void;
-    getList(): LiveRoom[];
+    getList(): (LiveRoom | InvalidLiveRoom)[];
 }
 declare module "../../index.js" {
     interface AppCommandMap {
@@ -22,19 +27,22 @@ declare module "../../index.js" {
         close: (key: string) => void;
         update: (key: string) => void;
         "room.snapshot": () => LiveRoomData[];
+        "room.validate": (key: string) => void;
+        "room.invalidate": (key: string) => void;
         [name: `${string}.room.create`]: (id: string | number, options: Record<string, any>) => LiveRoom | Promise<LiveRoom>;
         [name: `${string}.room.data`]: (id: string | number) => LiveRoomData | Promise<LiveRoomData>;
     }
     interface AppEventDetailMap {
         "live:message": {
+            key: string;
+            platform: string;
+            roomId: string | number;
             message: LiveMessage.All;
         };
         "live:raw": {
-            /** 平台 */
+            key: string;
             platform: string;
             roomId: string | number;
-            /** 服务来源 */
-            service?: string;
             data: any;
         };
         "room:connecting": {
@@ -60,6 +68,14 @@ declare module "../../index.js" {
             key: string;
             position: number;
         };
+        "room:validate": {
+            key: string;
+            room: LiveRoomData;
+        };
+        "room:invalidate": {
+            key: string;
+            room: LiveRoomData;
+        };
         "room:open": {
             key: string;
             room: LiveRoomData;
@@ -89,10 +105,13 @@ declare module "../../index.js" {
     }
     interface AppHookMap {
         "live.message": {
+            key: string;
+            platform: string;
+            roomId: string | number;
             message: LiveMessage.All;
         };
-        "room.add": {
-            platform: string;
+        "room.create": {
+            serviceId: string;
             id: string | number;
             options: Record<string, any>;
         };
@@ -107,17 +126,30 @@ declare module "../../index.js" {
 export declare class Room extends BasePlugin {
     static pluginName: string;
     private map;
+    /** AbortController 属性 symbol
+     * 与 room 插件实例绑定，为绑定的
+     */
     private symbolAbortController;
     init(ctx: PluginContext): void;
     expose(): PluginExposes;
     /** 添加房间监听实例 */
-    attach(room: LiveRoom, open?: boolean): void;
+    attach(room: LiveRoom | InvalidLiveRoom, open?: boolean): void;
+    /** 移除房间监听实例 */
+    detach(key: string): LiveRoom | InvalidLiveRoom;
+    /** 绑定房间事件监听 */
+    private bindEvent;
     /** 添加房间 */
-    add(platform: string, id: number, options?: boolean | Record<string, any>): Promise<void>;
-    /** 移除房间 */
+    add(serviceId: string, id: number, options?: boolean | RoomCreateOptions): Promise<void>;
+    /** 创建房间实例 */
+    create(serviceId: string, id: number | string, options?: RoomCreateOptions): Promise<LiveRoom | InvalidLiveRoom>;
+    /** 移除并销毁房间 */
     remove(key: string): void;
+    /** 激活无效房间 */
+    validate(key: string, options: RoomCreateOptions): Promise<void>;
+    /** 使有效的房间设为无效 */
+    invalidate(key: string): void;
     /** 获取房间 */
-    get(key: string): LiveRoom | undefined;
+    get(key: string): LiveRoom | InvalidLiveRoom | undefined;
     has(key: string): boolean;
     /** 获取房间信息 */
     data(key: string): LiveRoomData | undefined;
@@ -126,7 +158,7 @@ export declare class Room extends BasePlugin {
     /** 获取房间key列表 */
     get keys(): string[];
     /** 获取房间列表 */
-    getList(): LiveRoom[];
+    getList(): (LiveRoom | InvalidLiveRoom)[];
     /** 打开房间连接 */
     open(key: string): void;
     /** 关闭房间连接 */

package/dist/plugins/room/index.js

@@ -1,12 +1,14 @@
-import { AppError } from "../../error/index.js";
+import { appError } from "../../error/index.js";
+import { InvalidLiveRoom, } from "../../live/room.js";
 import { BasePlugin } from "../../plugin/index.js";
 import { bindCommand } from "../../utils/index.js";
 export class Room extends BasePlugin {
-    constructor() {
-        super(...arguments);
-        this.map = new Map();
-        this.symbolAbortController = Symbol("room.abortController");
-    }
+    static pluginName = "room";
+    map = new Map();
+    /** AbortController 属性 symbol
+     * 与 room 插件实例绑定，为绑定的
+     */
+    symbolAbortController = Symbol("room.abortController");
     init(ctx) {
         ctx.registerCommand("add", bindCommand(this.add, this));
         ctx.registerCommand("remove", bindCommand(this.remove, this));
@@ -31,14 +33,44 @@ export class Room extends BasePlugin {
     }
     /** 添加房间监听实例 */
     attach(room, open) {
-        let key = room.key;
+        const key = room.key;
         if (this.map.has(key)) {
-            this.throw(new AppError("room:add_exist", {
-                message: "房间已存在",
-            }));
-            return;
+            throw appError("room:add_exist", {
+                message: `房间已存在[${key}]`,
+                target: `room/${key}`,
+            });
         }
         this.map.set(key, room);
+        // 如果房间有效，则绑定事件
+        if (room.valid) {
+            this.bindEvent(room);
+            if (open) {
+                room.open();
+            }
+            this.ctx.emit("room:add", { key, room: room.toData() });
+        }
+    }
+    /** 移除房间监听实例 */
+    detach(key) {
+        const room = this.map.get(key);
+        if (!room) {
+            throw appError("room:remove_unexist", {
+                message: `房间不存在[${key}]`,
+                target: `room/${key}`,
+            });
+        }
+        this.map.delete(key); // 从表中删除房间
+        // 移除插件实例对该房间的所有监听
+        room[this.symbolAbortController]?.abort();
+        room[this.symbolAbortController] = undefined;
+        this.ctx.emit("room:remove", { key });
+        return room;
+    }
+    /** 绑定房间事件监听 */
+    bindEvent(room) {
+        const key = room.key;
+        const platform = room.platform;
+        const roomId = room.id;
         const abortController = new AbortController();
         room[this.symbolAbortController] =
             abortController;
@@ -48,15 +80,15 @@ export class Room extends BasePlugin {
         // 添加监听事件
         // 直播消息
         setHandler("message", ({ message }) => {
-            const ctx = { message };
+            const ctx = { key, platform, roomId, message };
             this.ctx.callHook("live.message", ctx).then((ctx) => {
                 !ctx.defaultPrevented &&
-                    this.ctx.emit("live:message", { message: ctx.message });
+                    this.ctx.emit("live:message", { key, platform, roomId, message: ctx.message });
             });
         });
         // 直播消息源数据
         setHandler("raw", ({ platform, roomId, data }) => {
-            this.ctx.emit("live:raw", { platform, roomId, data });
+            this.ctx.emit("live:raw", { key, platform, roomId, data });
         });
         // 正在连接服务器
         setHandler("connecting", () => {
@@ -98,48 +130,117 @@ export class Room extends BasePlugin {
         setHandler("close", () => {
             this.ctx.emit("room:close", { key, room: room.toData() });
         });
-        if (open) {
-            room.open();
-        }
-        this.ctx.emit("room:add", { key, room: room.toData() });
     }
     /** 添加房间 */
-    async add(platform, id, options) {
+    async add(serviceId, id, options) {
         const opt = typeof options == "boolean" ? { open: options } : options || {};
-        const ctx = { platform, id, options: opt };
-        const res = await this.ctx.callHook("room.add", ctx);
+        const room = await this.create(serviceId, id, opt);
+        this.attach(room);
+    }
+    /** 创建房间实例 */
+    async create(serviceId, id, options = {}) {
+        const ctx = { serviceId, id, options };
+        const res = await this.ctx.callHook("room.create", ctx).catch((reason) => {
+            throw appError("room:create_hook_error", {
+                message: `无法创建房间监听实例[${serviceId}:${id}]：调用钩子函数出错`,
+                target: `room/${serviceId}:${id}`,
+            });
+        });
         if (res.defaultPrevented) {
-            this.throw(new this.Error("room:add_hook_prevented", {
-                message: "无法添加房间",
-                cause: "房间添加被钩子函数阻止",
-                target: `room/${platform}:${id}`,
-            }));
+            throw appError("room:create_hook_prevented", {
+                message: `无法创建房间监听实例[${serviceId}:${id}]：房间添加被钩子函数阻止`,
+                target: `room/${serviceId}:${id}`,
+            });
         }
         let room;
         try {
-            room = await this.ctx.call(`${platform}.room.create`, id, opt);
+            room = await this.ctx.call(`${serviceId}.room.create`, id, options);
         }
         catch (e) {
-            this.throw(new this.Error("room:create_fail", {
-                message: "无法创建房间",
-                cause: e,
-                target: `room/${platform}:${id}`,
-            }));
+            if (options.allowInvalidRoom) {
+                room = new InvalidLiveRoom(serviceId, id);
+            }
+            else {
+                throw appError("room:create_fail", {
+                    message: `创建房间监听实例失败[${serviceId}:${id}]`,
+                    reason: e,
+                    target: `room/${serviceId}:${id}`,
+                });
+            }
         }
-        this.attach(room);
+        return room;
     }
-    /** 移除房间 */
+    /** 移除并销毁房间 */
     remove(key) {
+        const room = this.detach(key);
+        if (room.valid) {
+            try {
+                room.destroy?.();
+            }
+            catch (e) {
+                throw appError("room:destroy_fail", {
+                    message: `销毁房间实例失败[${key}]`,
+                    reason: e,
+                    target: `room/${key}`,
+                });
+            }
+        }
+    }
+    /** 激活无效房间 */
+    async validate(key, options) {
+        let invalidRoom = this.map.get(key);
+        if (!invalidRoom) {
+            throw appError("room:validate_unexist", {
+                message: `房间不存在[${key}]`,
+                target: `room/${key}`,
+            });
+        }
+        if (invalidRoom.valid == true) {
+            throw appError("room:validate_valid", {
+                message: `无法将已经有效的房间再次设为有效[${key}]`,
+                target: `room/${key}`,
+            });
+        }
+        const { serviceId, id } = invalidRoom;
+        const room = await this.create(serviceId, id, { ...options, allowInvalidRoom: false });
+        this.map.set(key, room);
+        if (room.valid) {
+            this.ctx.emit("room:validate", { key, room: room.toData() });
+        }
+    }
+    /** 使有效的房间设为无效 */
+    invalidate(key) {
         let room = this.map.get(key);
         if (!room) {
-            this.throw(new this.Error("room:remove_unexist", {
-                message: "房间不存在",
+            throw appError("room:invalidate_unexist", {
+                message: `房间不存在[${key}]`,
                 target: `room/${key}`,
-            }));
+            });
         }
-        this.map.delete(key); // 从表中删除房间
-        room[this.symbolAbortController]?.abort(); // 移除房间监听实例
+        if (room.valid == true) {
+            throw appError("room:invalidate_invalid", {
+                message: `无法将已经无效的房间再次设为无效[${key}]`,
+                target: `room/${key}`,
+            });
+        }
+        // 用无效房间替换掉原房间
+        const { serviceId, id } = room;
+        const invalidRoom = new InvalidLiveRoom(serviceId, id);
+        this.map.set(key, invalidRoom);
+        // 移除插件实例对原房间的所有监听
+        room[this.symbolAbortController]?.abort();
+        room[this.symbolAbortController] = undefined;
         this.ctx.emit("room:remove", { key });
+        try {
+            room.destroy?.();
+        }
+        catch (e) {
+            throw appError("room:destroy_fail", {
+                message: `销毁房间实例失败[${key}]`,
+                reason: e,
+                target: `room/${key}`,
+            });
+        }
     }
     /** 获取房间 */
     get(key) {
@@ -156,7 +257,7 @@ export class Room extends BasePlugin {
     /** 更新房间信息 */
     update(key) {
         let room = this.map.get(key);
-        room && room.update();
+        room && room.valid && room.update();
     }
     /** 获取房间key列表 */
     get keys() {
@@ -170,21 +271,33 @@ export class Room extends BasePlugin {
     open(key) {
         let room = this.map.get(key);
         if (!room) {
-            this.throw(new this.Error("room:open_unexist", {
-                message: "打开的房间不存在",
+            throw (appError("room:open_unexist", {
+                message: "要打开的房间不存在",
                 target: `room/${key}`,
             }));
         }
+        if (!room.valid) {
+            throw appError("room:open_invalid", {
+                message: "要打开的房间无效",
+                target: `room/${key}`,
+            });
+        }
         room.open();
     }
     /** 关闭房间连接 */
     close(key) {
         let room = this.map.get(key);
         if (!room) {
-            this.throw(new this.Error("room:close_unexist", {
+            throw appError("room:close_unexist", {
                 message: "关闭的房间不存在",
                 target: `room/${key}`,
-            }));
+            });
+        }
+        if (!room.valid) {
+            throw appError("room:close_invalid", {
+                message: "要关闭的房间无效",
+                target: `room/${key}`,
+            });
         }
         room.close();
     }
@@ -193,10 +306,10 @@ export class Room extends BasePlugin {
         const arr = [...this.map];
         const index = arr.findIndex(([k]) => k == key);
         if (index == -1) {
-            this.throw(new this.Error("room:move_unexist", {
+            throw appError("room:move_unexist", {
                 message: "要移动的房间不存在",
                 target: `room/${key}`,
-            }));
+            });
         }
         const [item] = arr.splice(index, 1);
         arr.splice(position, 0, item);
@@ -208,5 +321,4 @@ export class Room extends BasePlugin {
         return this.getList().map((room) => room.toData());
     }
 }
-Room.pluginName = "room";
 export default Room;

package/dist/value/manager.js

@@ -1,8 +1,9 @@
-import { AppError } from "../error/index.js";
+import { AppErrorLegacy } from "../error/index.js";
 import { bindCommand } from "../utils/index.js";
 export class ValueManager {
+    list = new Map();
+    app;
     constructor(app) {
-        this.list = new Map();
         this.app = app;
         app.registerCommand("value.snapshot", bindCommand(this.toSnapshot, this));
     }
@@ -25,7 +26,7 @@ export class ValueManager {
     get(name, options) {
         const item = this.list.get(name);
         if (!item)
-            throw new AppError("value:get_unexist", {
+            throw new AppErrorLegacy("value:get_unexist", {
                 message: "无法获取未注册的值",
             });
         return item.get(options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "floating-live",
-  "version": "0.17.0-alpha.2",
+  "version": "0.17.0-alpha.4",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,13 +11,17 @@
     "rimraf": "^3.0.2",
     "ts-node": "^10.9.1",
     "tsc-alias": "^1.8.16",
-    "typescript": "^5.6.3"
+    "typescript": "^6.0.3"
   },
   "scripts": {
     "tsc": "tsc -b",
+    "check": "tsc --noEmit",
     "clear": "rimraf dist",
     "build": "npm run clear && tsc -b && tsc-alias",
     "prepack": "npm run build",
     "postpack": "npm run clear"
-  }
+  },
+  "files": [
+    "./dist/"
+  ]
 }