floating-live 0.16.6 → 0.17.0-alpha.0

package/.yarnrc.yml

@@ -0,0 +1,6 @@
+approvedGitRepositories:
+  - "**"
+
+enableScripts: true
+
+nodeLinker: node-modules

package/LICENSE

@@ -1,9 +1,9 @@
-MIT License
-
-Copyright (c) 2023 Minteea
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
+MIT License
+
+Copyright (c) 2023 Minteea
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,36 +1,36 @@
-# Floating Live
-
-一个用于处理和保存直播弹幕的 Web 小工具，开箱即用。
-
-本体无弹幕获取功能，需要配合[floating-live-plugins](https://github.com/Minteea/floating-live-plugins)中的插件使用。
-
-目前插件库支持 bilibili 和 AcFun 的直播弹幕，不同平台的弹幕会转换为同一种格式便于保存。
-
-项目仍在开发中，功能尚未完善，目前除了记录保存直播弹幕外暂时没有别的用处啦，敬请期待。
-
-注意：当前项目未进入正式版本阶段，程序结构及导出数据结构可能随时改动，**非常不建议用于正式项目中**。
-
-GUI 版本：[Minteea/floating-live-gui](https://github.com/Minteea/floating-live-gui)
-
-## 使用方法
-
-### npm 安装
-
-```
-npm install floating-live
-```
-
-```javascript
-// 导入FloatingLive本体
-import { FloatingLive } from "floating-live";
-// 导入bilibili房间生成插件
-import bilibili from "@floating-live/bilibili";
-
-// 创建一个FloatingLive实例
-const live = new FloatingLive();
-// 注册插件
-live.plugin.register(bilibili);
-
-// 添加房间并自动打开
-live.room.add("bilibili", 6, true);
-```
+# Floating Live
+
+一个用于处理和保存直播弹幕的 Web 小工具，开箱即用。
+
+本体无弹幕获取功能，需要配合[floating-live-plugins](https://github.com/Minteea/floating-live-plugins)中的插件使用。
+
+目前插件库支持 bilibili 和 AcFun 的直播弹幕，不同平台的弹幕会转换为同一种格式便于保存。
+
+项目仍在开发中，功能尚未完善，目前除了记录保存直播弹幕外暂时没有别的用处啦，敬请期待。
+
+注意：当前项目未进入正式版本阶段，程序结构及导出数据结构可能随时改动，**非常不建议用于正式项目中**。
+
+GUI 版本：[Minteea/floating-live-gui](https://github.com/Minteea/floating-live-gui)
+
+## 使用方法
+
+### npm 安装
+
+```
+npm install floating-live
+```
+
+```javascript
+// 导入FloatingLive本体
+import { FloatingLive } from "floating-live";
+// 导入bilibili房间生成插件
+import bilibili from "@floating-live/bilibili";
+
+// 创建一个FloatingLive实例
+const live = new FloatingLive();
+// 注册插件
+live.plugin.register(bilibili);
+
+// 添加房间并自动打开
+live.room.add("bilibili", 6, true);
+```

package/dist/FloatingLive.js

@@ -4,8 +4,8 @@ import { Platform } from "./plugins/platform/index.js";
 export class FloatingLive extends App {
     constructor() {
         super();
-        this.room = this.registerSync(Room, { core: true });
-        this.platform = this.registerSync(Platform, { core: true });
+        this.room = this.registerSync(Room, {}, { unremovable: true, accessApp: true, pluginType: "core" });
+        this.platform = this.registerSync(Platform, {}, { unremovable: true, accessApp: true, pluginType: "core" });
     }
     /** 添加房间 */
     add(platform, id, options) {

package/dist/app.d.ts

@@ -4,8 +4,8 @@ import { AppError } from "./error/index.js";
 import { AppEventDetailMap, AppEventEmitOptions, AppEventListener } from "./event/index.js";
 import { AppHookMap, HookCallOptions, HookContext, HookFunction, HookUseOptions } from "./hook/index.js";
 import { HookManager } from "./hook/manager.js";
-import { AppPluginExposesMap, PluginConstructor, PluginContext, PluginInitOptions, PluginItem } from "./plugin/index.js";
-import { PluginManager } from "./plugin/manager.js";
+import { PluginConstructor, PluginContext, PluginInitOptions, PluginItem, PluginRegisterOptions } from "./plugin/index.js";
+import { PluginManager, WhenRegisterCallback } from "./plugin/manager.js";
 import { CustomEventEmitter } from "./utils/EventEmitter.js";
 import { AppValueMap, ValueOptions } from "./value/index.js";
 import { ValueManager } from "./value/manager.js";
@@ -24,14 +24,14 @@ export declare class App extends CustomEventEmitter implements PluginContext {
     throw(err?: Error): void;
     error(id: string, detail?: Record<string, any>): AppError;
     /** 注册插件 */
-    register<P extends PluginItem>(plugin: PluginConstructor<P>, options?: PluginInitOptions): Promise<P>;
+    register<P extends PluginItem>(plugin: PluginConstructor<P>, options?: PluginInitOptions, registerOptions?: PluginRegisterOptions): Promise<P>;
     /** 同步注册插件 */
-    registerSync<P extends PluginItem>(plugin: PluginConstructor<P>, options?: PluginInitOptions): P;
-    /** 取消注册插件 */
+    registerSync<P extends PluginItem>(plugin: PluginConstructor<P>, options?: PluginInitOptions, registerOptions?: PluginRegisterOptions): P;
+    /** 注销插件 */
     unregister(pluginName: string): void;
     getPlugin(pluginName: string): void;
-    whenRegister<K extends keyof AppPluginExposesMap>(pluginName: K, callback: (exposes: AppPluginExposesMap[K]) => (() => void) | void): void;
-    whenRegister(pluginName: string, callback: () => (() => void) | void): void;
+    whenRegister(pluginName: string, callback: WhenRegisterCallback): void;
+    cancelWhenRegister(pluginName: string, callback: WhenRegisterCallback): void;
     getPluginExposes(pluginName: string): any;
     hasPlugin(pluginName: string): boolean;
     registerCommand<T extends keyof AppCommandMap>(name: T, func: CommandFunction<AppCommandMap[T]>, options?: CommandOptions): void;
@@ -53,5 +53,6 @@ export declare class App extends CustomEventEmitter implements PluginContext {
     destroy(): void;
     /** 拓展值 */
     define(key: string, value: ((...args: any[]) => any) | PropertyDescriptor): void;
+    getApp(): App;
     get signal(): AbortSignal;
 }

package/dist/app.js

@@ -41,14 +41,14 @@ export class App extends CustomEventEmitter {
     }
     //--- 插件机制 ---//
     /** 注册插件 */
-    register(plugin, options) {
-        return this.pluginManager.register(plugin, options);
+    register(plugin, options, registerOptions) {
+        return this.pluginManager.register(plugin, options, registerOptions);
     }
     /** 同步注册插件 */
-    registerSync(plugin, options) {
-        return this.pluginManager.registerSync(plugin, options);
+    registerSync(plugin, options, registerOptions) {
+        return this.pluginManager.registerSync(plugin, options, registerOptions);
     }
-    /** 取消注册插件 */
+    /** 注销插件 */
     unregister(pluginName) {
         this.pluginManager.unregister(pluginName);
     }
@@ -56,27 +56,10 @@ export class App extends CustomEventEmitter {
         this.pluginManager.getPlugin(pluginName);
     }
     whenRegister(pluginName, callback) {
-        let registered = this.hasPlugin(pluginName);
-        let whenUnregistered;
-        if (registered) {
-            whenUnregistered = callback(this.getPluginExposes(pluginName));
-        }
-        this.on("plugin:register", ({ pluginName: name }) => {
-            if (pluginName == name) {
-                if (registered) {
-                    whenUnregistered?.();
-                }
-                whenUnregistered = callback(this.getPluginExposes(pluginName));
-                registered = true;
-            }
-        });
-        this.on("plugin:unregister", ({ pluginName: name }) => {
-            if (pluginName == name) {
-                whenUnregistered?.();
-                whenUnregistered = undefined;
-                registered = false;
-            }
-        });
+        return this.pluginManager.whenRegister(pluginName, callback);
+    }
+    cancelWhenRegister(pluginName, callback) {
+        return this.pluginManager.cancelWhenRegister(pluginName, callback);
     }
     getPluginExposes(pluginName) {
         return this.pluginManager.getExposes(pluginName);
@@ -148,6 +131,9 @@ export class App extends CustomEventEmitter {
             Object.defineProperty(this, key, value);
         }
     }
+    getApp() {
+        return this;
+    }
     get signal() {
         return this.abortController.signal;
     }

package/dist/command/manager.d.ts

@@ -7,7 +7,7 @@ export declare class CommandManager {
     constructor(app: App);
     /** 注册命令 */
     register(name: string, call: CommandFunction<any>, options?: CommandOptions): void;
-    /** 取消注册命令 */
+    /** 注销命令 */
     unregister(name: string): void;
     /** 调用命令 */
     call(name: string, ...args: any[]): any;

package/dist/command/manager.js

@@ -11,7 +11,7 @@ export class CommandManager {
         this.list.set(name, { call, pluginName });
         this.app.emit("command:register", { name });
     }
-    /** 取消注册命令 */
+    /** 注销命令 */
     unregister(name) {
         this.list.delete(name);
         this.app.emit("command:unregister", { name });

package/dist/live/room.d.ts

@@ -5,6 +5,7 @@ import { UserInfo } from "./messageInfo.js";
 /** 直播间信息流监听类 */
 export declare abstract class LiveRoom extends CustomEventEmitter implements LiveRoomData {
     constructor();
+    get valid(): boolean;
     /** 平台 */
     abstract readonly platform: string;
     /** 房间id */
@@ -60,6 +61,8 @@ export interface LiveRoom {
 }
 /** 房间数据 */
 export interface LiveRoomData {
+    /** 房间有效性 */
+    valid: boolean;
     /** 平台id */
     platform: string;
     /** 房间id */
@@ -193,3 +196,22 @@ export interface LiveRoomEventMap {
     /** 关闭直播间连接 */
     close: {};
 }
+export declare class InvalidLiveRoom implements LiveRoomData {
+    get valid(): false;
+    constructor(platform: string, id: string | number);
+    readonly platform: string;
+    readonly id: string | number;
+    detail: LiveRoomDetailInfo;
+    stats?: LiveRoomStatsInfo;
+    anchor: UserInfo;
+    status: LiveRoomStatus;
+    timestamp: number;
+    connectionStatus: LiveConnectionStatus;
+    openStatus: LiveRoomOpenStatus;
+    liveId?: string;
+    get opened(): boolean;
+    available: boolean;
+    /** 生成房间数据 */
+    toData(): LiveRoomData;
+    get key(): string;
+}

package/dist/live/room.js

@@ -13,6 +13,9 @@ export class LiveRoom extends CustomEventEmitter {
         this.openStatus = 0;
         this.available = false;
     }
+    get valid() {
+        return true;
+    }
     get opened() {
         return this.openStatus == 2;
     }
@@ -64,6 +67,7 @@ export class LiveRoom extends CustomEventEmitter {
     /** 生成房间数据 */
     toData() {
         return {
+            valid: this.valid,
             platform: this.platform,
             id: this.id,
             detail: this.detail,
@@ -118,3 +122,44 @@ export const LiveRoomOpenStatus = {
     /** 已开启 */
     opened: 2,
 };
+export class InvalidLiveRoom {
+    get valid() {
+        return false;
+    }
+    constructor(platform, id) {
+        this.detail = {};
+        this.anchor = { name: "", id: 0 };
+        this.status = LiveRoomStatus.off;
+        this.timestamp = 0;
+        this.connectionStatus = LiveConnectionStatus.off;
+        this.openStatus = 0;
+        this.available = false;
+        this.platform = platform;
+        this.id = id;
+    }
+    get opened() {
+        return this.openStatus == 2;
+    }
+    /** 生成房间数据 */
+    toData() {
+        return {
+            valid: this.valid,
+            platform: this.platform,
+            id: this.id,
+            detail: this.detail,
+            stats: this.stats,
+            anchor: this.anchor,
+            timestamp: this.timestamp,
+            status: this.status,
+            liveId: this.liveId,
+            openStatus: this.openStatus,
+            opened: this.opened,
+            available: this.available,
+            connectionStatus: this.connectionStatus,
+            key: this.key,
+        };
+    }
+    get key() {
+        return `${this.platform}:${this.id}`;
+    }
+}

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

@@ -4,14 +4,18 @@ import { AppError, ErrorOptions } from "../../error/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";
+import { WhenRegisterCallback } from "../manager.js";
 import type { PluginContext, PluginConstructor, PluginInitOptions, AppPluginExposesMap, PluginItem } from "../types.js";
 export declare class CommonPluginContext implements PluginContext {
     #private;
     get safe(): boolean;
+    getApp(): App | null;
     getRegisteredPlugins(): string[];
     /** 插件名称 */
     readonly pluginName: string;
-    constructor(app: App, pluginName: string);
+    constructor(app: App, pluginName: string, options?: {
+        accessApp?: boolean;
+    });
     /** 抛出错误
      *
      * 一般用于自身导致的错误，若非插件本身导致的错误，使用throw语句即可
@@ -21,7 +25,8 @@ export declare class CommonPluginContext implements PluginContext {
     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;
+    whenRegister(pluginName: string, callback: WhenRegisterCallback): void;
+    cancelWhenRegister(pluginName: string, callback: WhenRegisterCallback): void;
     hasPlugin(pluginName: string): boolean;
     registerValue<K extends keyof AppValueMap>(name: K, options: ValueOptions<AppValueMap[K]>): ValueContext<AppValueMap[K]>;
     unregisterValue(name: string): void;

package/dist/plugin/context/CommonPluginContext.js

@@ -9,7 +9,7 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     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 _CommonPluginContext_app, _CommonPluginContext_abortController, _CommonPluginContext_registered;
+var _CommonPluginContext_app, _CommonPluginContext_accessApp, _CommonPluginContext_abortController, _CommonPluginContext_registered, _CommonPluginContext_whenRegisterMap;
 import { AppError } from "../../error/index.js";
 class ListMap extends Map {
     addItem(key, value) {
@@ -29,12 +29,16 @@ export class CommonPluginContext {
     get safe() {
         return false;
     }
+    getApp() {
+        return __classPrivateFieldGet(this, _CommonPluginContext_accessApp, "f") ? __classPrivateFieldGet(this, _CommonPluginContext_app, "f") : null;
+    }
     getRegisteredPlugins() {
         return [...__classPrivateFieldGet(this, _CommonPluginContext_registered, "f").plugins];
     }
-    constructor(app, pluginName) {
+    constructor(app, pluginName, options) {
         /** 主程序，插件不可访问 */
         _CommonPluginContext_app.set(this, void 0);
+        _CommonPluginContext_accessApp.set(this, void 0);
         /** AbortController，插件不可访问 */
         _CommonPluginContext_abortController.set(this, new AbortController());
         _CommonPluginContext_registered.set(this, {
@@ -44,8 +48,10 @@ export class CommonPluginContext {
             hooks: new ListMap(),
             events: new ListMap(),
         });
+        _CommonPluginContext_whenRegisterMap.set(this, new ListMap());
         __classPrivateFieldSet(this, _CommonPluginContext_app, app, "f");
         this.pluginName = pluginName;
+        __classPrivateFieldSet(this, _CommonPluginContext_accessApp, options?.accessApp ?? false, "f");
     }
     /** 抛出错误
      *
@@ -81,27 +87,12 @@ export class CommonPluginContext {
         return __classPrivateFieldGet(this, _CommonPluginContext_app, "f").getPluginExposes(pluginName);
     }
     whenRegister(pluginName, callback) {
-        let registered = this.hasPlugin(pluginName);
-        let whenUnregistered;
-        if (registered) {
-            whenUnregistered = callback(this.getPluginExposes(pluginName));
-        }
-        this.on("plugin:register", ({ pluginName: name }) => {
-            if (pluginName == name) {
-                if (registered) {
-                    whenUnregistered?.();
-                }
-                whenUnregistered = callback(this.getPluginExposes(pluginName));
-                registered = true;
-            }
-        });
-        this.on("plugin:unregister", ({ pluginName: name }) => {
-            if (pluginName == name) {
-                whenUnregistered?.();
-                whenUnregistered = undefined;
-                registered = false;
-            }
-        });
+        __classPrivateFieldGet(this, _CommonPluginContext_app, "f").whenRegister(pluginName, callback);
+        __classPrivateFieldGet(this, _CommonPluginContext_whenRegisterMap, "f").addItem(pluginName, callback);
+    }
+    cancelWhenRegister(pluginName, callback) {
+        __classPrivateFieldGet(this, _CommonPluginContext_app, "f").cancelWhenRegister(pluginName, callback);
+        __classPrivateFieldGet(this, _CommonPluginContext_whenRegisterMap, "f").deleteItem(pluginName, callback);
     }
     hasPlugin(pluginName) {
         return __classPrivateFieldGet(this, _CommonPluginContext_app, "f").hasPlugin(pluginName);
@@ -282,6 +273,9 @@ export class CommonPluginContext {
         }
     }
     destroy() {
+        __classPrivateFieldGet(this, _CommonPluginContext_whenRegisterMap, "f").forEach((callbacks, pluginName) => {
+            callbacks.forEach((callback) => __classPrivateFieldGet(this, _CommonPluginContext_app, "f").cancelWhenRegister(pluginName, callback));
+        });
         const { plugins, values, hooks, commands } = __classPrivateFieldGet(this, _CommonPluginContext_registered, "f");
         plugins.forEach((pluginName) => __classPrivateFieldGet(this, _CommonPluginContext_app, "f").unregister(pluginName));
         hooks.forEach((hookList, name) => hookList.forEach((hookFunc) => __classPrivateFieldGet(this, _CommonPluginContext_app, "f").off(name, hookFunc)));
@@ -293,4 +287,4 @@ export class CommonPluginContext {
         return __classPrivateFieldGet(this, _CommonPluginContext_abortController, "f").signal;
     }
 }
-_CommonPluginContext_app = new WeakMap(), _CommonPluginContext_abortController = new WeakMap(), _CommonPluginContext_registered = new WeakMap();
+_CommonPluginContext_app = new WeakMap(), _CommonPluginContext_accessApp = new WeakMap(), _CommonPluginContext_abortController = new WeakMap(), _CommonPluginContext_registered = new WeakMap(), _CommonPluginContext_whenRegisterMap = new WeakMap();

package/dist/plugin/manager.d.ts

@@ -4,16 +4,26 @@ export interface PluginData<T> {
     plugin: PluginItem;
     context: PluginContext;
     exposes?: T;
-    core?: boolean;
+    unremovable: boolean;
+    /** 可访问App实例 */
+    accessApp: boolean;
+    /** 插件类型 */
+    pluginType: "core" | "framework" | "";
 }
+/** 插件注册监听回调
+ * 当目标插件已经注册时，回调会被立即调用，否则将在目标插件注册时调用。
+ * 回调可以返回一个函数作为注销时的回调。
+ */
+export type WhenRegisterCallback = () => (() => void) | void;
 export declare class PluginManager {
     /** 插件列表 */
     private list;
+    private whenRegisterMap;
     protected readonly app: App;
     constructor(app: App);
-    registerSync<P extends PluginItem>(pluginConstructor: PluginConstructor<P>, options?: Record<string, any>, { context, core }?: PluginRegisterOptions): P;
+    registerSync<P extends PluginItem>(pluginConstructor: PluginConstructor<P>, options?: Record<string, any>, { context, core, unremovable, accessApp, pluginType }?: PluginRegisterOptions): P;
     /** 注册插件 */
-    register<P extends PluginItem>(pluginConstructor: PluginConstructor<P>, options?: Record<string, any>, { context, core }?: PluginRegisterOptions): Promise<P>;
+    register<P extends PluginItem>(pluginConstructor: PluginConstructor<P>, options?: Record<string, any>, { context, core, unremovable, accessApp, pluginType }?: PluginRegisterOptions): Promise<P>;
     /** 移除插件 */
     unregister(pluginName: string): Promise<void>;
     /** 获取插件实例 */
@@ -21,6 +31,12 @@ export declare class PluginManager {
     has(pluginName: string): boolean;
     getPlugin(pluginName: string): PluginItem | undefined;
     getExposes(pluginName: string): any;
+    /** 在插件已注册时执行回调
+     * param skipError 在安装来源插件调用该方法且目标插件已安装时，是否跳过回调函数抛出的错误（默认为false）
+     */
+    whenRegister(pluginName: string, callback: WhenRegisterCallback): void;
+    /** 取消插件已注册时的执行回调 */
+    cancelWhenRegister(pluginName: string, callback: WhenRegisterCallback): void;
     toSnapshot(): {
         pluginName: string;
     }[];

package/dist/plugin/manager.js

@@ -1,15 +1,15 @@
 import { CommonPluginContext } from "./context/CommonPluginContext.js";
 import { AppError } from "../error/index.js";
-import { CorePluginContext } from "./context/CorePluginContext.js";
 import { bindCommand } from "../utils/index.js";
 export class PluginManager {
     constructor(app) {
         /** 插件列表 */
         this.list = new Map();
+        this.whenRegisterMap = new Map();
         this.app = app;
         app.registerCommand("plugin.snapshot", bindCommand(this.toSnapshot, this));
     }
-    registerSync(pluginConstructor, options = {}, { context, core } = {}) {
+    registerSync(pluginConstructor, options = {}, { context, core, unremovable, accessApp, pluginType } = {}) {
         const pluginName = pluginConstructor.pluginName;
         if (!pluginName) {
             throw new AppError("plugin:register_id_missing", {
@@ -26,7 +26,7 @@ export class PluginManager {
             });
         }
         const registerCtx = { pluginName, options };
-        const pluginCtx = context || new CorePluginContext(this.app, pluginName);
+        const pluginCtx = context || new CommonPluginContext(this.app, pluginName);
         try {
             const ctx = this.app.callHookSync("plugin.register", registerCtx);
             if (ctx.defaultPrevented)
@@ -41,13 +41,24 @@ export class PluginManager {
             plugin.init?.(pluginCtx, registerCtx.options || {});
             // 调用插件的expose钩子
             const exposes = plugin.expose?.(pluginCtx);
+            // 将插件数据注册到列表中
             this.list.set(pluginName, {
                 plugin,
                 context: pluginCtx,
                 exposes,
-                core,
+                unremovable: core || unremovable || false,
+                accessApp: core || accessApp || false,
+                pluginType: core ? "core" : pluginType || "",
             });
             this.app.emit("plugin:register", { pluginName });
+            // 如果有whenRegister的回调，调用回调函数
+            const callbackMap = this.whenRegisterMap.get(pluginName);
+            if (callbackMap) {
+                for (const [callback] of callbackMap.entries()) {
+                    const whenUnregistered = callback();
+                    callbackMap.set(callback, whenUnregistered || null);
+                }
+            }
             return plugin;
         }
         catch (err) {
@@ -59,7 +70,7 @@ export class PluginManager {
         }
     }
     /** 注册插件 */
-    async register(pluginConstructor, options = {}, { context, core } = {}) {
+    async register(pluginConstructor, options = {}, { context, core, unremovable, accessApp, pluginType } = {}) {
         const pluginName = pluginConstructor.pluginName;
         if (!pluginName) {
             throw new AppError("plugin:register_id_missing", {
@@ -96,9 +107,19 @@ export class PluginManager {
                 plugin,
                 context: pluginCtx,
                 exposes,
-                core,
+                unremovable: core || unremovable || false,
+                accessApp: core || accessApp || false,
+                pluginType: core ? "core" : pluginType || "",
             });
             this.app.emit("plugin:register", { pluginName });
+            // 如果有whenRegister的回调，调用回调函数
+            const callbackMap = this.whenRegisterMap.get(pluginName);
+            if (callbackMap) {
+                for (const [callback] of callbackMap.entries()) {
+                    const whenUnregistered = callback();
+                    callbackMap.set(callback, whenUnregistered || null);
+                }
+            }
             return plugin;
         })
             .catch((err) => {
@@ -121,11 +142,11 @@ export class PluginManager {
             });
         }
         else {
-            const { plugin, context, core } = pluginData;
-            if (core) {
-                throw new AppError("plugin:unregister_core", {
+            const { plugin, context, unremovable } = pluginData;
+            if (unremovable) {
+                throw new AppError("plugin:unregister_unremovable", {
                     message: `插件移除失败: ${pluginName}`,
-                    cause: "无法移除核心插件",
+                    cause: "不可移除的插件",
                     target: `plugin/${pluginName}`,
                 });
             }
@@ -136,6 +157,14 @@ export class PluginManager {
             this.list.delete(pluginName);
             // 移除插件注册事件
             this.app.emit("plugin:unregister", { pluginName });
+            // 如果有whenRegister的回调，调用whenUnregistered函数并将回调函数从列表中移除
+            const callbackMap = this.whenRegisterMap.get(pluginName);
+            if (callbackMap) {
+                for (const [callback, whenUnregistered] of callbackMap.entries()) {
+                    whenUnregistered?.();
+                    callbackMap.delete(callback);
+                }
+            }
         }
     }
     /** 获取插件实例 */
@@ -151,6 +180,38 @@ export class PluginManager {
     getExposes(pluginName) {
         return this.list.get(pluginName)?.exposes;
     }
+    /** 在插件已注册时执行回调
+     * param skipError 在安装来源插件调用该方法且目标插件已安装时，是否跳过回调函数抛出的错误（默认为false）
+     */
+    whenRegister(pluginName, callback /*, { skipError = false }: { skipError?: boolean } = {} */) {
+        if (!this.whenRegisterMap.has(pluginName)) {
+            // 如果目标插件的回调列表不存在，创建一个新的回调列表并添加回调函数
+            this.whenRegisterMap.set(pluginName, new Map([[callback, null]]));
+        }
+        else {
+            // 确保回调函数不重复注册
+            if (!this.whenRegisterMap.get(pluginName).has(callback)) {
+                return;
+            }
+            // 如果目标插件的回调列表已存在，直接添加回调函数
+            this.whenRegisterMap.get(pluginName).set(callback, null);
+        }
+        // 如果目标插件已经注册，直接调用回调
+        if (this.has(pluginName)) {
+            const whenUnregistered = callback();
+            this.whenRegisterMap.get(pluginName).set(callback, whenUnregistered || null);
+        }
+    }
+    /** 取消插件已注册时的执行回调 */
+    cancelWhenRegister(pluginName, callback) {
+        const callbackMap = this.whenRegisterMap.get(pluginName);
+        if (callbackMap?.has(callback)) {
+            const whenUnregistered = callbackMap.get(callback);
+            // 如果存在注销目标插件时调用的回调函数，则调用它
+            whenUnregistered?.();
+            callbackMap.delete(callback);
+        }
+    }
     toSnapshot() {
         return [...this.list.keys()].map((n) => ({ pluginName: n }));
     }

package/dist/plugin/types.d.ts

@@ -4,6 +4,7 @@ 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 interface PluginItem {
     /** 插件名称 */
@@ -29,15 +30,21 @@ export interface PluginInitOptions {
 export interface PluginRegisterOptions {
     /** 提供的插件上下文 */
     context?: PluginContext;
-    /** 核心插件，不可解除注册 */
+    /** 核心插件，不可解除注册 @deprecated */
     core?: boolean;
+    /** 不可注销 */
+    unremovable?: boolean;
+    /** 可访问App实例 */
+    accessApp?: boolean;
+    /** 插件类型 */
+    pluginType?: "core" | "framework" | "";
 }
 /** 插件上下文 */
 export interface PluginContext {
     /** 安全插件上下文 */
     safe?: boolean;
-    /** App实例，仅在核心插件上下文提供 */
-    app?: App;
+    /** 获取App实例，仅在核心插件上下文提供 */
+    getApp(): App | null;
     /** 监听事件 */
     on<K extends keyof AppEventDetailMap>(type: K, listener: AppEventListener<AppEventDetailMap[K]>): void;
     /** 单次监听事件 */
@@ -52,18 +59,18 @@ export interface PluginContext {
     error(id: string, options: ErrorOptions): AppError;
     /** 注册插件 */
     register<P extends PluginItem>(plugin: PluginConstructor<P>, options?: PluginInitOptions): Promise<P>;
-    /** 取消注册插件 */
+    /** 注销插件 */
     unregister(pluginName: string): void;
     /** 获取插件暴露对象 */
     getPluginExposes<K extends keyof AppPluginExposesMap>(pluginName: K): AppPluginExposesMap[K];
     /** 等待plugin注册 */
-    whenRegister<K extends keyof AppPluginExposesMap>(pluginName: K, callback: (exposes: AppPluginExposesMap[K]) => (() => void) | void): void;
-    whenRegister(pluginName: string, callback: () => (() => void) | void): void;
+    whenRegister(pluginName: string, callback: WhenRegisterCallback): void;
+    cancelWhenRegister(pluginName: string, callback: WhenRegisterCallback): void;
     /** 是否存在插件 */
     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;
@@ -81,7 +88,7 @@ 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]>): ValueContext<AppValueMap[K]>;
-    /** 取消注册值 */
+    /** 注销值 */
     unregisterValue(name: string): void;
     /** 监听值 */
     watch<K extends keyof AppValueMap>(name: K, watcher: (value: AppValueMap[K]) => void): void;

package/dist/value/manager.d.ts

@@ -6,7 +6,7 @@ export declare class ValueManager {
     constructor(app: App);
     /** 注册值 */
     register<T>(name: string, { get, set, pluginName }: ValueOptions<T>): ValueContext<T>;
-    /** 取消注册 */
+    /** 注销值 */
     unregister(name: string): void;
     /** 获取值 */
     get(name: string, options?: ValueAccessOptions): any;

package/dist/value/manager.js

@@ -16,7 +16,7 @@ export class ValueManager {
             },
         };
     }
-    /** 取消注册 */
+    /** 注销值 */
     unregister(name) {
         this.list.delete(name);
         this.app.emit("value:unregister", { name });

package/package.json

@@ -1,23 +1,23 @@
-{
-  "name": "floating-live",
-  "version": "0.16.6",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "author": "Minteea",
-  "license": "MIT",
-  "devDependencies": {
-    "@types/node": "^22.8.2",
-    "rimraf": "^3.0.2",
-    "ts-node": "^10.9.1",
-    "tsc-alias": "^1.8.16",
-    "typescript": "^5.6.3"
-  },
-  "scripts": {
-    "tsc": "tsc -b",
-    "clear": "rimraf dist",
-    "build": "npm run clear && tsc -b && tsc-alias",
-    "prepack": "npm run build",
-    "postpack": "npm run clear"
-  }
-}
+{
+  "name": "floating-live",
+  "version": "0.17.0-alpha.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "author": "Minteea",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^22.8.2",
+    "rimraf": "^3.0.2",
+    "ts-node": "^10.9.1",
+    "tsc-alias": "^1.8.16",
+    "typescript": "^5.6.3"
+  },
+  "scripts": {
+    "tsc": "tsc -b",
+    "clear": "rimraf dist",
+    "build": "npm run clear && tsc -b && tsc-alias",
+    "prepack": "npm run build",
+    "postpack": "npm run clear"
+  }
+}

package/playground/error.md

@@ -0,0 +1,23 @@
+错误消息机制
+
+嵌套的错误将放入cause中
+
+错误属性解析：
+
+- id: 错误id;
+- source?: 错误来源，取决于调用的插件和命令等;
+- target?: 引发错误的对象id;
+
+例如：
+
+`#plugin:register_id_missing@plugin/#unnamed 插件注册失败：缺少pluginName字段`
+`#plugin:register_id_duplicate@plugin/bilibili 插件注册失败：已存在相同id的插件`
+`#credentials:check_failed@platform/acfun 无法获取必要cookie信息`
+
+指令
+
+错误反馈机制：
+
+- 客户端发送命令导致错误时，服务端在返回前记录错误触发来源
+
+- 因用户交互导致错误时，需通过toast机制反馈

package/src/source.md

@@ -1,29 +1,29 @@
-##### 插件来源（source 字段）
-
-- managerName
-- "plugin:{pluginName}" (插件调用)
-- "" (app.emit())
-
-##### 客户端/服务端来源（client.name 字段）
-
-- "electron" (electron 客户端)
-- "web:{clinetId}" (网络客户端)
-- "server" (服务端)
-- "" (自身环境内)
-
-#### 机制
-
-- from server/node = source: "plugin:foo"
-  - to server/node = source: "plugin:foo" client: ""
-  - to client/browser = source: "plugin:foo" client: "server"
-  - to client/electron = source: "plugin:foo" client: "server"
-- from client/browser = source: "plugin:foo"
-  - to client/browser = source: "plugin:foo" client: ""
-  - to server/node = source: "plugin:foo" client: "browser:10000001"
-
-ctx.callWithOptions(name, options, ...args)
-ctx.emitWithOptions(name, detail, options)
-
-ctx.on()
-
-client.emit()
+##### 插件来源（source 字段）
+
+- managerName
+- "plugin:{pluginName}" (插件调用)
+- "" (app.emit())
+
+##### 客户端/服务端来源（client.name 字段）
+
+- "electron" (electron 客户端)
+- "web:{clinetId}" (网络客户端)
+- "server" (服务端)
+- "" (自身环境内)
+
+#### 机制
+
+- from server/node = source: "plugin:foo"
+  - to server/node = source: "plugin:foo" client: ""
+  - to client/browser = source: "plugin:foo" client: "server"
+  - to client/electron = source: "plugin:foo" client: "server"
+- from client/browser = source: "plugin:foo"
+  - to client/browser = source: "plugin:foo" client: ""
+  - to server/node = source: "plugin:foo" client: "browser:10000001"
+
+ctx.callWithOptions(name, options, ...args)
+ctx.emitWithOptions(name, detail, options)
+
+ctx.on()
+
+client.emit()

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

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

package/dist/plugin/context/CorePluginContext.js

@@ -1,25 +0,0 @@
-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.js";
-/** 核心插件，具有对程序的访问权限 */
-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();