floating-live 0.16.0-alpha.9 → 0.16.0-beta.0

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

@@ -3,8 +3,8 @@ import type { CommandOptions, CommandCallOptions, CommandFunction, AppCommandMap
 import { AppError, ErrorOptions } from "../../error";
 import { AppEventListener, AppEventEmitOptions, AppEventDetailMap } from "../../event";
 import { HookUseOptions, HookCallOptions, AppHookMap, HookFunction, HookContext } from "../../hook";
-import { AppValueMap, ValueOptions } from "../../value";
-import type { PluginContext, PluginConstructor, PluginInitOptions, AppPluginExposesMap } from "../types";
+import { AppValueMap, ValueContext, ValueOptions } from "../../value";
+import type { PluginContext, PluginConstructor, PluginInitOptions, AppPluginExposesMap, PluginItem } from "../types";
 export declare class CommonPluginContext implements PluginContext {
     #private;
     get safe(): boolean;
@@ -18,15 +18,16 @@ export declare class CommonPluginContext implements PluginContext {
      */
     throw(err: AppError): void;
     error(id: string, options: ErrorOptions): AppError;
-    register(plugin: PluginConstructor, options?: PluginInitOptions): void;
+    register<P extends PluginItem>(plugin: PluginConstructor<P>, options?: PluginInitOptions): Promise<P>;
     unregister(pluginName: string): void;
     getPluginExposes<K extends keyof AppPluginExposesMap>(pluginName: K): AppPluginExposesMap[K];
     whenRegister(pluginName: string, callback: (exposes: any) => (() => void) | void): void;
     hasPlugin(pluginName: string): boolean;
-    registerValue<K extends keyof AppValueMap>(name: K, options: ValueOptions<AppValueMap[K]>): void;
+    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;
     unregisterCommand(name: string): void;
+    hasCommand(name: string): boolean;
     on<K extends keyof AppEventDetailMap>(type: K, listener: AppEventListener<AppEventDetailMap[K]>): void;
     once<K extends keyof AppEventDetailMap>(type: K, listener: AppEventListener<AppEventDetailMap[K]>): void;
     off<K extends keyof AppEventDetailMap>(type: K, listener: AppEventListener<AppEventDetailMap[K]>): void;
@@ -39,7 +40,8 @@ export declare class CommonPluginContext implements PluginContext {
     callHookSync<T extends keyof AppHookMap>(name: T, ctx: AppHookMap[T], options?: HookCallOptions): HookContext<AppHookMap[T]>;
     watch<K extends keyof AppValueMap>(name: K, watcher: (value: AppValueMap[K]) => void): void;
     unwatch<K extends keyof AppValueMap>(name: K, watcher: (value: AppValueMap[K]) => void): void;
-    getValue<K extends keyof AppValueMap>(name: K): undefined;
+    hasValue<K extends keyof AppValueMap>(name: K): boolean;
+    getValue<K extends keyof AppValueMap>(name: K): AppValueMap[K];
     setValue<K extends keyof AppValueMap>(name: K, value: AppValueMap[K]): void;
     destroy(): void;
     get signal(): AbortSignal;

package/dist/plugin/context/CommonPluginContext.js

@@ -60,11 +60,12 @@ export class CommonPluginContext {
     }
     register(plugin, options) {
         try {
-            __classPrivateFieldGet(this, _CommonPluginContext_app, "f").register(plugin, options);
+            const p = __classPrivateFieldGet(this, _CommonPluginContext_app, "f").register(plugin, options);
             __classPrivateFieldGet(this, _CommonPluginContext_registered, "f").plugins.add(plugin.name);
+            return p;
         }
         catch (err) {
-            this.throw(err);
+            throw this.throw(err);
         }
     }
     unregister(pluginName) {
@@ -107,11 +108,12 @@ export class CommonPluginContext {
     }
     registerValue(name, options) {
         try {
-            __classPrivateFieldGet(this, _CommonPluginContext_app, "f").registerValue(name, options);
+            const ctx = __classPrivateFieldGet(this, _CommonPluginContext_app, "f").registerValue(name, options);
             __classPrivateFieldGet(this, _CommonPluginContext_registered, "f").values.add(name);
+            return ctx;
         }
         catch (err) {
-            this.throw(err);
+            throw this.throw(err);
         }
     }
     unregisterValue(name) {
@@ -141,6 +143,14 @@ export class CommonPluginContext {
             this.throw(err);
         }
     }
+    hasCommand(name) {
+        try {
+            return __classPrivateFieldGet(this, _CommonPluginContext_app, "f").hasCommand(name);
+        }
+        catch (err) {
+            throw this.throw(err);
+        }
+    }
     on(type, listener) {
         try {
             __classPrivateFieldGet(this, _CommonPluginContext_app, "f").on(type, listener);
@@ -236,7 +246,7 @@ export class CommonPluginContext {
             __classPrivateFieldGet(this, _CommonPluginContext_app, "f").watch(name, watcher);
         }
         catch (err) {
-            this.throw(err);
+            throw this.throw(err);
         }
     }
     unwatch(name, watcher) {
@@ -244,7 +254,15 @@ export class CommonPluginContext {
             __classPrivateFieldGet(this, _CommonPluginContext_app, "f").unwatch(name, watcher);
         }
         catch (err) {
-            this.throw(err);
+            throw this.throw(err);
+        }
+    }
+    hasValue(name) {
+        try {
+            return __classPrivateFieldGet(this, _CommonPluginContext_app, "f").hasValue(name);
+        }
+        catch (err) {
+            throw this.throw(err);
         }
     }
     getValue(name) {
@@ -252,15 +270,15 @@ export class CommonPluginContext {
             return __classPrivateFieldGet(this, _CommonPluginContext_app, "f").getValue(name);
         }
         catch (err) {
-            this.throw(err);
+            throw this.throw(err);
         }
     }
     setValue(name, value) {
         try {
-            __classPrivateFieldGet(this, _CommonPluginContext_app, "f").setValue(name, value);
+            return __classPrivateFieldGet(this, _CommonPluginContext_app, "f").setValue(name, value);
         }
         catch (err) {
-            this.throw(err);
+            throw this.throw(err);
         }
     }
     destroy() {

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

@@ -0,0 +1,8 @@
+import { App } from "../..";
+import { CommonPluginContext } from "./CommonPluginContext";
+/** 核心插件，具有对程序的访问权限 */
+export declare class CorePluginContext extends CommonPluginContext {
+    #private;
+    constructor(app: App, pluginName: string);
+    get app(): App;
+}

package/dist/plugin/context/CorePluginContext.js

@@ -0,0 +1,25 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _CorePluginContext_app;
+import { CommonPluginContext } from "./CommonPluginContext";
+/** 核心插件，具有对程序的访问权限 */
+export class CorePluginContext extends CommonPluginContext {
+    constructor(app, pluginName) {
+        super(app, pluginName);
+        _CorePluginContext_app.set(this, void 0);
+        __classPrivateFieldSet(this, _CorePluginContext_app, app, "f");
+    }
+    get app() {
+        return __classPrivateFieldGet(this, _CorePluginContext_app, "f");
+    }
+}
+_CorePluginContext_app = new WeakMap();

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

@@ -2,7 +2,7 @@ import { App } from "../../app";
 import { AppCommandMap, CommandCallOptions, CommandFunction, CommandOptions } from "../../command";
 import { AppEventDetailMap, AppEventEmitOptions } from "../../event";
 import { AppHookMap, HookCallOptions, HookContext, HookFunction, HookUseOptions } from "../../hook";
-import { PluginConstructor, PluginInitOptions } from "../types";
+import { PluginConstructor, PluginItem, PluginInitOptions } from "../types";
 import { CommonPluginContext } from "./CommonPluginContext";
 export interface PluginPermissions {
     "plugin.register"?: boolean;
@@ -22,7 +22,7 @@ export declare class SafePluginContext extends CommonPluginContext {
         permissions: PluginPermissions;
     });
     private throwNotPermitted;
-    register(plugin: PluginConstructor, options?: PluginInitOptions): void;
+    register<P extends PluginItem>(plugin: PluginConstructor<P>, options?: PluginInitOptions): Promise<P>;
     unregister(pluginName: string): void;
     emit<K extends keyof AppEventDetailMap>(type: K, detail: AppEventDetailMap[K], options?: AppEventEmitOptions & EventInit): void;
     call<T extends keyof AppCommandMap>(name: T, ...args: Parameters<AppCommandMap[T]>): ReturnType<AppCommandMap[T]>;

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,25 +1,19 @@
 import type { App } from "../app";
-import { AppError, ErrorOptions } from "../error";
-import { PluginItem, PluginConstructor, PluginContext } from "./types";
-export interface PluginErrorOptions extends ErrorOptions {
-    pluginName: string;
-}
-export declare class PluginError extends AppError {
-    pluginName: string;
-    constructor(id: string, options: PluginErrorOptions);
-}
+import { PluginItem, PluginConstructor, PluginContext, PluginRegisterOptions } from "./types";
 export interface PluginData<T> {
     plugin: PluginItem;
     context: PluginContext;
     exposes?: T;
+    core?: boolean;
 }
 export declare class PluginManager {
     /** 插件列表 */
     private list;
     protected readonly app: App;
     constructor(app: App);
+    registerSync<P extends PluginItem>(pluginConstructor: PluginConstructor<P>, options?: Record<string, any>, { context, core }?: PluginRegisterOptions): P;
     /** 注册插件 */
-    register(pluginConstructor: PluginConstructor, options?: Record<string, any>): Promise<PluginItem | undefined>;
+    register<P extends PluginItem>(pluginConstructor: PluginConstructor<P>, options?: Record<string, any>, { context, core }?: PluginRegisterOptions): Promise<P>;
     /** 移除插件 */
     unregister(pluginName: string): Promise<void>;
     /** 获取插件实例 */
@@ -27,5 +21,7 @@ export declare class PluginManager {
     has(pluginName: string): boolean;
     getPlugin(pluginName: string): PluginItem | undefined;
     getExposes(pluginName: string): any;
-    toData(): string[];
+    getSnapshot(): {
+        pluginName: string;
+    }[];
 }

package/dist/plugin/manager.js

@@ -1,56 +1,111 @@
 import { CommonPluginContext } from "./context/CommonPluginContext";
 import { AppError } from "../error";
-export class PluginError extends AppError {
-    constructor(id, options) {
-        super(id, options);
-        this.pluginName = options.pluginName;
-    }
-}
+import { CorePluginContext } from "./context/CorePluginContext";
+import { bindCommand } from "../utils";
 export class PluginManager {
     constructor(app) {
         /** 插件列表 */
         this.list = new Map();
         this.app = app;
+        app.registerCommand("plugin.snapshot", bindCommand(this.getSnapshot, this));
+    }
+    registerSync(pluginConstructor, options = {}, { context, core } = {}) {
+        const pluginName = pluginConstructor.pluginName;
+        if (!pluginName) {
+            throw new AppError("plugin:register_id_missing", {
+                message: "插件注册失败",
+                cause: "插件缺少pluginName字段",
+                target: "plugin/#unnamed",
+            });
+        }
+        if (this.list.has(pluginName)) {
+            throw new AppError("plugin:register_id_duplicate", {
+                message: `插件注册失败: ${pluginName}`,
+                cause: "已存在相同id的插件",
+                target: `plugin/${pluginName}`,
+            });
+        }
+        const registerCtx = { pluginName, options };
+        const pluginCtx = context || new CorePluginContext(this.app, pluginName);
+        try {
+            const ctx = this.app.callHookSync("plugin.register", registerCtx);
+            if (ctx.defaultPrevented)
+                throw new AppError("plugin:register_hook_prevented", {
+                    message: `插件注册失败: ${pluginName}`,
+                    cause: "插件注册被钩子函数阻止",
+                    target: `plugin/${pluginName}`,
+                });
+            // 执行插件函数
+            const plugin = new pluginConstructor(pluginCtx, registerCtx.options || {});
+            // 调用插件的init钩子
+            plugin.init?.(pluginCtx, registerCtx.options || {});
+            // 调用插件的expose钩子
+            const exposes = plugin.expose?.(pluginCtx);
+            this.list.set(pluginName, {
+                plugin,
+                context: pluginCtx,
+                exposes,
+                core,
+            });
+            this.app.emit("plugin:register", { pluginName });
+            return plugin;
+        }
+        catch (err) {
+            throw new AppError("plugin:register_fail", {
+                message: `插件注册失败: ${pluginName}`,
+                cause: err,
+                target: `plugin/${pluginName}`,
+            });
+        }
     }
     /** 注册插件 */
-    async register(pluginConstructor, options = {}) {
+    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 };
-        const pluginCtx = new CommonPluginContext(this.app, pluginName);
+        const pluginCtx = context || new CommonPluginContext(this.app, pluginName);
         return await this.app
             .callHook("plugin.register", registerCtx)
             .then(async (ctx) => {
             if (ctx.defaultPrevented)
-                return;
+                throw new AppError("plugin:register_hook_prevented", {
+                    message: `插件注册失败: ${pluginName}`,
+                    cause: "插件注册被钩子函数阻止",
+                    target: `plugin/${pluginName}`,
+                });
             // 执行插件函数
             const plugin = new pluginConstructor(pluginCtx, registerCtx.options || {});
             // 调用插件的init钩子
             await plugin.init?.(pluginCtx, registerCtx.options || {});
             // 调用插件的expose钩子
             const exposes = await plugin.expose?.(pluginCtx);
-            this.list.set(pluginName, { plugin, context: pluginCtx, exposes });
+            this.list.set(pluginName, {
+                plugin,
+                context: pluginCtx,
+                exposes,
+                core,
+            });
             this.app.emit("plugin:register", { pluginName });
             return plugin;
         })
             .catch((err) => {
-            throw new PluginError("plugin:register_fail", {
+            throw new AppError("plugin:register_fail", {
                 message: `插件注册失败: ${pluginName}`,
                 cause: err,
-                pluginName,
+                target: `plugin/${pluginName}`,
             });
         });
     }
@@ -59,14 +114,21 @@ 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 } = pluginData;
+            const { plugin, context, core } = pluginData;
+            if (core) {
+                throw new AppError("plugin:unregister_core", {
+                    message: `插件移除失败: ${pluginName}`,
+                    cause: "无法移除核心插件",
+                    target: `plugin/${pluginName}`,
+                });
+            }
             // 调用插件和上下文的destroy钩子
             plugin.destroy?.(context);
             context.destroy();
@@ -89,7 +151,7 @@ export class PluginManager {
     getExposes(pluginName) {
         return this.list.get(pluginName)?.exposes;
     }
-    toData() {
-        return [...this.list.keys()];
+    getSnapshot() {
+        return [...this.list.keys()].map((n) => ({ pluginName: n }));
     }
 }

package/dist/plugin/types.d.ts

@@ -1,25 +1,40 @@
+import { App } from "../app";
 import { CommandOptions, CommandCallOptions, AppCommandMap, CommandFunction } from "../command";
 import { AppError, ErrorOptions } from "../error";
 import { AppEventListener, AppEventEmitOptions, AppEventDetailMap } from "../event";
 import { AppHookMap, HookCallOptions, HookContext, HookFunction, HookUseOptions } from "../hook";
-import { AppValueMap, ValueOptions } from "../value";
+import { AppValueMap, ValueContext, ValueOptions } from "../value";
 /** 插件对象 */
 export interface PluginItem {
     pluginName: string;
+    /** 初始化插件 */
     init?(ctx: PluginContext, options?: Record<string, any>): void | Promise<void>;
+    /** 插件销毁 */
     destroy?(ctx: PluginContext): void | Promise<void>;
+    /** 插件暴露 */
     expose?(ctx: PluginContext): any;
 }
 /** 插件构造器 */
-export interface PluginConstructor {
+export interface PluginConstructor<P extends PluginItem> {
     pluginName: string;
-    new (ctx: PluginContext, options: any): PluginItem;
+    new (ctx: PluginContext, options: any): P;
 }
 /** 插件初始化选项 */
 export interface PluginInitOptions {
 }
+/** 插件注册选项 */
+export interface PluginRegisterOptions {
+    /** 提供的插件上下文 */
+    context?: PluginContext;
+    /** 核心插件，不可解除注册 */
+    core?: boolean;
+}
 /** 插件上下文 */
 export interface PluginContext {
+    /** 安全插件上下文 */
+    safe?: boolean;
+    /** App实例，仅在核心插件上下文提供 */
+    app?: App;
     /** 监听事件 */
     on<K extends keyof AppEventDetailMap>(type: K, listener: AppEventListener<AppEventDetailMap[K]>): void;
     /** 单次监听事件 */
@@ -30,10 +45,10 @@ 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(plugin: PluginConstructor, options?: PluginInitOptions): void;
+    register<P extends PluginItem>(plugin: PluginConstructor<P>, options?: PluginInitOptions): Promise<P>;
     /** 取消注册插件 */
     unregister(pluginName: string): void;
     /** 获取插件暴露对象 */
@@ -47,6 +62,8 @@ export interface PluginContext {
     registerCommand<T extends keyof AppCommandMap>(name: T, func: CommandFunction<AppCommandMap[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]>;
     /** 调用指令(可配置) */
@@ -60,13 +77,15 @@ export interface PluginContext {
     /** 调用同步钩子 */
     callHookSync<T extends keyof AppHookMap>(name: T, ctx: AppHookMap[T], options?: HookCallOptions): HookContext<AppHookMap[T]>;
     /** 注册值 */
-    registerValue<K extends keyof AppValueMap>(name: K, options: ValueOptions<AppValueMap[K]>): void;
+    registerValue<K extends keyof AppValueMap>(name: K, options: ValueOptions<AppValueMap[K]>): ValueContext<AppValueMap[K]>;
     /** 取消注册值 */
     unregisterValue(name: string): void;
     /** 监听值 */
     watch<K extends keyof AppValueMap>(name: K, watcher: (value: AppValueMap[K]) => void): void;
     /** 取消监听值 */
     unwatch<K extends keyof AppValueMap>(name: K, watcher: (value: AppValueMap[K]) => void): void;
+    /** 值是否存在 */
+    hasValue(name: string): boolean;
     /** 获取值 */
     getValue<K extends keyof AppValueMap>(name: K): AppValueMap[K];
     /** 设置值 */
@@ -77,3 +96,21 @@ export interface PluginContext {
 export interface AppPluginExposesMap {
     "": {};
 }
+export interface AppSnapshotMap {
+    plugin: {
+        pluginName: string;
+    }[];
+    value: {
+        name: string;
+        value: any;
+    }[];
+    command: {
+        name: string;
+    }[];
+    hook: {
+        name: string;
+        list: {
+            pluginName?: string;
+        }[];
+    }[];
+}

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

@@ -2,6 +2,17 @@ import { LiveMessage } from "../../live/message";
 import { LiveRoom, LiveRoomDetailInfo, LiveRoomData, LiveRoomStatsInfo, LiveRoomStatus } from "../../live/room";
 import { BasePlugin } from "../../plugin";
 import { PluginContext } from "../../plugin/types";
+interface PluginExposes {
+    add(platform: string, id: number, options?: boolean | Record<string, any>): void;
+    remove(key: string): void;
+    get(key: string): LiveRoom | undefined;
+    has(key: string): boolean;
+    data(key: string): LiveRoomData | undefined;
+    update(key: string): void;
+    open(key: string): void;
+    close(key: string): void;
+    getList(): LiveRoom[];
+}
 declare module "../.." {
     interface AppCommandMap {
         add: (platform: string, id: number, options?: boolean | Record<string, any>) => void;
@@ -83,14 +94,21 @@ declare module "../.." {
             options: Record<string, any>;
         };
     }
+    interface AppSnapshotMap {
+        room: LiveRoomData[];
+    }
+    interface AppPluginExposesMap {
+        room: PluginExposes;
+    }
 }
 export declare class Room extends BasePlugin {
     static pluginName: string;
     private map;
-    private symbolRoomEventHandlers;
-    constructor(ctx: PluginContext);
+    private symbolAbortController;
+    init(ctx: PluginContext): void;
+    expose(): PluginExposes;
     /** 添加房间监听实例 */
-    attachRoom(room: LiveRoom, open?: boolean): void;
+    attach(room: LiveRoom, open?: boolean): void;
     /** 添加房间 */
     add(platform: string, id: number, options?: boolean | Record<string, any>): Promise<void>;
     /** 移除房间 */
@@ -99,13 +117,13 @@ export declare class Room extends BasePlugin {
     get(key: string): LiveRoom | undefined;
     has(key: string): boolean;
     /** 获取房间信息 */
-    info(key: string): LiveRoomData | undefined;
+    data(key: string): LiveRoomData | undefined;
     /** 更新房间信息 */
     update(key: string): void;
     /** 获取房间key列表 */
-    get keys(): Array<string>;
+    get keys(): string[];
     /** 获取房间列表 */
-    getList(): Array<LiveRoom>;
+    getList(): LiveRoom[];
     /** 打开房间连接 */
     open(key: string): void;
     /** 关闭房间连接 */