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

package/dist/FloatingLive.d.ts

@@ -1,6 +1,24 @@
+import { LiveRoom } from ".";
 import { App } from "./app";
 import { Room } from "./plugins/room";
 export declare class FloatingLive extends App {
     room: Room;
     constructor();
+    /** 添加房间 */
+    add(platform: string, id: number, options?: boolean | Record<string, any>): Promise<void>;
+    /** 移除房间 */
+    remove(key: string): void;
+    /** 获取房间 */
+    get(key: string): LiveRoom | undefined;
+    has(key: string): boolean;
+    /** 获取房间信息 */
+    data(key: string): import("./live").LiveRoomData | undefined;
+    /** 更新房间信息 */
+    update(key: string): void;
+    /** 打开房间连接 */
+    open(key: string): void;
+    /** 关闭房间连接 */
+    close(key: string): void;
+    /** 获取房间列表 */
+    getList(): LiveRoom[];
 }

package/dist/FloatingLive.js

@@ -3,6 +3,41 @@ import { Room } from "./plugins/room";
 export class FloatingLive extends App {
     constructor() {
         super();
-        this.room = new Room(this);
+        this.room = this.registerSync(Room, { core: true });
+    }
+    /** 添加房间 */
+    add(platform, id, options) {
+        return this.room.add(platform, id, options);
+    }
+    /** 移除房间 */
+    remove(key) {
+        return this.room.remove(key);
+    }
+    /** 获取房间 */
+    get(key) {
+        return this.room.get(key);
+    }
+    has(key) {
+        return this.room.has(key);
+    }
+    /** 获取房间信息 */
+    data(key) {
+        return this.room.data(key);
+    }
+    /** 更新房间信息 */
+    update(key) {
+        return this.room.update(key);
+    }
+    /** 打开房间连接 */
+    open(key) {
+        return this.room.open(key);
+    }
+    /** 关闭房间连接 */
+    close(key) {
+        return this.room.close(key);
+    }
+    /** 获取房间列表 */
+    getList() {
+        return this.room.getList();
     }
 }

package/dist/app.d.ts

@@ -1,16 +1,20 @@
 import { CommandOptions, CommandCallOptions, AppCommandMap, CommandFunction } from "./command";
+import { CommandManager } from "./command/manager";
 import { AppError } from "./error";
 import { AppEventDetailMap, AppEventEmitOptions, AppEventListener } from "./event";
 import { AppHookMap, HookCallOptions, HookContext, HookFunction, HookUseOptions } from "./hook";
-import { AppPluginExposesMap, PluginContext, PluginInitOptions } from "./plugin";
+import { HookManager } from "./hook/manager";
+import { AppPluginExposesMap, PluginConstructor, PluginContext, PluginInitOptions, PluginItem } from "./plugin";
+import { PluginManager } from "./plugin/manager";
 import { CustomEventEmitter } from "./utils/EventEmitter";
 import { AppValueMap, ValueOptions } from "./value";
+import { ValueManager } from "./value/manager";
 export declare class App extends CustomEventEmitter implements PluginContext {
-    private hookManager;
-    private pluginManager;
-    private commandManager;
-    private valueManager;
-    private abortController;
+    protected hookManager: HookManager;
+    protected pluginManager: PluginManager;
+    protected commandManager: CommandManager;
+    protected valueManager: ValueManager;
+    protected abortController: AbortController;
     constructor();
     on<K extends keyof AppEventDetailMap>(type: K, listener: AppEventListener<AppEventDetailMap[K]>, signal?: AbortSignal): void;
     once<K extends keyof AppEventDetailMap>(type: K, listener: AppEventListener<AppEventDetailMap[K]>, signal?: AbortSignal): void;
@@ -20,7 +24,9 @@ export declare class App extends CustomEventEmitter implements PluginContext {
     throw(err?: Error): void;
     error(id: string, detail?: Record<string, any>): AppError;
     /** 注册插件 */
-    register(plugin: any, options?: PluginInitOptions): void;
+    register<P extends PluginItem>(plugin: PluginConstructor<P>, options?: PluginInitOptions): Promise<P>;
+    /** 同步注册插件 */
+    registerSync<P extends PluginItem>(plugin: PluginConstructor<P>, options?: PluginInitOptions): P;
     /** 取消注册插件 */
     unregister(pluginName: string): void;
     getPlugin(pluginName: string): void;
@@ -30,20 +36,22 @@ export declare class App extends CustomEventEmitter implements PluginContext {
     hasPlugin(pluginName: string): boolean;
     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]>;
     callWithOptions<T extends keyof AppCommandMap>(name: T, options: CommandCallOptions, ...args: Parameters<AppCommandMap[T]>): ReturnType<AppCommandMap[T]>;
     useHook<T extends keyof AppHookMap>(name: T, func: HookFunction<AppHookMap[T]>, options?: HookUseOptions): void;
     unuseHook<T extends keyof AppHookMap>(name: T, func: HookFunction<AppHookMap[T]>): void;
     callHook<T extends keyof AppHookMap>(name: T, ctx: AppHookMap[T], options?: HookCallOptions): Promise<HookContext<AppHookMap[T]>>;
     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]>): import("./value").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];
-    setValue(name: string, value: any): void;
+    setValue(name: string, value: any): boolean;
     destroy(): void;
     /** 拓展值 */
-    define(): void;
+    define(key: string, value: ((...args: any[]) => any) | PropertyDescriptor): void;
     get signal(): AbortSignal;
 }

package/dist/app.js

@@ -8,10 +8,13 @@ export class App extends CustomEventEmitter {
     constructor() {
         super();
         this.abortController = new AbortController();
-        this.hookManager = new HookManager(this);
-        this.pluginManager = new PluginManager(this);
         this.commandManager = new CommandManager(this);
+        this.hookManager = new HookManager(this);
         this.valueManager = new ValueManager(this);
+        this.pluginManager = new PluginManager(this);
+        // 初始化命令
+        this.registerCommand("get", (e, name) => this.getValue(name));
+        this.registerCommand("set", (e, name, value) => this.setValue(name, value));
     }
     on(type, listener, signal = this.signal) {
         super.on(type, listener, signal);
@@ -25,6 +28,7 @@ export class App extends CustomEventEmitter {
     emit(type, detail, options) {
         const { source, remote } = options || {};
         super.emit(type, { ...detail, source, remote }, options);
+        super.emit("event", { name: type, detail: { ...detail, source, remote } });
     }
     //--- 错误机制 ---//
     /** 发送错误 */
@@ -37,7 +41,11 @@ export class App extends CustomEventEmitter {
     //--- 插件机制 ---//
     /** 注册插件 */
     register(plugin, options) {
-        this.pluginManager.register(plugin, options);
+        return this.pluginManager.register(plugin, options);
+    }
+    /** 同步注册插件 */
+    registerSync(plugin, options) {
+        return this.pluginManager.registerSync(plugin, options);
     }
     /** 取消注册插件 */
     unregister(pluginName) {
@@ -70,7 +78,7 @@ export class App extends CustomEventEmitter {
         });
     }
     getPluginExposes(pluginName) {
-        this.pluginManager.getExposes(pluginName);
+        return this.pluginManager.getExposes(pluginName);
     }
     hasPlugin(pluginName) {
         return this.pluginManager.has(pluginName);
@@ -82,6 +90,9 @@ export class App extends CustomEventEmitter {
     unregisterCommand(name) {
         this.commandManager.unregister(name);
     }
+    hasCommand(name) {
+        return this.commandManager.has(name);
+    }
     call(name, ...args) {
         return this.commandManager.call(name, ...args);
     }
@@ -103,7 +114,7 @@ export class App extends CustomEventEmitter {
     }
     //--- 值机制 ---//
     registerValue(name, options) {
-        this.valueManager.register(name, options);
+        return this.valueManager.register(name, options);
     }
     unregisterValue(name) {
         this.valueManager.unregister(name);
@@ -114,18 +125,28 @@ export class App extends CustomEventEmitter {
     unwatch(name, watcher) {
         this.valueManager.unwatch(name, watcher);
     }
+    hasValue(name) {
+        return this.valueManager.has(name);
+    }
     getValue(name) {
         return this.valueManager.get(name);
     }
     setValue(name, value) {
-        this.valueManager.set(name, value);
+        return this.valueManager.set(name, value);
     }
     destroy() {
         this.abortController.abort();
     }
     //--- 其他 ---//
     /** 拓展值 */
-    define() { }
+    define(key, value) {
+        if (typeof value == "function") {
+            Object.defineProperty(this, key, { value });
+        }
+        else {
+            Object.defineProperty(this, key, value);
+        }
+    }
     get signal() {
         return this.abortController.signal;
     }

package/dist/command/manager.d.ts

@@ -16,7 +16,7 @@ export declare class CommandManager {
     /** 检测命令是否存在 */
     has(name: string): boolean;
     /** 获取数据 */
-    getData(): {
+    getSnapshot(): {
         name: string;
         pluginName: string | undefined;
     }[];

package/dist/command/manager.js

@@ -1,8 +1,10 @@
+import { AppError } from "../error";
 export class CommandManager {
     constructor(app) {
         /** 功能列表 */
         this.list = new Map();
         this.app = app;
+        app.registerCommand("command.snapshot", () => this.getSnapshot());
     }
     /** 注册命令 */
     register(name, call, options) {
@@ -23,10 +25,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);
@@ -37,7 +39,7 @@ export class CommandManager {
         return this.list.has(name);
     }
     /** 获取数据 */
-    getData() {
+    getSnapshot() {
         return [...this.list].map(([name, { pluginName }]) => ({
             name,
             pluginName,

package/dist/command/types.d.ts

@@ -22,4 +22,24 @@ export interface CommandItem {
 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": () => {
+        name: string;
+        value: any;
+    }[];
+    /** 获取命令快照 */
+    "command.snapshot": () => {
+        name: string;
+    }[];
+    /** 获取插件快照 */
+    "plugin.snapshot": () => {
+        pluginName: string;
+    }[];
+    /** 获取hook快照 */
+    "hook.snapshot": () => {
+        name: string;
+        list: {
+            pluginName?: string;
+        }[];
+    }[];
 }

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/event/types.d.ts

@@ -36,6 +36,13 @@ export interface AppEventDetailMap {
     "value:unregister": {
         name: string;
     };
+    event: {
+        name: string;
+        detail: AppEventDetail<any>;
+    };
+    error: {
+        error: Error;
+    };
     [name: `change:${string}`]: {
         value: 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;
@@ -21,5 +13,10 @@ export declare class HookManager {
     call(name: string, ctx: any): Promise<any>;
     /** 同步调用钩子函数 */
     callSync(name: string, ctx: any): any;
-    getData(): void[];
+    getSnapshot(): {
+        name: string;
+        list: {
+            pluginName?: string;
+        }[];
+    }[];
 }

package/dist/hook/manager.js

@@ -1,15 +1,10 @@
 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();
         this.pluginMap = new Map();
         this.app = app;
+        app.registerCommand("hook.snapshot", () => this.getSnapshot());
     }
     /** 挂载钩子函数 */
     use(name, call, options) {
@@ -20,10 +15,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 +26,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);
     }
     /** 调用钩子函数 */
@@ -70,10 +63,10 @@ export class HookManager {
         }
         return ctx;
     }
-    getData() {
-        const map = {};
-        return [...this.list].map(([name, fnList]) => {
-            map[name] = fnList.length;
-        });
+    getSnapshot() {
+        return [...this.list].map(([name, fnList]) => ({
+            name,
+            list: fnList.map(({ pluginName }) => ({ pluginName })),
+        }));
     }
 }

package/dist/live/room.d.ts

@@ -2,6 +2,7 @@ import { CustomEventEmitter } from "../utils/EventEmitter";
 import { EnumValue } from "../utils/types";
 import { LiveMessage } from "./message";
 import { UserInfo } from "./messageInfo";
+/** 直播间信息流监听类 */
 export declare abstract class LiveRoom extends CustomEventEmitter implements LiveRoomData {
     constructor();
     /** 平台 */
@@ -20,30 +21,39 @@ export declare abstract class LiveRoom extends CustomEventEmitter implements Liv
     timestamp: number;
     /** 当前直播id */
     liveId?: string;
-    /** 房间是否打开 */
-    opened: boolean;
-    /** 是否连接上房间 */
-    connection: LiveConnectionStatus;
-    /** 房间是否可用 */
-    abstract available: boolean;
+    /** 房间连接状态 */
+    connectionStatus: LiveConnectionStatus;
+    /** 房间开启状态 */
+    openStatus: LiveRoomOpenStatus;
+    get opened(): boolean;
+    available: boolean;
     /** 打开连接 */
     abstract open(): void;
     /** 关闭连接 */
     abstract close(): void;
-    /** 从服务器获取信息 */
-    abstract getInfo(): Promise<void>;
-    /** 销毁事件 */
-    protected onDestroy?(): void;
+    /** 重连 */
+    abstract reconnect?(): void;
+    /** 更新房间数据 */
+    abstract update(): Promise<LiveRoomData>;
+    /** 从服务器获取房间数据 */
+    abstract fetchData?(): Promise<LiveRoomData>;
+    /** 设置房间数据 */
+    abstract setData?(data: LiveRoomData): LiveRoomData;
     /** 销毁 */
     destroy(): void;
+    /** 销毁事件 */
+    protected onDestroy?: () => void;
+    /** 发送消息 */
     protected emitMessage(msg: LiveMessage.All): void;
     /** 发送源消息 */
     protected emitRaw(msg: any): void;
-    /** 获取数据 */
+    /** 生成房间数据 */
     toData(): LiveRoomData;
     get key(): string;
-    on<K extends keyof LiveRoomEventMap>(type: K, listener: (e: LiveRoomEventMap[K]) => void): void;
-    once<K extends keyof LiveRoomEventMap>(type: K, listener: (e: LiveRoomEventMap[K]) => void): void;
+}
+export interface LiveRoom {
+    on<K extends keyof LiveRoomEventMap>(type: K, listener: (e: LiveRoomEventMap[K]) => void, signal?: AbortSignal): void;
+    once<K extends keyof LiveRoomEventMap>(type: K, listener: (e: LiveRoomEventMap[K]) => void, signal?: AbortSignal): void;
     off<K extends keyof LiveRoomEventMap>(type: K, listener: (e: LiveRoomEventMap[K]) => void): void;
     emit<K extends keyof LiveRoomEventMap>(type: LiveRoomEventMap[K] extends Record<string, never> ? K : never): void;
     emit<K extends keyof LiveRoomEventMap>(type: K, detail: LiveRoomEventMap[K]): void;
@@ -68,12 +78,14 @@ export interface LiveRoomData {
     liveId?: string;
     /** 直播状态 */
     status: LiveRoomStatus;
-    /** 直播间是否可用 */
-    available: boolean;
-    /** 房间监听是否打开 */
-    opened: boolean;
     /** 房间连接状态 */
-    connection: LiveConnectionStatus;
+    connectionStatus: LiveConnectionStatus;
+    /** 房间监听状态 */
+    openStatus: LiveRoomOpenStatus;
+    /** 房间是否开启 */
+    opened: boolean;
+    /** 房间是否可用 */
+    available: boolean;
 }
 /** 房间展示信息 */
 export interface LiveRoomDetailInfo {
@@ -112,42 +124,72 @@ export type LiveRoomStatus = EnumValue<typeof LiveRoomStatus>;
 /** 直播间状态 */
 export declare const LiveConnectionStatus: {
     /** 未连接 */
-    off: number;
+    readonly off: 0;
     /** 连接中 */
-    connecting: number;
+    readonly connecting: 1;
     /** 连接到服务器 */
-    connected: number;
+    readonly connected: 2;
     /** 连接到房间 */
-    entered: number;
+    readonly entered: 3;
     /** 连接失败或断开 */
-    disconnected: number;
+    readonly disconnected: -1;
 };
 export type LiveConnectionStatus = EnumValue<typeof LiveConnectionStatus>;
+/** 直播间开启状态 */
+export declare const LiveRoomOpenStatus: {
+    /** 已关闭 */
+    readonly closed: 0;
+    /** 正在开启 */
+    readonly opening: 1;
+    /** 已开启 */
+    readonly opened: 2;
+};
+export type LiveRoomOpenStatus = EnumValue<typeof LiveRoomOpenStatus>;
 export interface LiveRoomEventMap {
+    /**  */
     status: {
         status: LiveRoomStatus;
         timestamp: number;
         liveId?: string | number;
     };
-    update: {};
+    /** 房间数据更新 */
+    update: {
+        room: LiveRoomData;
+    };
+    /** 细节改变 */
     detail: {
         detail: Partial<LiveRoomDetailInfo>;
     };
+    /** 统计信息改变 */
     stats: {
-        stats: LiveRoomStatsInfo;
+        stats: Partial<LiveRoomStatsInfo>;
     };
+    /** 消息 */
     message: {
         message: LiveMessage.All;
     };
+    /** 消息源数据 */
     raw: {
         platform: string;
         roomId: string | number;
         data: any;
     };
+    /** 初始化 */
+    init: {};
+    /** 正在连接 */
     connecting: {};
+    /** 连接到服务器 */
     connected: {};
+    /** 断开连接 */
     disconnect: {};
+    /** 连接到房间 */
     enter: {};
+    /** 连接超时 */
+    timeout: {
+        time: number;
+    };
+    /** 开启直播间连接 */
     open: {};
+    /** 关闭直播间连接 */
     close: {};
 }

package/dist/live/room.js

@@ -1,4 +1,5 @@
 import { CustomEventEmitter } from "../utils/EventEmitter";
+/** 直播间信息流监听类 */
 export class LiveRoom extends CustomEventEmitter {
     constructor() {
         super();
@@ -6,17 +7,21 @@ export class LiveRoom extends CustomEventEmitter {
         this.status = LiveRoomStatus.off;
         /** 时间戳 */
         this.timestamp = 0;
-        /** 房间是否打开 */
-        this.opened = false;
-        /** 是否连接上房间 */
-        this.connection = LiveConnectionStatus.off;
+        /** 房间连接状态 */
+        this.connectionStatus = LiveConnectionStatus.off;
+        /** 房间开启状态 */
+        this.openStatus = 0;
+        this.available = false;
+    }
+    get opened() {
+        return this.openStatus == 2;
     }
     /** 销毁 */
     destroy() {
         this.close();
         this.onDestroy?.();
     }
-    // 发送消息
+    /** 发送消息 */
     emitMessage(msg) {
         // 其他消息 => 先更改状态再发送消息
         // 直播结束消息 => 先发送消息再更改状态
@@ -56,7 +61,7 @@ export class LiveRoom extends CustomEventEmitter {
     emitRaw(msg) {
         this.emit("raw", { platform: this.platform, roomId: this.id, data: msg });
     }
-    /** 获取数据 */
+    /** 生成房间数据 */
     toData() {
         return {
             platform: this.platform,
@@ -67,28 +72,16 @@ export class LiveRoom extends CustomEventEmitter {
             timestamp: this.timestamp,
             status: this.status,
             liveId: this.liveId,
-            available: this.available,
+            openStatus: this.openStatus,
             opened: this.opened,
-            connection: this.connection,
+            available: this.available,
+            connectionStatus: this.connectionStatus,
             key: this.key,
         };
     }
     get key() {
         return `${this.platform}:${this.id}`;
     }
-    on(type, listener) {
-        super.on(type, listener);
-    }
-    once(type, listener) {
-        super.once(type, listener);
-        this.emit("connecting");
-    }
-    off(type, listener) {
-        super.off(type, listener);
-    }
-    emit(type, detail) {
-        super.emit(type, detail);
-    }
 }
 /** 直播间状态 */
 export const LiveRoomStatus = {
@@ -116,3 +109,12 @@ export const LiveConnectionStatus = {
     /** 连接失败或断开 */
     disconnected: -1,
 };
+/** 直播间开启状态 */
+export const LiveRoomOpenStatus = {
+    /** 已关闭 */
+    closed: 0,
+    /** 正在开启 */
+    opening: 1,
+    /** 已开启 */
+    opened: 2,
+};