floating-live 0.17.0-alpha.12 → 0.17.0-alpha.13

package/dist/FloatingLive.d.ts

@@ -13,8 +13,6 @@ export declare class FloatingLive extends App {
     /** 获取房间 */
     get(key: string): LiveRoom | import("./live/index.js").InvalidLiveRoom | undefined;
     has(key: string): boolean;
-    /** 获取房间信息 */
-    data(key: string): import("./live/index.js").LiveRoomData | undefined;
     /** 更新房间信息 */
     update(key: string): void;
     /** 打开房间连接 */

package/dist/FloatingLive.js

@@ -24,10 +24,6 @@ export class FloatingLive extends App {
     has(key) {
         return this.room.has(key);
     }
-    /** 获取房间信息 */
-    data(key) {
-        return this.room.data(key);
-    }
     /** 更新房间信息 */
     update(key) {
         return this.room.update(key);

package/dist/app.d.ts

@@ -1,4 +1,4 @@
-import { CommandOptions, CommandCallOptions, AppCommandMap, CommandFunction } from "./command/index.js";
+import { CommandOptions, CommandCallOptions, AppCommandMap, CommandFunction, AppCommandAliasMap } from "./command/index.js";
 import { CommandManager } from "./command/manager.js";
 import { AppEventDetailMap, AppEventEmitOptions, AppEventListener } from "./event/index.js";
 import { AppHookMap, HookCallOptions, HookContext, HookFunction, HookUseOptions } from "./hook/index.js";
@@ -31,6 +31,7 @@ export declare class App extends CustomEventEmitter implements PluginContext {
     getPluginExposes(pluginName: string): any;
     hasPlugin(pluginName: string): boolean;
     registerCommand<T extends keyof AppCommandMap>(name: T, func: CommandFunction<AppCommandMap[T]>, options?: CommandOptions): void;
+    registerCommandAlias<T extends keyof AppCommandAliasMap>(name: T, targetName: AppCommandAliasMap[T], options?: CommandOptions): void;
     unregisterCommand(name: string): void;
     hasCommand(name: string): boolean;
     call<T extends keyof AppCommandMap>(name: T, ...args: Parameters<AppCommandMap[T]>): ReturnType<AppCommandMap[T]>;

package/dist/app.js

@@ -16,7 +16,7 @@ export class App extends CustomEventEmitter {
         this.valueManager = new ValueManager(this);
         this.pluginManager = new PluginManager(this);
         // 初始化命令
-        this.registerCommand("command.snapshot", () => this.commandManager.toSnapshot());
+        this.registerCommand("command.getData", () => this.commandManager.getData());
         this.registerCommand("get", (e, name) => this.getValue(name));
         this.registerCommand("set", (e, name, value) => this.setValue(name, value));
     }
@@ -66,6 +66,9 @@ export class App extends CustomEventEmitter {
     registerCommand(name, func, options) {
         this.commandManager.register(name, func, options);
     }
+    registerCommandAlias(name, targetName, options) {
+        this.commandManager.registerAlias(name, targetName, options);
+    }
     unregisterCommand(name) {
         this.commandManager.unregister(name);
     }

package/dist/command/manager.d.ts

@@ -7,16 +7,20 @@ export declare class CommandManager {
     constructor(app: App);
     /** 注册命令 */
     register(name: string, call: CommandFunction<any>, options?: CommandOptions): void;
+    /** 注册命令别名 */
+    registerAlias(name: string, targetName: string, options?: CommandOptions): void;
     /** 注销命令 */
     unregister(name: string): void;
     /** 调用命令 */
     call(name: string, ...args: any[]): any;
     /** 调用命令(可配置) */
     callWithOptions(name: string, options: CommandCallOptions, ...args: any[]): any;
+    /** 从命令别名调用命令 */
+    private _callAliasWithOptions;
     /** 检测命令是否存在 */
     has(name: string): boolean;
     /** 获取数据 */
-    toSnapshot(): {
+    getData(): {
         name: string;
         pluginName: string | undefined;
     }[];

package/dist/command/manager.js

@@ -12,6 +12,12 @@ export class CommandManager {
         this.list.set(name, { call, pluginName });
         this.app.emit("command:register", { name });
     }
+    /** 注册命令别名 */
+    registerAlias(name, targetName, options) {
+        const { pluginName } = options || {};
+        this.list.set(name, { targetName, pluginName });
+        this.app.emit("command:register", { name });
+    }
     /** 注销命令 */
     unregister(name) {
         this.list.delete(name);
@@ -26,12 +32,38 @@ export class CommandManager {
         const command = this.list.get(name);
         if (!command) {
             throw appError("command:call_unexist", {
-                message: `命令不存在: ${name}`,
+                message: `命令不存在[${name}]`,
                 target: `command/${name}`,
             });
         }
         else {
-            return command.call({ source: options.source, client: options.client }, ...args);
+            const { call } = command;
+            if (!call) {
+                return this._callAliasWithOptions(name, command.targetName, options, ...args);
+            }
+            else {
+                return call({ source: options.source, client: options.client }, ...args);
+            }
+        }
+    }
+    /** 从命令别名调用命令 */
+    _callAliasWithOptions(name, targetName, options, ...args) {
+        const tcommand = this.list.get(targetName);
+        if (!tcommand) {
+            throw appError("command:alias_unexist", {
+                message: `命令别名[${name}]指向的命令不存在[${targetName}]`,
+                target: `command/${name}>${targetName}`,
+            });
+        }
+        else {
+            const { call } = tcommand;
+            if (!call) {
+                throw appError("command:alias_target_uncallable", {
+                    message: `命令别名[${name}]不可指向其他命令别名[${targetName}]`,
+                    target: `command/${name}>${targetName}>${tcommand.targetName}`,
+                });
+            }
+            return call({ source: options.source, client: options.client }, ...args);
         }
     }
     /** 检测命令是否存在 */
@@ -39,7 +71,7 @@ export class CommandManager {
         return this.list.has(name);
     }
     /** 获取数据 */
-    toSnapshot() {
+    getData() {
         return [...this.list].map(([name, { pluginName }]) => ({
             name,
             pluginName,

package/dist/command/types.d.ts

@@ -19,27 +19,36 @@ export interface CommandItem {
     call: CommandFunction<any>;
     pluginName?: string;
 }
+export interface CommandAliasItem {
+    call?: undefined;
+    targetName: string;
+    pluginName?: string;
+}
+/** 命令函数类型表 */
 export interface AppCommandMap {
     get: <T extends keyof AppValueMap>(name: T) => AppValueMap[T];
     set: <T extends keyof AppValueMap>(name: T, value: AppValueMap[T]) => boolean;
-    /** 获取注册值快照 */
-    "value.snapshot": () => {
+    /** 获取注册值数据 */
+    "value.getData": () => {
         name: string;
         value: any;
     }[];
-    /** 获取命令快照 */
-    "command.snapshot": () => {
+    /** 获取命令数据 */
+    "command.getData": () => {
         name: string;
     }[];
-    /** 获取插件快照 */
-    "plugin.snapshot": () => {
+    /** 获取插件数据 */
+    "plugin.getData": () => {
         pluginName: string;
     }[];
-    /** 获取hook快照 */
-    "hook.snapshot": () => {
+    /** 获取hook数据 */
+    "hook.getData": () => {
         name: string;
         list: {
             pluginName?: string;
         }[];
     }[];
 }
+/** 命令别名映射 */
+export interface AppCommandAliasMap {
+}

package/dist/error/index.d.ts

@@ -2,8 +2,8 @@ export * from "./types.js";
 export interface AppError extends Error {
     /** 错误发生信息 */
     cause: {
-        /** 错误id */
-        id: string;
+        /** 错误代码 */
+        code: string;
         /** 错误目标对象 */
         target?: string;
         /** 错误原因 */
@@ -21,4 +21,4 @@ export interface AppErrorOptions {
     errorConstructor?: ErrorConstructor;
     [key: string]: unknown;
 }
-export declare function appError(id: string, { message, target, reason, errorConstructor }: AppErrorOptions): Error;
+export declare function appError(code: string, { message, target, reason, errorConstructor }: AppErrorOptions): AppError;

package/dist/error/index.js

@@ -1,8 +1,8 @@
 export * from "./types.js";
-export function appError(id, { message, target, reason, errorConstructor = Error }) {
+export function appError(code, { message, target, reason, errorConstructor = Error }) {
     return new errorConstructor(message, {
         cause: {
-            id,
+            code,
             target,
             reason,
         },

package/dist/hook/manager.d.ts

@@ -13,7 +13,7 @@ export declare class HookManager {
     call(name: string, ctx: any): Promise<any>;
     /** 同步调用钩子函数 */
     callSync(name: string, ctx: any): any;
-    toSnapshot(): {
+    getData(): {
         name: string;
         list: {
             pluginName?: string;

package/dist/hook/manager.js

@@ -5,7 +5,7 @@ export class HookManager {
     app;
     constructor(app) {
         this.app = app;
-        app.registerCommand("hook.snapshot", () => this.toSnapshot());
+        app.registerCommand("hook.getData", () => this.getData());
     }
     /** 挂载钩子函数 */
     use(name, call, options) {
@@ -64,7 +64,7 @@ export class HookManager {
         }
         return ctx;
     }
-    toSnapshot() {
+    getData() {
         return [...this.list].map(([name, fnList]) => ({
             name,
             list: fnList.map(({ pluginName }) => ({ pluginName })),

package/dist/live/room.d.ts

@@ -6,11 +6,12 @@ import { UserInfo } from "./messageInfo.js";
 export declare abstract class LiveRoom extends CustomEventEmitter implements LiveRoomData {
     constructor();
     get valid(): true;
-    get serviceId(): string;
+    get pending(): false;
+    get service(): string;
     /** 平台 */
     abstract readonly platform: string;
     /** api服务 */
-    readonly service: string;
+    readonly serviceName: string;
     /** 房间id */
     abstract readonly id: string | number;
     /** 房间详情 */
@@ -60,11 +61,15 @@ export declare abstract class LiveRoom extends CustomEventEmitter implements Liv
 /** 无效房间 */
 export declare class InvalidLiveRoom implements LiveRoomData {
     get valid(): false;
-    get serviceId(): string;
-    constructor(serviceId: string, id: string | number);
+    get service(): string;
+    constructor(service: string, id: string | number, { pending, error }?: {
+        pending?: boolean | undefined;
+        error?: null | undefined;
+    });
     readonly platform: string;
     readonly id: string | number;
-    readonly service: string;
+    readonly serviceName: string;
+    pending: boolean;
     detail: LiveRoomDetailInfo;
     stats?: LiveRoomStatsInfo;
     anchor: UserInfo;
@@ -73,6 +78,10 @@ export declare class InvalidLiveRoom implements LiveRoomData {
     connectionStatus: LiveConnectionStatus;
     openStatus: LiveRoomOpenStatus;
     liveId?: string;
+    error: {
+        code: string;
+        message: string;
+    } | null;
     get opened(): boolean;
     available: boolean;
     /** 生成房间数据 */
@@ -90,14 +99,16 @@ export interface LiveRoom {
 export interface LiveRoomData {
     /** 房间有效性 */
     valid: boolean;
+    /** 房间待定状态 */
+    pending: boolean;
     /** 平台id */
     platform: string;
     /** API服务 */
-    service: string;
+    serviceName: string;
     /** 房间id */
     id: number | string;
     /** API服务id */
-    serviceId: string;
+    service: string;
     /** 房间key */
     key: string;
     /** 基本信息 */
@@ -120,6 +131,11 @@ export interface LiveRoomData {
     opened: boolean;
     /** 房间是否可用 */
     available: boolean;
+    /** 错误信息 */
+    error?: {
+        code: string;
+        message: string;
+    } | null;
 }
 /** 房间展示信息 */
 export interface LiveRoomDetailInfo {
@@ -179,6 +195,8 @@ export declare const LiveRoomOpenStatus: {
     readonly opened: 2;
 };
 export type LiveRoomOpenStatus = EnumValue<typeof LiveRoomOpenStatus>;
+export declare const LiveRoomValidStatus: {};
+export type LiveRoomValidStatus = EnumValue<typeof LiveRoomValidStatus>;
 export interface LiveRoomEventMap {
     /**  */
     status: {

package/dist/live/room.js

@@ -7,11 +7,16 @@ export class LiveRoom extends CustomEventEmitter {
     get valid() {
         return true;
     }
-    get serviceId() {
-        return this.service ? `${this.platform}.${this.service}` : this.platform;
+    get pending() {
+        return false;
+    }
+    get service() {
+        return this.serviceName
+            ? `${this.platform}.${this.serviceName}`
+            : this.platform;
     }
     /** api服务 */
-    service = "";
+    serviceName = "";
     /** 统计信息 */
     stats;
     /** 直播状态 */
@@ -81,8 +86,9 @@ export class LiveRoom extends CustomEventEmitter {
     toData() {
         return {
             valid: this.valid,
+            pending: this.pending,
             platform: this.platform,
-            service: this.service,
+            serviceName: this.serviceName,
             id: this.id,
             detail: this.detail,
             stats: this.stats,
@@ -95,11 +101,11 @@ export class LiveRoom extends CustomEventEmitter {
             available: this.available,
             connectionStatus: this.connectionStatus,
             key: this.key,
-            serviceId: this.serviceId,
+            service: this.service,
         };
     }
     get key() {
-        return `${this.serviceId}:${this.id}`;
+        return `${this.service}:${this.id}`;
     }
 }
 /** 无效房间 */
@@ -107,18 +113,23 @@ export class InvalidLiveRoom {
     get valid() {
         return false;
     }
-    get serviceId() {
-        return this.service ? `${this.platform}.${this.service}` : this.platform;
+    get service() {
+        return this.serviceName
+            ? `${this.platform}.${this.serviceName}`
+            : this.platform;
     }
-    constructor(serviceId, id) {
-        const [platform, ...serviceIdArr] = serviceId.split(".");
+    constructor(service, id, { pending = false, error = null } = {}) {
+        const [platform, ...serviceIdArr] = service.split(".");
         this.platform = platform;
         this.id = id;
-        this.service = serviceIdArr.join(".");
+        this.serviceName = serviceIdArr.join(".");
+        this.pending = pending;
+        this.error = error;
     }
     platform;
     id;
-    service;
+    serviceName;
+    pending;
     detail = {};
     stats;
     anchor = { name: "", id: 0 };
@@ -127,6 +138,7 @@ export class InvalidLiveRoom {
     connectionStatus = LiveConnectionStatus.off;
     openStatus = 0;
     liveId;
+    error;
     get opened() {
         return this.openStatus == 2;
     }
@@ -135,8 +147,9 @@ export class InvalidLiveRoom {
     toData() {
         return {
             valid: this.valid,
+            pending: this.pending,
             platform: this.platform,
-            service: this.service,
+            serviceName: this.serviceName,
             id: this.id,
             detail: this.detail,
             stats: this.stats,
@@ -148,12 +161,12 @@ export class InvalidLiveRoom {
             opened: this.opened,
             available: this.available,
             connectionStatus: this.connectionStatus,
-            serviceId: this.serviceId,
+            service: this.service,
             key: this.key,
         };
     }
     get key() {
-        return `${this.serviceId}:${this.id}`;
+        return `${this.service}:${this.id}`;
     }
 }
 /** 直播间状态 */
@@ -191,3 +204,4 @@ export const LiveRoomOpenStatus = {
     /** 已开启 */
     opened: 2,
 };
+export const LiveRoomValidStatus = {};

package/dist/plugin/context/CommonPluginContext.d.ts

@@ -1,5 +1,5 @@
 import { App } from "../../app.js";
-import type { CommandOptions, CommandCallOptions, CommandFunction, AppCommandMap } from "../../command/index.js";
+import type { CommandOptions, CommandCallOptions, CommandFunction, AppCommandMap, AppCommandAliasMap } from "../../command/index.js";
 import { AppEventListener, AppEventEmitOptions, AppEventDetailMap } from "../../event/index.js";
 import { HookUseOptions, HookCallOptions, AppHookMap, HookFunction, HookContext } from "../../hook/index.js";
 import { AppValueMap, ValueContext, ValueOptions } from "../../value/index.js";
@@ -23,6 +23,7 @@ export declare class CommonPluginContext implements PluginContext {
     registerValue<K extends keyof AppValueMap>(name: K, options: ValueOptions<AppValueMap[K]>): ValueContext<AppValueMap[K]>;
     unregisterValue(name: string): void;
     registerCommand<T extends keyof AppCommandMap>(name: T, func: CommandFunction<AppCommandMap[T]>, options?: CommandOptions): void;
+    registerCommandAlias<T extends keyof AppCommandAliasMap>(name: T, targetName: AppCommandAliasMap[T], options?: CommandOptions): void;
     unregisterCommand(name: string): void;
     hasCommand(name: string): boolean;
     on<K extends keyof AppEventDetailMap>(type: K, listener: AppEventListener<AppEventDetailMap[K]>): void;

package/dist/plugin/context/CommonPluginContext.js

@@ -78,6 +78,10 @@ export class CommonPluginContext {
         this.#app.registerCommand(name, func, options);
         this.#registered.commands.add(name);
     }
+    registerCommandAlias(name, targetName, options) {
+        this.#app.registerCommandAlias(name, targetName, options);
+        this.#registered.commands.add(name);
+    }
     unregisterCommand(name) {
         this.#app.unregisterCommand(name);
         this.#registered.commands.delete(name);

package/dist/plugin/manager.d.ts

@@ -22,7 +22,7 @@ export declare class PluginManager {
     whenRegister(pluginName: string, callback: WhenRegisterCallback): void;
     /** 取消插件已注册时的执行回调 */
     cancelWhenRegister(pluginName: string, callback: WhenRegisterCallback): void;
-    toSnapshot(): {
+    getData(): {
         pluginName: string;
     }[];
 }

package/dist/plugin/manager.js

@@ -8,22 +8,20 @@ export class PluginManager {
     app;
     constructor(app) {
         this.app = app;
-        app.registerCommand("plugin.snapshot", bindCommand(this.toSnapshot, this));
+        app.registerCommand("plugin.getData", bindCommand(this.getData, this));
     }
     registerSync(pluginConstructor, options = {}, { context, unremovable = false, accessApp = false, pluginType = "", } = {}) {
         const pluginName = pluginConstructor.pluginName;
         const role = pluginConstructor.role || "";
         if (!pluginName) {
             throw appError("plugin:register_id_missing", {
-                message: "插件注册失败",
-                reason: "插件缺少pluginName字段",
+                message: "插件注册失败: 插件缺少pluginName字段",
                 target: "plugin/#unnamed",
             });
         }
         if (this.list.has(pluginName)) {
             throw appError("plugin:register_id_duplicate", {
-                message: `插件注册失败: ${pluginName}`,
-                reason: "已存在相同id的插件",
+                message: `插件注册失败[${pluginName}]: 已存在相同id的插件`,
                 target: `plugin/${pluginName}`,
             });
         }
@@ -33,8 +31,7 @@ export class PluginManager {
             const ctx = this.app.callHookSync("plugin.register", registerCtx);
             if (ctx.defaultPrevented)
                 throw appError("plugin:register_hook_prevented", {
-                    message: `插件注册失败: ${pluginName}`,
-                    reason: "插件注册被钩子函数阻止",
+                    message: `插件注册失败${pluginName}: 插件注册被钩子函数阻止`,
                     target: `plugin/${pluginName}`,
                 });
             // 执行插件函数
@@ -84,15 +81,13 @@ export class PluginManager {
         const role = pluginConstructor.role || "";
         if (!pluginName) {
             throw appError("plugin:register_id_missing", {
-                message: "插件注册失败",
-                reason: "插件缺少pluginName字段",
+                message: "插件注册失败: 插件缺少pluginName字段",
                 target: "plugin/#unnamed",
             });
         }
         if (this.list.has(pluginName)) {
             throw appError("plugin:register_id_duplicate", {
-                message: `插件注册失败: ${pluginName}`,
-                reason: "已存在相同id的插件",
+                message: `插件注册失败[${pluginName}]: 已存在相同id的插件`,
                 target: `plugin/${pluginName}`,
             });
         }
@@ -103,8 +98,7 @@ export class PluginManager {
             .then(async (ctx) => {
             if (ctx.defaultPrevented)
                 throw appError("plugin:register_hook_prevented", {
-                    message: `插件注册失败: ${pluginName}`,
-                    reason: "插件注册被钩子函数阻止",
+                    message: `插件注册失败${pluginName}: 插件注册被钩子函数阻止`,
                     target: `plugin/${pluginName}`,
                 });
             // 执行插件函数
@@ -153,8 +147,7 @@ export class PluginManager {
         // 检测插件是否存在
         if (!pluginData) {
             throw appError("plugin:unregister_unexist", {
-                message: `插件移除失败: ${pluginName}`,
-                reason: "插件不存在",
+                message: `插件移除失败[${pluginName}]: 插件不存在`,
                 target: `plugin/${pluginName}`,
             });
         }
@@ -162,8 +155,7 @@ export class PluginManager {
             const { plugin, context, unremovable, role } = pluginData;
             if (unremovable) {
                 throw appError("plugin:unregister_unremovable", {
-                    message: `插件移除失败: ${pluginName}`,
-                    reason: "不可移除的插件",
+                    message: `插件移除失败[${pluginName}]: 该插件已配置为不可移除`,
                     target: `plugin/${pluginName}`,
                 });
             }
@@ -231,7 +223,7 @@ export class PluginManager {
             callbackMap.delete(callback);
         }
     }
-    toSnapshot() {
+    getData() {
         return [...this.list.keys()].map((n) => ({ pluginName: n }));
     }
 }

package/dist/plugin/types.d.ts

@@ -1,5 +1,5 @@
 import { App } from "../app.js";
-import { CommandOptions, CommandCallOptions, AppCommandMap, CommandFunction } from "../command/index.js";
+import { CommandOptions, CommandCallOptions, AppCommandMap, CommandFunction, AppCommandAliasMap } from "../command/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";
@@ -88,9 +88,11 @@ export interface PluginContext {
     hasPlugin(pluginName: string): boolean;
     /** 注册指令 */
     registerCommand<T extends keyof AppCommandMap>(name: T, func: CommandFunction<AppCommandMap[T]>, options?: CommandOptions): void;
+    /** 注册指令别名，别名指令通常只作为手动输入指令的简写，不应在代码中直接使用 */
+    registerCommandAlias<T extends keyof AppCommandAliasMap>(name: T, targetName: AppCommandAliasMap[T], options?: CommandOptions): void;
     /** 注销指令 */
     unregisterCommand(name: string): void;
-    /** 检测值是否存在 */
+    /** 检测指令是否存在 */
     hasCommand(name: string): boolean;
     /** 调用指令 */
     call<T extends keyof AppCommandMap>(name: T, ...args: Parameters<AppCommandMap[T]>): ReturnType<AppCommandMap[T]>;

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

@@ -1,8 +1,9 @@
-import { BasePlugin, LivePlatformInfo } from "../../index.js";
+import { BasePlugin, LivePlatformInfo, PluginContext } from "../../index.js";
 interface PluginExposes {
     register(name: string, info: LivePlatformInfo, signal: AbortSignal): void;
     get(name: string): LivePlatformInfo | undefined;
-    toSnapshot(): {
+    info(name: string): LivePlatformInfo | undefined;
+    getData(): {
         name: string;
     }[];
 }
@@ -19,8 +20,12 @@ declare module "../../index.js" {
             name: string;
         };
     }
+    interface AppCommandAliasMap {
+        platform: "platform.info";
+    }
     interface AppCommandMap {
-        "platform.snapshot": () => {
+        "platform.info": (name: string) => LivePlatformInfo | undefined;
+        "platform.getData": () => {
             name: string;
             info: LivePlatformInfo;
         }[];
@@ -35,14 +40,17 @@ declare module "../../index.js" {
 export declare class Platform extends BasePlugin {
     static pluginName: string;
     private list;
+    init(ctx: PluginContext): void;
     /** 注册直播平台信息 */
     register(name: string, info: LivePlatformInfo, signal?: AbortSignal): void;
     /** 解除注册直播平台信息 */
     unregister(name: string): void;
-    /** 获取直播平台信息 */
+    /** 直接获取直播平台信息 */
     get(name: string): LivePlatformInfo | undefined;
+    /** 获取直播平台信息 */
+    info(name: string): LivePlatformInfo | undefined;
     expose(): PluginExposes;
-    toSnapshot(): {
+    getData(): {
         name: string;
         info: LivePlatformInfo;
     }[];

package/dist/plugins/platform/index.js

@@ -1,7 +1,13 @@
+import { bindCommand } from "../../utils/index.js";
 import { appError, BasePlugin } from "../../index.js";
 export class Platform extends BasePlugin {
     static pluginName = "platform";
     list = new Map();
+    init(ctx) {
+        ctx.registerCommand("platform.getData", this.getData.bind(this));
+        ctx.registerCommand("platform.info", bindCommand(this.info, this));
+        ctx.registerCommandAlias("platform", "platform.info");
+    }
     /** 注册直播平台信息 */
     register(name, info, signal) {
         if (this.list.has(name)) {
@@ -13,7 +19,7 @@ export class Platform extends BasePlugin {
         if (signal) {
             signal.addEventListener("abort", () => {
                 this.unregister(name);
-            }, { once: true });
+            }, { once: true, signal: this.ctx.signal });
         }
     }
     /** 解除注册直播平台信息 */
@@ -25,20 +31,25 @@ export class Platform extends BasePlugin {
         }
         this.list.delete(name);
     }
-    /** 获取直播平台信息 */
+    /** 直接获取直播平台信息 */
     get(name) {
         return this.list.get(name);
     }
+    /** 获取直播平台信息 */
+    info(name) {
+        return structuredClone(this.list.get(name));
+    }
     expose() {
         return {
             register: (name, info, signal) => {
                 this.register(name, info, signal);
             },
             get: (name) => this.get(name),
-            toSnapshot: () => this.toSnapshot(),
+            info: (name) => this.info(name),
+            getData: () => this.getData(),
         };
     }
-    toSnapshot() {
+    getData() {
         return [...this.list].map(([name, info]) => ({ name, info }));
     }
 }

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

@@ -3,6 +3,9 @@ import { LiveRoom, LiveRoomDetailInfo, LiveRoomData, LiveRoomStatsInfo, LiveRoom
 import { BasePlugin } from "../../plugin/index.js";
 import { PluginContext } from "../../plugin/types.js";
 export interface RoomCreateOptions {
+    /** 允许立即添加房间，如果不能立即添加，则先添加待定状态的房间，以免房间添加顺序混乱或重复执行 */
+    allowPending?: boolean;
+    /** 允许在创建房间失败后，设置为无效房间 */
     allowInvalidRoom?: boolean;
     open?: boolean;
     [option: string]: any;
@@ -10,27 +13,41 @@ export interface RoomCreateOptions {
 interface PluginExposes {
     add(platform: string, id: number, options?: boolean | RoomCreateOptions): Promise<void>;
     remove(key: string): void;
-    get(key: string): LiveRoom | InvalidLiveRoom | undefined;
-    has(key: string): boolean;
-    data(key: string): LiveRoomData | undefined;
-    update(key: string): void;
+    move: (key: string, position: number) => void;
     open(key: string): void;
     close(key: string): void;
+    has(key: string): boolean;
+    info(key: string): LiveRoomData | null;
+    update(key: string): void;
+    validate: (key: string, options: RoomCreateOptions) => void;
+    invalidate: (key: string) => void;
+    getData(): LiveRoomData[];
+    get(key: string): LiveRoom | InvalidLiveRoom | undefined;
     getList(): (LiveRoom | InvalidLiveRoom)[];
 }
 declare module "../../index.js" {
+    interface AppCommandAliasMap {
+        add: "room.add";
+        remove: "room.remove";
+        move: "room.move";
+        open: "room.open";
+        close: "room.close";
+        update: "room.update";
+        room: "room.info";
+    }
     interface AppCommandMap {
-        add: (platform: string, id: number, options?: boolean | RoomCreateOptions) => void;
-        remove: (key: string) => void;
-        move: (key: string, position: number) => void;
-        open: (key: string) => void;
-        close: (key: string) => void;
-        update: (key: string) => void;
-        "room.snapshot": () => LiveRoomData[];
+        "room.add": (platform: string, id: number, options?: boolean | RoomCreateOptions) => void;
+        "room.remove": (key: string) => void;
+        "room.move": (key: string, position: number) => void;
+        "room.open": (key: string) => void;
+        "room.close": (key: string) => void;
+        "room.update": (key: string) => void;
+        "room.info": (key: string) => LiveRoomData | null;
         "room.validate": (key: string, options: RoomCreateOptions) => void;
         "room.invalidate": (key: string) => void;
+        "room.getData": () => LiveRoomData[];
         [name: `${string}.room.create`]: (id: string | number, options: RoomCreateOptions) => LiveRoom | Promise<LiveRoom>;
-        [name: `${string}.room.data`]: (id: string | number) => LiveRoomData | Promise<LiveRoomData>;
+        [name: `${string}.room.info`]: (id: string | number) => LiveRoomData | Promise<LiveRoomData>;
     }
     interface AppEventDetailMap {
         "live:message": {
@@ -76,6 +93,15 @@ declare module "../../index.js" {
             key: string;
             room: LiveRoomData;
         };
+        "room:replace": {
+            key: string;
+            room: LiveRoomData;
+        };
+        "room:changeKey": {
+            oldKey: string;
+            newKey: string;
+            room: LiveRoomData;
+        };
         "room:open": {
             key: string;
             room: LiveRoomData;
@@ -111,7 +137,7 @@ declare module "../../index.js" {
             message: LiveMessage.All;
         };
         "room.create": {
-            serviceId: string;
+            service: string;
             id: string | number;
             options: RoomCreateOptions;
         };
@@ -139,9 +165,9 @@ export declare class Room extends BasePlugin {
     /** 绑定房间事件监听 */
     private bindEvent;
     /** 添加房间 */
-    add(serviceId: string, id: number, options?: boolean | RoomCreateOptions): Promise<void>;
+    add(service: string, id: number, options?: boolean | RoomCreateOptions): Promise<void>;
     /** 创建房间实例 */
-    create(serviceId: string, id: number | string, options?: RoomCreateOptions): Promise<LiveRoom | InvalidLiveRoom>;
+    create(service: string, id: number | string, options?: RoomCreateOptions): Promise<LiveRoom | InvalidLiveRoom>;
     /** 移除并销毁房间 */
     remove(key: string): void;
     /** 使无效房间生效 */
@@ -152,7 +178,7 @@ export declare class Room extends BasePlugin {
     get(key: string): LiveRoom | InvalidLiveRoom | undefined;
     has(key: string): boolean;
     /** 获取房间信息 */
-    data(key: string): LiveRoomData | undefined;
+    info(key: string): LiveRoomData | null;
     /** 更新房间信息 */
     update(key: string): void;
     /** 获取房间key列表 */
@@ -165,7 +191,9 @@ export declare class Room extends BasePlugin {
     close(key: string): void;
     /** 更改某个房间的顺序 */
     move(key: string, position: number): void;
-    /** 获取快照 */
-    toSnapshot(): LiveRoomData[];
+    /** 在不更改列表排序的情况下更改某个房间的key，目前仅用于处理输入房间key与返回房间key不一致的特殊情况，不提供指令，通常情况下请勿使用该方法 */
+    changeKey(oldKey: string, newKey: string): void;
+    /** 获取当前数据 */
+    getData(): LiveRoomData[];
 }
 export default Room;

package/dist/plugins/room/index.js

@@ -10,26 +10,38 @@ export class Room extends BasePlugin {
      */
     symbolAbortController = Symbol("room.abortController");
     init(ctx) {
-        ctx.registerCommand("add", bindCommand(this.add, this));
-        ctx.registerCommand("remove", bindCommand(this.remove, this));
-        ctx.registerCommand("open", bindCommand(this.open, this));
-        ctx.registerCommand("close", bindCommand(this.close, this));
-        ctx.registerCommand("update", bindCommand(this.update, this));
-        ctx.registerCommand("move", bindCommand(this.move, this));
-        ctx.registerCommand("room.snapshot", bindCommand(this.toSnapshot, this));
+        ctx.registerCommand("room.add", bindCommand(this.add, this));
+        ctx.registerCommand("room.remove", bindCommand(this.remove, this));
+        ctx.registerCommand("room.move", bindCommand(this.move, this));
+        ctx.registerCommand("room.open", bindCommand(this.open, this));
+        ctx.registerCommand("room.close", bindCommand(this.close, this));
+        ctx.registerCommand("room.update", bindCommand(this.update, this));
+        ctx.registerCommand("room.info", bindCommand(this.info, this));
         ctx.registerCommand("room.validate", bindCommand(this.validate, this));
         ctx.registerCommand("room.invalidate", bindCommand(this.invalidate, this));
+        ctx.registerCommand("room.getData", bindCommand(this.getData, this));
+        ctx.registerCommandAlias("add", "room.add");
+        ctx.registerCommandAlias("remove", "room.remove");
+        ctx.registerCommandAlias("move", "room.move");
+        ctx.registerCommandAlias("open", "room.open");
+        ctx.registerCommandAlias("close", "room.close");
+        ctx.registerCommandAlias("update", "room.update");
+        ctx.registerCommandAlias("room", "room.info");
     }
     expose() {
         return {
             add: this.add.bind(this),
             remove: this.remove.bind(this),
-            get: this.get.bind(this),
-            has: this.has.bind(this),
-            data: this.data.bind(this),
-            update: this.update.bind(this),
+            move: this.move.bind(this),
             open: this.open.bind(this),
             close: this.close.bind(this),
+            has: this.has.bind(this),
+            update: this.update.bind(this),
+            info: this.info.bind(this),
+            validate: this.validate.bind(this),
+            invalidate: this.invalidate.bind(this),
+            getData: this.getData.bind(this),
+            get: this.get.bind(this),
             getList: this.getList.bind(this),
         };
     }
@@ -139,39 +151,102 @@ export class Room extends BasePlugin {
         });
     }
     /** 添加房间 */
-    async add(serviceId, id, options) {
+    async add(service, id, options) {
         const opt = typeof options == "boolean" ? { open: options } : options || {};
-        const room = await this.create(serviceId, id, opt);
-        this.attach(room);
+        if (opt.allowPending) {
+            const promiseRoom = this.create(service, id, opt);
+            await Promise.race([promiseRoom, 0]).then(async (result) => {
+                if (result === 0) {
+                    // pending: 房间尚未创建完毕
+                    // 先添加一个待定状态的房间，以免房间添加顺序混乱或重复执行
+                    const pendingRoom = new InvalidLiveRoom(service, id);
+                    this.attach(pendingRoom);
+                    // 等待房间创建完毕后，再用真正的房间实例替换掉待定房间
+                    const room = await promiseRoom.catch((e) => {
+                        // 如果创建房间失败且不返回无效房间，则直接移除待定房间，并抛出错误
+                        this.detach(pendingRoom.key);
+                        throw e;
+                    });
+                    // 如果房间key与待定房间key不一致，则更改房间key（通常是因为输入的房间key与实际返回的房间key不一致的特殊情况），并触发 changeKey 事件
+                    if (pendingRoom.key != room.key) {
+                        // 更改房间数据以匹配实际返回的房间key
+                        pendingRoom.platform = room.platform;
+                        pendingRoom.id = room.id;
+                        // 更改列表中的房间key
+                        this.changeKey(pendingRoom.key, room.key);
+                    }
+                    // 用真正的房间实例替换掉待定房间
+                    this.map.set(pendingRoom.key, room);
+                    if (room.valid) {
+                        this.bindEvent(room);
+                        if (opt.open) {
+                            room.open();
+                        }
+                        // 如果房间有效，则触发 validate 事件
+                        this.ctx.emit("room:validate", {
+                            key: room.key,
+                            room: room.toData(),
+                        });
+                    }
+                    else {
+                        // 如果房间无效，则触发 invalidate 事件
+                        this.ctx.emit("room:invalidate", {
+                            key: room.key,
+                            room: room.toData(),
+                        });
+                    }
+                }
+                else {
+                    // fulfilled: 房间已经立即创建完毕
+                    this.attach(result, opt.open);
+                }
+            });
+        }
+        else {
+            const room = await this.create(service, id, opt);
+            this.attach(room, opt.open);
+        }
     }
     /** 创建房间实例 */
-    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) {
-            throw appError("room:create_hook_prevented", {
-                message: `无法创建房间监听实例[${serviceId}:${id}]：房间添加被钩子函数阻止`,
-                target: `room/${serviceId}:${id}`,
+    async create(service, id, options = {}) {
+        const ctx = { service, id, options };
+        try {
+            const res = await this.ctx
+                .callHook("room.create", ctx)
+                .catch((reason) => {
+                throw appError("room:create_hook_error", {
+                    message: `无法创建房间监听实例[${service}:${id}]: 调用钩子函数出错`,
+                    target: `room/${service}:${id}`,
+                });
             });
+            if (res.defaultPrevented) {
+                throw appError("room:create_hook_prevented", {
+                    message: `无法创建房间监听实例[${service}:${id}]: 房间添加被钩子函数阻止`,
+                    target: `room/${service}:${id}`,
+                });
+            }
+        }
+        catch (e) {
+            if (options.allowInvalidRoom) {
+                return new InvalidLiveRoom(service, id);
+            }
+            else {
+                throw e;
+            }
         }
         let room;
         try {
-            room = await this.ctx.call(`${serviceId}.room.create`, id, options);
+            room = await this.ctx.call(`${service}.room.create`, id, options);
         }
         catch (e) {
             if (options.allowInvalidRoom) {
-                room = new InvalidLiveRoom(serviceId, id);
+                room = new InvalidLiveRoom(service, id);
             }
             else {
                 throw appError("room:create_fail", {
-                    message: `创建房间监听实例失败[${serviceId}:${id}]`,
+                    message: `创建房间监听实例失败[${service}:${id}]`,
                     reason: e,
-                    target: `room/${serviceId}:${id}`,
+                    target: `room/${service}:${id}`,
                 });
             }
         }
@@ -208,8 +283,8 @@ export class Room extends BasePlugin {
                 target: `room/${key}`,
             });
         }
-        const { serviceId, id } = invalidRoom;
-        const room = await this.create(serviceId, id, {
+        const { service, id } = invalidRoom;
+        const room = await this.create(service, id, {
             ...options,
             allowInvalidRoom: false,
         });
@@ -236,8 +311,8 @@ export class Room extends BasePlugin {
             });
         }
         // 用无效房间替换掉原房间
-        const { serviceId, id } = room;
-        const invalidRoom = new InvalidLiveRoom(serviceId, id);
+        const { service, id } = room;
+        const invalidRoom = new InvalidLiveRoom(service, id);
         this.map.set(key, invalidRoom);
         // 移除插件实例对原房间的所有监听
         room[this.symbolAbortController]?.abort();
@@ -262,9 +337,9 @@ export class Room extends BasePlugin {
         return this.map.has(key);
     }
     /** 获取房间信息 */
-    data(key) {
+    info(key) {
         let room = this.map.get(key);
-        return room ? room.toData() : undefined;
+        return room?.toData() || null;
     }
     /** 更新房间信息 */
     update(key) {
@@ -328,8 +403,27 @@ export class Room extends BasePlugin {
         this.map = new Map(arr);
         this.ctx.emit("room:move", { key, position });
     }
-    /** 获取快照 */
-    toSnapshot() {
+    /** 在不更改列表排序的情况下更改某个房间的key，目前仅用于处理输入房间key与返回房间key不一致的特殊情况，不提供指令，通常情况下请勿使用该方法 */
+    changeKey(oldKey, newKey) {
+        const arr = [...this.map];
+        const index = arr.findIndex(([k]) => k == oldKey);
+        if (index == -1) {
+            throw appError("room:changekey_unexist", {
+                message: "要更改key的房间不存在",
+                target: `room/${oldKey}`,
+            });
+        }
+        let room = arr[index][1];
+        arr[index][0] = newKey;
+        this.map = new Map(arr);
+        this.ctx.emit("room:changeKey", {
+            oldKey,
+            newKey,
+            room: room.toData(),
+        });
+    }
+    /** 获取当前数据 */
+    getData() {
         return this.getList().map((room) => room.toData());
     }
 }

package/dist/value/manager.d.ts

@@ -20,7 +20,7 @@ export declare class ValueManager {
     watch(name: string, listener: (value: any) => void): void;
     unwatch(name: string, listener: (value: any) => void): void;
     /** 获取注册的所有值 */
-    toSnapshot(): {
+    getData(): {
         name: string;
         value: string;
     }[];

package/dist/value/manager.js

@@ -5,7 +5,7 @@ export class ValueManager {
     app;
     constructor(app) {
         this.app = app;
-        app.registerCommand("value.snapshot", bindCommand(this.toSnapshot, this));
+        app.registerCommand("value.getData", bindCommand(this.getData, this));
     }
     /** 注册值 */
     register(name, { get, set, pluginName }) {
@@ -61,7 +61,7 @@ export class ValueManager {
         this.app.off(`change:${name}`, listener);
     }
     /** 获取注册的所有值 */
-    toSnapshot() {
+    getData() {
         console.log(this);
         return [...this.list].map(([name, config]) => ({
             name,

package/package.json

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